@tstdl/base 0.93.125 → 0.93.126

package/injector/inject.d.ts

@@ -2,24 +2,24 @@ import { Injector, type ResolveManyItem, type ResolveManyReturnType } from './in
 import type { Resolvable, ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { ResolveOptions } from './types.js';
-export type InjectOptions<T, A> = ResolveOptions<T, A>;
+export type InjectOptions = ResolveOptions;
 export type InjectArgumentOptions = {
     optional?: boolean;
 };
 export type InjectionContext = {
     injector: Injector;
     argument: unknown;
-    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
         optional: true;
     }): T | undefined;
-    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions & {
         optional?: false;
     }): T;
-    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T | undefined;
-    injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T[];
+    inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T | undefined;
+    injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
     injectMany<T extends InjectManyItem<any, any>[]>(...tokens: T): InjectManyReturnType<T>;
-    injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T>;
-    injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T[]>;
+    injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
+    injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
     injectManyAsync<T extends InjectManyItem<any, any>[]>(...tokens: T): Promise<InjectManyReturnType<T>>;
 };
 export type InjectManyItem<T, A> = ResolveManyItem<T, A>;
@@ -31,13 +31,13 @@ export type InjectManyReturnType<T extends InjectManyItem<any, any>[]> = Resolve
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
     optional: true;
 }): T | undefined;
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions & {
     optional?: false;
 }): T;
-export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T | undefined;
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T | undefined;
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
  *
@@ -51,13 +51,13 @@ export declare function injectMany<T extends InjectManyItem<any, any>[]>(...toke
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A> & {
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
     optional: true;
 }): Promise<T | undefined>;
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A> & {
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions & {
     optional?: false;
 }): Promise<T>;
-export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T | undefined>;
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T | undefined>;
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
  *
@@ -71,7 +71,7 @@ export declare function injectManyAsync<T extends InjectManyItem<any, any>[]>(..
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): T[];
+export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
 /**
  * Resolves a token using the {@link Injector} of the current injection context
  *
@@ -79,7 +79,7 @@ export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?:
  * @param argument argument to resolve token with
  * @param options resolve options
  */
-export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>): Promise<T[]>;
+export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
 /**
  * Injects the resolve argument from the current resolution
  * @param _this can be used for type infer by simply passing `this`. Requires class to implement {@link Resolvable}.

package/injector/injector.d.ts

@@ -1,10 +1,47 @@
-import type { OneOrMany, Record, TypedOmit } from '../types/index.js';
+import { CircularBuffer } from '../data-structures/circular-buffer.js';
+import { MultiKeyMap } from '../data-structures/multi-key-map.js';
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import type { OneOrMany, Record, TypedOmit, WritableOneOrMany } from '../types/index.js';
+import { FactoryMap } from '../utils/factory-map.js';
+import { ForwardRef } from '../utils/object/forward-ref.js';
 import { type InjectOptions } from './inject.js';
 import { type ResolveArgument } from './interfaces.js';
 import { type Provider } from './provider.js';
+import { type AfterResolveHandler } from './resolution.js';
+import { ResolveChain } from './resolve-chain.js';
 import { type InjectionToken } from './token.js';
-import type { RegistrationOptions, ResolveOptions } from './types.js';
-export type DisposeHandler = Disposable | AsyncDisposable | (() => PromiseLike<void> | void);
+import type { AfterResolveContext, RegistrationOptions, ResolveContextData, ResolveOptions } from './types.js';
+export type DisposeHandler = Disposable | AsyncDisposable | (() => any);
+type ResolutionTag = symbol;
+type RegistrationsMap = Map<InjectionToken, WritableOneOrMany<Registration>>;
+type GlobalRegistrationsMap = Map<InjectionToken, WritableOneOrMany<GlobalRegistration>>;
+export type InternalResolveContext = {
+    resolves: number;
+    /** Currently resolving tokens (for circular dependency detection) */
+    resolving: FactoryMap<Injector, Set<InjectionToken>>;
+    /** Resolutions for resolution scoped dependencies  */
+    resolutionScopedResolutions: MultiKeyMap<[InjectionToken, unknown], Resolution<any, any>>;
+    /** All resolutions in this chain for postprocessing */
+    resolutions: Resolution<any, any>[];
+    /** All dependency accesses (including cached ones) for graph generation */
+    accesses: {
+        chain: ResolveChain;
+    }[];
+    recordAccess(chain: ResolveChain): void;
+    resolutionContextData: FactoryMap<ResolutionTag, ResolveContextData<Record>>;
+    forwardRefQueue: CircularBuffer<() => void>;
+    forwardRefs: Set<ForwardRef>;
+    $done: DeferredPromise;
+};
+export type Resolution<T, A> = {
+    tag: ResolutionTag;
+    registration: Registration<T>;
+    value: T;
+    argument: ResolveArgument<T, A>;
+    afterResolveRegistrations: AfterResolveHandler<A, Record>[];
+    afterResolveContext: AfterResolveContext<any>;
+    chain: ResolveChain;
+};
 export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & {
     provide: InjectionToken<T, A>;
     multi?: boolean;
@@ -16,6 +53,10 @@ export type GlobalRegistration<T = any, A = any> = {
     options: RegistrationOptions<T, A>;
 };
 export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
+    /**
+     * The injector this registration belongs to.
+     */
+    injector: Injector;
     /**
      * A map associating argument identities to their resolved instances of type `T`.
      */
@@ -25,7 +66,7 @@ export type GetRegistrationOptions = {
     skipSelf?: boolean | number;
     onlySelf?: boolean;
 };
-export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
+export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions];
 export type ResolveManyItem<T, A> = InjectionToken<T, A> | ResolveManyArrayItem<T, A>;
 export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T extends ResolveManyItem<infer U, any> ? U | (T extends (ResolveManyArrayItem<any, any> & [any, any, {
     optional: true;
@@ -33,14 +74,27 @@ export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T e
 export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = {
     [I in keyof T]: ResolveManyItemReturnType<T[I]>;
 };
-export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
 export declare class Injector implements AsyncDisposable {
     #private;
     readonly id: number;
     readonly name: string;
+    readonly ownerToken?: InjectionToken;
     get parent(): Injector | null;
+    get accesses(): {
+        chain: ResolveChain;
+    }[];
     get disposed(): boolean;
-    constructor(name: string, parent?: Injector | null);
+    constructor(name: string, parent?: Injector | null, ownerToken?: InjectionToken);
+    /**
+     * Add a dispose handler to this injector. The handler can be a disposable, async disposable, or a simple function. If the handler is a disposable or async disposable, it will be disposed when the injector is disposed.
+     * If the handler is a function, it will be called when the injector is disposed.
+     * @param handler dispose handler to add
+     */
+    addDisposeHandler(handler: DisposeHandler): void;
+    /** @internal */
+    static getGlobalRegistrations(): GlobalRegistrationsMap;
+    /** @internal */
+    getRegistrations(): RegistrationsMap;
     /**
      * Globally register a provider for a token
      * @param token token to register
@@ -61,9 +115,10 @@ export declare class Injector implements AsyncDisposable {
      * Creates a new child `Injector` instance with the specified name.
      *
      * @param name - The name to assign to the child injector.
+     * @param ownerToken - The token that owns this injector.
      * @returns The newly created child `Injector` instance.
      */
-    fork(name: string): Injector;
+    fork(name: string, ownerToken?: InjectionToken): Injector;
     /**
      * Register a provider for a token
      * @param token token to register
@@ -93,17 +148,49 @@ export declare class Injector implements AsyncDisposable {
      * @param token token to get registration for
      */
     getRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[];
-    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
+    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
         optional: true;
     }): T | undefined;
-    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T;
-    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T[];
+    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): T;
+    resolveWithResolutions<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
+        optional: true;
+    }): {
+        value: T | undefined;
+        resolutions: Resolution<any, any>[];
+        accesses: {
+            chain: ResolveChain;
+        }[];
+    };
+    resolveWithResolutions<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): {
+        value: T;
+        resolutions: Resolution<any, any>[];
+        accesses: {
+            chain: ResolveChain;
+        }[];
+    };
+    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): T[];
     resolveMany<T extends ResolveManyItem<any, any>[]>(...tokens: T): ResolveManyReturnType<T>;
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
         optional: true;
     }): Promise<T | undefined>;
-    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
-    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T>;
+    resolveWithResolutionsAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions & {
+        optional: true;
+    }): Promise<{
+        value: T | undefined;
+        resolutions: Resolution<any, any>[];
+        accesses: {
+            chain: ResolveChain;
+        }[];
+    }>;
+    resolveWithResolutionsAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<{
+        value: T;
+        resolutions: Resolution<any, any>[];
+        accesses: {
+            chain: ResolveChain;
+        }[];
+    }>;
+    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T[]>;
     resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>>;
     private _resolveManyTokens;
     private _resolve;
@@ -123,3 +210,4 @@ export declare class Injector implements AsyncDisposable {
 export declare function provide<T = any, A = any, D extends Record = Record>(token: InjectionToken<T, A>, provider: Provider<T, A, D> & {
     multi?: boolean;
 }): ProvidersItem<T, A, D>;
+export {};

package/injector/injector.js

@@ -1,4 +1,5 @@
 import { CancellationSignal, CancellationToken } from '../cancellation/index.js';
+import { isDevMode } from '../core.js';
 import { CircularBuffer } from '../data-structures/circular-buffer.js';
 import { MultiKeyMap } from '../data-structures/multi-key-map.js';
 import { isSyncOrAsyncDisposable } from '../disposable/disposable.js';
@@ -8,7 +9,8 @@ import { toArray } from '../utils/array/array.js';
 import { FactoryMap } from '../utils/factory-map.js';
 import { ForwardRef } from '../utils/object/forward-ref.js';
 import { objectEntries } from '../utils/object/object.js';
-import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
+import { assert, isArray, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
+import { isForwardRefToken } from './forward-ref.js';
 import { setCurrentInjectionContext } from './inject.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
@@ -28,32 +30,50 @@ export class Injector {
     #disposableStackRegistrations = new Set();
     #registrations = new Map();
     #injectorScopedResolutions = new MultiKeyMap();
-    #addDisposeHandler;
+    #accesses = [];
     id = _id++;
     name;
+    ownerToken;
     get parent() {
         return this.#parent;
     }
+    get accesses() {
+        return this.#accesses;
+    }
     get disposed() {
         return this.#disposableStack.disposed;
     }
-    constructor(name, parent = null) {
+    constructor(name, parent = null, ownerToken) {
         this.name = name;
         this.#parent = parent;
+        this.ownerToken = ownerToken;
         this.register(Injector, { useValue: this });
         this.register(CancellationSignal, { useValue: this.#disposeToken.signal });
-        this.#addDisposeHandler = (handler) => {
-            if (isSyncOrAsyncDisposable(handler)) {
-                this.#disposableStack.use(handler);
-            }
-            else {
-                this.#disposableStack.defer(handler);
-            }
-        };
         this.#disposableStack.defer(() => this.#registrations.clear());
         this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
         this.#disposableStack.defer(() => this.#disposableStackRegistrations.clear());
     }
+    /**
+     * Add a dispose handler to this injector. The handler can be a disposable, async disposable, or a simple function. If the handler is a disposable or async disposable, it will be disposed when the injector is disposed.
+     * If the handler is a function, it will be called when the injector is disposed.
+     * @param handler dispose handler to add
+     */
+    addDisposeHandler(handler) {
+        if (isSyncOrAsyncDisposable(handler)) {
+            this.#disposableStack.use(handler);
+        }
+        else {
+            this.#disposableStack.defer(handler);
+        }
+    }
+    /** @internal */
+    static getGlobalRegistrations() {
+        return Injector.#globalRegistrations;
+    }
+    /** @internal */
+    getRegistrations() {
+        return this.#registrations;
+    }
     /**
      * Globally register a provider for a token
      * @param token token to register
@@ -92,10 +112,11 @@ export class Injector {
      * Creates a new child `Injector` instance with the specified name.
      *
      * @param name - The name to assign to the child injector.
+     * @param ownerToken - The token that owns this injector.
      * @returns The newly created child `Injector` instance.
      */
-    fork(name) {
-        const child = new Injector(name, this);
+    fork(name, ownerToken) {
+        const child = new Injector(name, this, ownerToken);
         this.#children.push(child);
         this.#disposableStack.use(child);
         return child;
@@ -115,6 +136,7 @@ export class Injector {
                 provider,
                 providers: options.providers ?? [],
                 options: { multi, ...options },
+                injector: this,
                 resolutions: new Map(),
             };
             addRegistration(this.#registrations, registration);
@@ -176,8 +198,12 @@ export class Injector {
         return registration;
     }
     resolve(token, argument, options = {}) {
-        const context = newInternalResolveContext();
-        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
+        const { value } = this.resolveWithResolutions(token, argument, options);
+        return value;
+    }
+    resolveWithResolutions(token, argument, options = {}) {
+        const context = newInternalResolveContext(this);
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token, options));
         try {
             postProcess(context);
             context.$done.resolve();
@@ -187,13 +213,13 @@ export class Injector {
             throw error;
         }
         if (context.forwardRefs.has(value)) {
-            return ForwardRef.deref(value);
+            return { value: ForwardRef.deref(value), resolutions: context.resolutions, accesses: context.accesses };
         }
-        return value;
+        return { value, resolutions: context.resolutions, accesses: context.accesses };
     }
     resolveAll(token, argument, options = {}) {
-        const context = newInternalResolveContext();
-        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
+        const context = newInternalResolveContext(this);
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token, { ...options, multi: true }));
         try {
             postProcess(context);
             context.$done.resolve();
@@ -208,7 +234,7 @@ export class Injector {
         return values;
     }
     resolveMany(...tokens) {
-        const context = newInternalResolveContext();
+        const context = newInternalResolveContext(this);
         const values = this._resolveManyTokens(tokens, context);
         try {
             postProcess(context);
@@ -223,8 +249,12 @@ export class Injector {
             : value);
     }
     async resolveAsync(token, argument, options = {}) {
-        const context = newInternalResolveContext();
-        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
+        const { value } = await this.resolveWithResolutionsAsync(token, argument, options);
+        return value;
+    }
+    async resolveWithResolutionsAsync(token, argument, options = {}) {
+        const context = newInternalResolveContext(this);
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token, options));
         try {
             await postProcessAsync(context);
             context.$done.resolve();
@@ -234,13 +264,13 @@ export class Injector {
             throw error;
         }
         if (context.forwardRefs.has(value)) {
-            return ForwardRef.deref(value);
+            return { value: ForwardRef.deref(value), resolutions: context.resolutions, accesses: context.accesses };
         }
-        return value;
+        return { value, resolutions: context.resolutions, accesses: context.accesses };
     }
     async resolveAllAsync(token, argument, options = {}) {
-        const context = newInternalResolveContext();
-        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
+        const context = newInternalResolveContext(this);
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token, { ...options, multi: true }));
         try {
             await postProcessAsync(context);
             context.$done.resolve();
@@ -255,7 +285,7 @@ export class Injector {
         return values;
     }
     async resolveManyAsync(...tokens) {
-        const context = newInternalResolveContext();
+        const context = newInternalResolveContext(this);
         const values = this._resolveManyTokens(tokens, context);
         try {
             await postProcessAsync(context);
@@ -271,7 +301,7 @@ export class Injector {
     }
     _resolveManyTokens(tokens, context) {
         return tokens.map((token) => (isArray(token)
-            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(this, token[0]))
+            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(this, token[0], token[2] ?? {}))
             : this._resolve(token, undefined, {}, context, ResolveChain.startWith(this, token))));
     }
     _resolve(token, argument, options, context, chain) {
@@ -283,11 +313,11 @@ export class Injector {
             }
             return this.#parent?._resolve(token, argument, { ...options, skipSelf: skipSelf - 1 }, context, chain);
         }
-        if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
+        if (isForwardRefToken(token)) {
             assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
-            const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken : undefined });
-            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+            const forwardToken = token.tokenFactory();
+            const forwardRef = ForwardRef.create({ typeHint: token.typeHint ?? (isFunction(forwardToken) ? forwardToken : undefined) });
+            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;
         }
@@ -297,7 +327,7 @@ export class Injector {
         const registration = this.tryGetRegistration(token, options);
         if (isDefined(registration)) {
             const singleRegistration = isArray(registration) ? registration[0] : registration;
-            return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+            return this._resolveRegistration(singleRegistration, argument, options, context, chain.withResolvedBy(singleRegistration.injector));
         }
         if ((options.onlySelf != true) && isNotNull(this.#parent)) {
             return this.#parent._resolve(token, argument, options, context, chain);
@@ -316,10 +346,10 @@ export class Injector {
             }
             return this.#parent?._resolveAll(token, argument, { ...options, skipSelf: skipSelf - 1 }, context, chain) ?? [];
         }
-        if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
-            const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken : undefined });
-            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
+        if (isForwardRefToken(token)) {
+            const forwardToken = token.tokenFactory();
+            const forwardRef = ForwardRef.create({ typeHint: token.typeHint ?? (isFunction(forwardToken) ? forwardToken : undefined) });
+            context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;
         }
@@ -329,7 +359,7 @@ export class Injector {
         const registration = this.tryGetRegistration(token);
         if (isDefined(registration)) {
             const registrations = isArray(registration) ? registration : [registration];
-            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain.withResolvedBy(reg.injector)));
         }
         if ((options.onlySelf != true) && isNotNull(this.#parent)) {
             return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
@@ -351,18 +381,22 @@ export class Injector {
             resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider(this.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
         }
         const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
+        chain = chain.withArgument(resolveArgument).withMetadata({ registration });
         if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
+            context.recordAccess(chain.withMetadata({ isCached: true }));
             return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
         }
         else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
+            context.recordAccess(chain.withMetadata({ isCached: true }));
             return this.#injectorScopedResolutions.getFlat(token, argumentIdentity).value;
         }
         else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
+            context.recordAccess(chain.withMetadata({ isCached: true }));
             return registration.resolutions.get(argumentIdentity);
         }
         // A new scope is only needed if we are instantiating a class, running a factory, or if the registration explicitly defines scoped providers.
         const needsNewScope = isClassProvider(provider) || isFactoryProvider(provider) || (providers.length > 0);
-        const injector = needsNewScope ? this.fork(`[${getTokenName(token)}]Injector`) : this;
+        const injector = needsNewScope ? this.fork(`${getTokenName(token)}Injector`, token) : this;
         for (const nestedProvider of providers) {
             injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
         }
@@ -371,6 +405,8 @@ export class Injector {
         try {
             const resolutionContext = { afterResolveRegistrations: [] };
             const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
+            chain = chain.withMetadata({ isCached: false });
+            context.recordAccess(chain);
             const resolution = {
                 tag: resolutionTag,
                 registration,
@@ -444,27 +480,18 @@ export class Injector {
         }
     }
     resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
-        const getChain = (injectToken) => chain.addParameter(this, constructor, metadata.index, injectToken);
         const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
         const injectToken = (injectMetadata.injectToken ?? metadata.type);
+        const getChain = (injectToken) => chain.addParameter(this, constructor, metadata.index, injectToken, { optional: injectMetadata.optional, multi: injectMetadata.resolveAll });
         if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
             return wrapInResolveError(() => injectMetadata.injectArgumentMapper(resolveArgument), 'Error in injectArgumentMapper', getChain(injectToken));
         }
         const parameterResolveArgument = wrapInResolveError(() => injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken))), 'Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider)', getChain(injectToken));
-        const { forwardRef } = injectMetadata;
-        if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
-            const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
-            throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
-        }
         const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
-        const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
-        if (isDefined(injectMetadata.mapper)) {
-            return wrapInResolveError(() => injectMetadata.mapper(resolved), 'Error in inject mapper', getChain(injectToken));
-        }
-        return resolved;
+        return this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(injectToken));
     }
     resolveInjection(token, argument, options, context, injectIndex, chain) {
-        return this._resolve(token, argument, options, context, chain.addInject(this, token, injectIndex));
+        return this._resolve(token, argument, options, context, chain.addInject(this, token, injectIndex, { optional: options.optional }));
     }
     async resolveInjectionAsync(token, argument, options, context, injectIndex, chain) {
         const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
@@ -472,7 +499,7 @@ export class Injector {
         return value;
     }
     resolveInjectionAll(token, argument, options, context, injectIndex, chain) {
-        return this._resolveAll(token, argument, options, context, chain.addInject(this, token, injectIndex));
+        return this._resolveAll(token, argument, options, context, chain.addInject(this, token, injectIndex, { optional: options.optional, multi: true }));
     }
     async resolveInjectionAllAsync(token, argument, options, context, injectIndex, chain) {
         const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
@@ -484,7 +511,7 @@ export class Injector {
             resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
             resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
             cancellationSignal: this.#disposeToken,
-            addDisposeHandler: this.#addDisposeHandler,
+            addDisposeHandler: (handler) => this.addDisposeHandler(handler),
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
@@ -493,7 +520,7 @@ export class Injector {
     getAfterResolveContext(resolutionTag, resolveContext) {
         return {
             cancellationSignal: this.#disposeToken,
-            addDisposeHandler: this.#addDisposeHandler,
+            addDisposeHandler: (handler) => this.addDisposeHandler(handler),
             get data() {
                 return resolveContext.resolutionContextData.get(resolutionTag);
             },
@@ -536,24 +563,41 @@ function addRegistration(registrations, registration) {
         const tokenName = getTokenName(registration.token);
         throw new RegistrationError(`Cannot mix multi and non-multi registrations for token: ${tokenName}.`);
     }
-    if (multi && existingIsMulti) {
-        existingRegistration.push(registration);
+    if (multi) {
+        if (existingIsMulti) {
+            existingRegistration.push(registration);
+        }
+        else {
+            registrations.set(registration.token, [registration]);
+        }
     }
     else {
-        registrations.set(registration.token, multi ? [registration] : registration);
+        registrations.set(registration.token, registration);
     }
 }
-function newInternalResolveContext() {
-    return {
+function newInternalResolveContext(injector) {
+    const context = {
         resolves: 0,
         resolving: new FactoryMap(() => new Set()),
         resolutionScopedResolutions: new MultiKeyMap(),
         resolutions: [],
+        accesses: [],
+        recordAccess(chain) {
+            context.accesses.push({ chain });
+            if (isDevMode()) {
+                let current = injector;
+                while (current != null) {
+                    current.accesses.push({ chain });
+                    current = current.parent;
+                }
+            }
+        },
         resolutionContextData: new FactoryMap(() => ({})),
         forwardRefQueue: new CircularBuffer(),
         forwardRefs: new Set(),
         $done: new DeferredPromise(),
     };
+    return context;
 }
 function postProcess(context) {
     for (const fn of context.forwardRefQueue.consume()) {