@navios/di 0.7.1 → 0.9.0

package/lib/browser/internal/lifecycle/circular-detector.d.mts

@@ -0,0 +1,39 @@
+import { InstanceHolder } from "../holder/instance-holder.mjs";
+
+//#region src/internal/lifecycle/circular-detector.d.mts
+
+/**
+ * Detects circular dependencies by analyzing the waitingFor relationships
+ * between service holders.
+ *
+ * Uses BFS to traverse the waitingFor graph starting from a target holder
+ * and checks if following the chain leads back to the waiter, indicating a circular dependency.
+ *
+ * Note: In production (NODE_ENV === 'production'), detection is skipped for performance.
+ */
+declare class CircularDetector {
+  /**
+   * Detects if waiting for `targetName` from `waiterName` would create a cycle.
+   *
+   * This works by checking if `targetName` (or any holder in its waitingFor chain)
+   * is currently waiting for `waiterName`. If so, waiting would create a deadlock.
+   *
+   * In production mode, this always returns null to skip the BFS traversal overhead.
+   *
+   * @param waiterName The name of the holder that wants to wait
+   * @param targetName The name of the holder being waited on
+   * @param getHolder Function to retrieve a holder by name
+   * @returns The cycle path if a cycle is detected, null otherwise
+   */
+  static detectCycle(waiterName: string, targetName: string, getHolder: (name: string) => InstanceHolder | undefined): string[] | null;
+  /**
+   * Formats a cycle path into a human-readable string.
+   *
+   * @param cycle The cycle path (array of service names)
+   * @returns Formatted string like "ServiceA -> ServiceB -> ServiceA"
+   */
+  static formatCycle(cycle: string[]): string;
+}
+//#endregion
+export { CircularDetector };
+//# sourceMappingURL=circular-detector.d.mts.map

package/lib/browser/internal/lifecycle/circular-detector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circular-detector.d.mts","names":[],"sources":["../../../../src/internal/lifecycle/circular-detector.mts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;cAAa,gBAAA;;;;;;;;;;;;;;0FAiBoB"}

package/lib/browser/internal/lifecycle/circular-detector.mjs

@@ -0,0 +1,55 @@
+//#region src/internal/lifecycle/circular-detector.mts
+/**
+* Detects circular dependencies by analyzing the waitingFor relationships
+* between service holders.
+*
+* Uses BFS to traverse the waitingFor graph starting from a target holder
+* and checks if following the chain leads back to the waiter, indicating a circular dependency.
+*
+* Note: In production (NODE_ENV === 'production'), detection is skipped for performance.
+*/ var CircularDetector = class {
+	/**
+	* Detects if waiting for `targetName` from `waiterName` would create a cycle.
+	*
+	* This works by checking if `targetName` (or any holder in its waitingFor chain)
+	* is currently waiting for `waiterName`. If so, waiting would create a deadlock.
+	*
+	* In production mode, this always returns null to skip the BFS traversal overhead.
+	*
+	* @param waiterName The name of the holder that wants to wait
+	* @param targetName The name of the holder being waited on
+	* @param getHolder Function to retrieve a holder by name
+	* @returns The cycle path if a cycle is detected, null otherwise
+	*/ static detectCycle(waiterName, targetName, getHolder) {
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [{
+			name: targetName,
+			path: [waiterName, targetName]
+		}];
+		while (queue.length > 0) {
+			const { name: currentName, path } = queue.shift();
+			if (currentName === waiterName) return path;
+			if (visited.has(currentName)) continue;
+			visited.add(currentName);
+			const holder = getHolder(currentName);
+			if (!holder) continue;
+			for (const waitingForName of holder.waitingFor) if (!visited.has(waitingForName)) queue.push({
+				name: waitingForName,
+				path: [...path, waitingForName]
+			});
+		}
+		return null;
+	}
+	/**
+	* Formats a cycle path into a human-readable string.
+	*
+	* @param cycle The cycle path (array of service names)
+	* @returns Formatted string like "ServiceA -> ServiceB -> ServiceA"
+	*/ static formatCycle(cycle) {
+		return cycle.join(" -> ");
+	}
+};
+
+//#endregion
+export { CircularDetector };
+//# sourceMappingURL=circular-detector.mjs.map

package/lib/browser/internal/lifecycle/circular-detector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"circular-detector.mjs","names":["isProduction","process","env","NODE_ENV","CircularDetector","detectCycle","waiterName","targetName","getHolder","visited","Set","queue","name","path","length","currentName","shift","has","add","holder","waitingForName","waitingFor","push","formatCycle","cycle","join"],"sources":["../../../../src/internal/lifecycle/circular-detector.mts"],"sourcesContent":["import type { InstanceHolder } from '../holder/instance-holder.mjs'\n\n/**\n * Whether we're running in production mode.\n * In production, circular dependency detection is skipped for performance.\n */\nconst isProduction = process.env.NODE_ENV === 'production'\n\n/**\n * Detects circular dependencies by analyzing the waitingFor relationships\n * between service holders.\n *\n * Uses BFS to traverse the waitingFor graph starting from a target holder\n * and checks if following the chain leads back to the waiter, indicating a circular dependency.\n *\n * Note: In production (NODE_ENV === 'production'), detection is skipped for performance.\n */\nexport class CircularDetector {\n  /**\n   * Detects if waiting for `targetName` from `waiterName` would create a cycle.\n   *\n   * This works by checking if `targetName` (or any holder in its waitingFor chain)\n   * is currently waiting for `waiterName`. If so, waiting would create a deadlock.\n   *\n   * In production mode, this always returns null to skip the BFS traversal overhead.\n   *\n   * @param waiterName The name of the holder that wants to wait\n   * @param targetName The name of the holder being waited on\n   * @param getHolder Function to retrieve a holder by name\n   * @returns The cycle path if a cycle is detected, null otherwise\n   */\n  static detectCycle(\n    waiterName: string,\n    targetName: string,\n    getHolder: (name: string) => InstanceHolder | undefined,\n  ): string[] | null {\n    // Skip circular dependency detection in production for performance\n    if (isProduction) {\n      return null\n    }\n\n    // Use BFS to find if there's a path from targetName back to waiterName\n    const visited = new Set<string>()\n    const queue: Array<{ name: string; path: string[] }> = [\n      { name: targetName, path: [waiterName, targetName] },\n    ]\n\n    while (queue.length > 0) {\n      const { name: currentName, path } = queue.shift()!\n\n      // If we've reached back to the waiter, we have a cycle\n      if (currentName === waiterName) {\n        return path\n      }\n\n      // Skip if already visited\n      if (visited.has(currentName)) {\n        continue\n      }\n      visited.add(currentName)\n\n      // Get the holder and check what it's waiting for\n      const holder = getHolder(currentName)\n      if (!holder) {\n        continue\n      }\n\n      // Add all services this holder is waiting for to the queue\n      for (const waitingForName of holder.waitingFor) {\n        if (!visited.has(waitingForName)) {\n          queue.push({\n            name: waitingForName,\n            path: [...path, waitingForName],\n          })\n        }\n      }\n    }\n\n    // No path found from target back to waiter, no cycle\n    return null\n  }\n\n  /**\n   * Formats a cycle path into a human-readable string.\n   *\n   * @param cycle The cycle path (array of service names)\n   * @returns Formatted string like \"ServiceA -> ServiceB -> ServiceA\"\n   */\n  static formatCycle(cycle: string[]): string {\n    return cycle.join(' -> ')\n  }\n}\n\n"],"mappings":";;;;;;;;;GAiBA,IAAaI,mBAAb,MAAaA;;;;;;;;;;;;;IAcX,OAAOC,YACLC,YACAC,YACAC,WACiB;EAOjB,MAAMC,0BAAU,IAAIC,KAAAA;EACpB,MAAMC,QAAiD,CACrD;GAAEC,MAAML;GAAYM,MAAM,CAACP,YAAYC,WAAW;GAAC,CACpD;AAED,SAAOI,MAAMG,SAAS,GAAG;GACvB,MAAM,EAAEF,MAAMG,aAAaF,SAASF,MAAMK,OAAK;AAG/C,OAAID,gBAAgBT,WAClB,QAAOO;AAIT,OAAIJ,QAAQQ,IAAIF,YAAAA,CACd;AAEFN,WAAQS,IAAIH,YAAAA;GAGZ,MAAMI,SAASX,UAAUO,YAAAA;AACzB,OAAI,CAACI,OACH;AAIF,QAAK,MAAMC,kBAAkBD,OAAOE,WAClC,KAAI,CAACZ,QAAQQ,IAAIG,eAAAA,CACfT,OAAMW,KAAK;IACTV,MAAMQ;IACNP,MAAM,IAAIA,MAAMO,eAAe;IACjC,CAAA;;AAMN,SAAO;;;;;;;IAST,OAAOG,YAAYC,OAAyB;AAC1C,SAAOA,MAAMC,KAAK,OAAA"}

package/lib/browser/internal/lifecycle/lifecycle-event-bus.d.mts

@@ -0,0 +1,18 @@
+//#region src/internal/lifecycle/lifecycle-event-bus.d.mts
+/**
+ * Event bus for service lifecycle events (create, destroy, etc.).
+ *
+ * Enables loose coupling between services by allowing them to subscribe
+ * to lifecycle events of their dependencies without direct references.
+ * Used primarily for invalidation cascading.
+ */
+declare class LifecycleEventBus {
+  private readonly logger;
+  private listeners;
+  constructor(logger?: Console | null);
+  on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
+  emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
+}
+//#endregion
+export { LifecycleEventBus };
+//# sourceMappingURL=lifecycle-event-bus.d.mts.map

package/lib/browser/internal/lifecycle/lifecycle-event-bus.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-event-bus.d.mts","names":[],"sources":["../../../../src/internal/lifecycle/lifecycle-event-bus.mts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;AAgCuC,cAhC1B,iBAAA,CAgC0B;;;uBA9BA;mFAI5B,yBACW;oCAyBiB,QAAA"}

package/lib/browser/internal/lifecycle/lifecycle-event-bus.mjs

@@ -0,0 +1,43 @@
+//#region src/internal/lifecycle/lifecycle-event-bus.mts
+/**
+* Event bus for service lifecycle events (create, destroy, etc.).
+*
+* Enables loose coupling between services by allowing them to subscribe
+* to lifecycle events of their dependencies without direct references.
+* Used primarily for invalidation cascading.
+*/ var LifecycleEventBus = class {
+	logger;
+	listeners = /* @__PURE__ */ new Map();
+	constructor(logger = null) {
+		this.logger = logger;
+	}
+	on(ns, event, listener) {
+		this.logger?.debug(`[LifecycleEventBus]#on(): ns:${ns} event:${event}`);
+		if (!this.listeners.has(ns)) this.listeners.set(ns, /* @__PURE__ */ new Map());
+		const nsEvents = this.listeners.get(ns);
+		if (!nsEvents.has(event)) nsEvents.set(event, /* @__PURE__ */ new Set());
+		nsEvents.get(event).add(listener);
+		return () => {
+			nsEvents.get(event)?.delete(listener);
+			if (nsEvents.get(event)?.size === 0) nsEvents.delete(event);
+			if (nsEvents.size === 0) this.listeners.delete(ns);
+		};
+	}
+	async emit(key, event) {
+		if (!this.listeners.has(key)) return;
+		const events = this.listeners.get(key);
+		this.logger?.debug(`[LifecycleEventBus]#emit(): ${key}:${event}`);
+		return await Promise.allSettled([...events.get(event) ?? []].map((listener) => listener(event))).then((results) => {
+			const res = results.filter((result) => result.status === "rejected").map((result) => {
+				this.logger?.warn(`[LifecycleEventBus]#emit(): ${key}:${event} rejected with`, result.reason);
+				return result;
+			});
+			if (res.length > 0) return Promise.reject(res);
+			return results;
+		});
+	}
+};
+
+//#endregion
+export { LifecycleEventBus };
+//# sourceMappingURL=lifecycle-event-bus.mjs.map

package/lib/browser/internal/lifecycle/lifecycle-event-bus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-event-bus.mjs","names":["LifecycleEventBus","listeners","Map","logger","on","ns","event","listener","debug","has","set","nsEvents","get","Set","add","delete","size","emit","key","events","res","Promise","allSettled","map","then","results","filter","result","status","warn","reason","length","reject"],"sources":["../../../../src/internal/lifecycle/lifecycle-event-bus.mts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-object-type */\n/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n\ntype ListenersMap = Map<string, Map<string, Set<Function>>>\n\n/**\n * Event bus for service lifecycle events (create, destroy, etc.).\n *\n * Enables loose coupling between services by allowing them to subscribe\n * to lifecycle events of their dependencies without direct references.\n * Used primarily for invalidation cascading.\n */\n/* eslint-disable @typescript-eslint/no-non-null-assertion */\nexport class LifecycleEventBus {\n  private listeners: ListenersMap = new Map()\n  constructor(private readonly logger: Console | null = null) {}\n\n  on<Event extends string | `pre:${string}` | `post:${string}`>(\n    ns: string,\n    event: Event,\n    listener: (event: Event) => void,\n  ) {\n    this.logger?.debug(`[LifecycleEventBus]#on(): ns:${ns} event:${event}`)\n    if (!this.listeners.has(ns)) {\n      this.listeners.set(ns, new Map())\n    }\n\n    const nsEvents = this.listeners.get(ns)!\n    if (!nsEvents.has(event)) {\n      nsEvents.set(event, new Set())\n    }\n\n    nsEvents.get(event)!.add(listener)\n\n    return () => {\n      nsEvents.get(event)?.delete(listener)\n      if (nsEvents.get(event)?.size === 0) {\n        nsEvents.delete(event)\n      }\n      if (nsEvents.size === 0) {\n        this.listeners.delete(ns)\n      }\n    }\n  }\n\n  async emit(key: string, event: string) {\n    if (!this.listeners.has(key)) {\n      return\n    }\n\n    const events = this.listeners.get(key)!\n\n    this.logger?.debug(`[LifecycleEventBus]#emit(): ${key}:${event}`)\n\n    const res = await Promise.allSettled(\n      [...(events.get(event) ?? [])!].map((listener) => listener(event)),\n    ).then((results) => {\n      const res = results\n        .filter((result) => result.status === 'rejected')\n        .map((result: PromiseRejectedResult) => {\n          this.logger?.warn(\n            `[LifecycleEventBus]#emit(): ${key}:${event} rejected with`,\n            result.reason,\n          )\n          return result\n        })\n\n      if (res.length > 0) {\n        return Promise.reject(res)\n      }\n      return results\n    })\n    return res\n  }\n}\n\n"],"mappings":";;;;;;;GAaA,IAAaA,oBAAb,MAAaA;;CACHC,4BAA0B,IAAIC,KAAAA;CACtC,YAAY,SAA0C,MAAM;OAA/BC,SAAAA;;CAE7BC,GACEC,IACAC,OACAC,UACA;AACA,OAAKJ,QAAQK,MAAM,gCAAgCH,GAAG,SAASC,QAAO;AACtE,MAAI,CAAC,KAAKL,UAAUQ,IAAIJ,GAAAA,CACtB,MAAKJ,UAAUS,IAAIL,oBAAI,IAAIH,KAAAA,CAAAA;EAG7B,MAAMS,WAAW,KAAKV,UAAUW,IAAIP,GAAAA;AACpC,MAAI,CAACM,SAASF,IAAIH,MAAAA,CAChBK,UAASD,IAAIJ,uBAAO,IAAIO,KAAAA,CAAAA;AAG1BF,WAASC,IAAIN,MAAAA,CAAQQ,IAAIP,SAAAA;AAEzB,eAAO;AACLI,YAASC,IAAIN,MAAAA,EAAQS,OAAOR,SAAAA;AAC5B,OAAII,SAASC,IAAIN,MAAAA,EAAQU,SAAS,EAChCL,UAASI,OAAOT,MAAAA;AAElB,OAAIK,SAASK,SAAS,EACpB,MAAKf,UAAUc,OAAOV,GAAAA;;;CAK5B,MAAMY,KAAKC,KAAaZ,OAAe;AACrC,MAAI,CAAC,KAAKL,UAAUQ,IAAIS,IAAAA,CACtB;EAGF,MAAMC,SAAS,KAAKlB,UAAUW,IAAIM,IAAAA;AAElC,OAAKf,QAAQK,MAAM,+BAA+BU,IAAI,GAAGZ,QAAO;AAoBhE,SAlBY,MAAMe,QAAQC,WACxB,IAAKH,OAAOP,IAAIN,MAAAA,IAAU,EAAE,CAAG,CAACiB,KAAKhB,aAAaA,SAASD,MAAAA,CAAAA,CAAAA,CAC3DkB,MAAMC,YAAAA;GACN,MAAML,MAAMK,QACTC,QAAQC,WAAWA,OAAOC,WAAW,WAAA,CACrCL,KAAKI,WAAAA;AACJ,SAAKxB,QAAQ0B,KACX,+BAA+BX,IAAI,GAAGZ,MAAM,iBAC5CqB,OAAOG,OAAM;AAEf,WAAOH;KACT;AAEF,OAAIP,IAAIW,SAAS,EACf,QAAOV,QAAQW,OAAOZ,IAAAA;AAExB,UAAOK;IACT"}

package/lib/browser/internal/stub-factory-class.d.mts

@@ -0,0 +1,14 @@
+//#region src/internal/stub-factory-class.d.mts
+/**
+ * Stub factory class used when registering InjectionTokens without a real class implementation.
+ * This is used in ScopedContainer.addInstance() to allow registering tokens that don't have
+ * a corresponding class, while preventing accidental instantiation.
+ *
+ * @internal
+ */
+declare class StubFactoryClass {
+  constructor();
+}
+//#endregion
+export { StubFactoryClass };
+//# sourceMappingURL=stub-factory-class.d.mts.map

package/lib/browser/internal/stub-factory-class.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-factory-class.d.mts","names":[],"sources":["../../../src/internal/stub-factory-class.mts"],"sourcesContent":[],"mappings":";;AASA;;;;;;cAAa,gBAAA"}

package/lib/browser/internal/stub-factory-class.mjs

@@ -0,0 +1,18 @@
+import { DIError } from "../errors/di-error.mjs";
+
+//#region src/internal/stub-factory-class.mts
+/**
+* Stub factory class used when registering InjectionTokens without a real class implementation.
+* This is used in ScopedContainer.addInstance() to allow registering tokens that don't have
+* a corresponding class, while preventing accidental instantiation.
+*
+* @internal
+*/ var StubFactoryClass = class {
+	constructor() {
+		throw DIError.factoryNotFound("Trying to get instance of factory without real implementation");
+	}
+};
+
+//#endregion
+export { StubFactoryClass };
+//# sourceMappingURL=stub-factory-class.mjs.map

package/lib/browser/internal/stub-factory-class.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-factory-class.mjs","names":["DIError","StubFactoryClass","factoryNotFound"],"sources":["../../../src/internal/stub-factory-class.mts"],"sourcesContent":["import { DIError } from '../errors/di-error.mjs'\n\n/**\n * Stub factory class used when registering InjectionTokens without a real class implementation.\n * This is used in ScopedContainer.addInstance() to allow registering tokens that don't have\n * a corresponding class, while preventing accidental instantiation.\n *\n * @internal\n */\nexport class StubFactoryClass {\n  constructor() {\n    throw DIError.factoryNotFound(\n      'Trying to get instance of factory without real implementation',\n    )\n  }\n}\n"],"mappings":";;;;;;;;;GASA,IAAaC,mBAAb,MAAaA;CACX,cAAc;AACZ,QAAMD,QAAQE,gBACZ,gEAAA"}

package/lib/browser/symbols/injectable-token.d.mts

@@ -0,0 +1,5 @@
+//#region src/symbols/injectable-token.d.mts
+declare const InjectableTokenMeta: unique symbol;
+//#endregion
+export { InjectableTokenMeta };
+//# sourceMappingURL=injectable-token.d.mts.map

package/lib/browser/symbols/injectable-token.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable-token.d.mts","names":[],"sources":["../../../src/symbols/injectable-token.mts"],"sourcesContent":[],"mappings":";cAAa"}

package/lib/browser/symbols/injectable-token.mjs

@@ -0,0 +1,6 @@
+//#region src/symbols/injectable-token.mts
+const InjectableTokenMeta = /* @__PURE__ */ Symbol.for("InjectableTokenMeta");
+
+//#endregion
+export { InjectableTokenMeta };
+//# sourceMappingURL=injectable-token.mjs.map

package/lib/browser/symbols/injectable-token.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable-token.mjs","names":[],"sources":["../../../src/symbols/injectable-token.mts"],"sourcesContent":["export const InjectableTokenMeta = /* #__PURE__ */ Symbol.for(\n  'InjectableTokenMeta',\n)\n"],"mappings":";AAAA,MAAa,sBAAsC,uBAAO,IACxD,sBACD"}

package/lib/browser/token/injection-token.d.mts

@@ -0,0 +1,55 @@
+import { FactoryContext } from "../internal/context/factory-context.mjs";
+import { ZodObject, ZodOptional, ZodRecord, z } from "zod/v4";
+
+//#region src/token/injection-token.d.mts
+type ClassType = new (...args: any[]) => any;
+type ClassTypeWithoutArguments = new () => any;
+type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
+type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
+type BaseInjectionTokenSchemaType = ZodObject | ZodRecord;
+type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject> | ZodOptional<ZodRecord>;
+type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
+declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown, Required extends boolean = (S extends ZodOptional<ZodObject> ? false : S extends ZodOptional<ZodRecord> ? false : S extends ZodObject ? true : S extends ZodRecord ? true : false)> {
+  readonly name: string | symbol | ClassType;
+  readonly schema: ZodObject | undefined;
+  readonly id: string;
+  private formattedName;
+  constructor(name: string | symbol | ClassType, schema: ZodObject | undefined, customId?: string);
+  static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
+  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): Schema['_def']['type'] extends 'ZodOptional' ? InjectionToken<InstanceType<T>, Schema, false> : InjectionToken<InstanceType<T>, Schema, true>;
+  static create<T>(name: string | symbol): InjectionToken<T, undefined>;
+  static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
+  static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
+  static factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
+  static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
+  toString(): string;
+}
+declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
+  readonly token: InjectionToken<T, S>;
+  readonly value: z.input<S>;
+  id: string;
+  name: string | symbol | ClassType;
+  schema: InjectionTokenSchemaType;
+  constructor(token: InjectionToken<T, S>, value: z.input<S>);
+  toString(): string;
+}
+declare class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
+  readonly token: InjectionToken<T, S>;
+  readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>;
+  value?: z.input<S>;
+  resolved: boolean;
+  id: string;
+  name: string | symbol | ClassType;
+  schema: InjectionTokenSchemaType;
+  constructor(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>);
+  resolve(ctx: FactoryContext): Promise<z.input<S>>;
+  toString(): string;
+}
+type AnyInjectableType = ClassType | InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+type InjectionTokenType = InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
+//#endregion
+export { AnyInjectableType, BaseInjectionTokenSchemaType, BoundInjectionToken, ClassType, ClassTypeWithArgument, ClassTypeWithInstance, ClassTypeWithInstanceAndArgument, ClassTypeWithInstanceAndOptionalArgument, ClassTypeWithOptionalArgument, ClassTypeWithoutArguments, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType, InjectionTokenType, OptionalInjectionTokenSchemaType };
+//# sourceMappingURL=injection-token.d.mts.map

package/lib/browser/token/injection-token.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-token.d.mts","names":[],"sources":["../../../src/token/injection-token.mts"],"sourcesContent":[],"mappings":"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"}

package/lib/browser/token/injection-token.mjs

@@ -0,0 +1,100 @@
+//#region src/token/injection-token.mts
+/**
+* Simple hash function for deterministic ID generation
+*/ function simpleHash(str) {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return Math.abs(hash).toString(36);
+}
+/**
+* Generate deterministic ID from token name
+*/ function generateTokenId(name, customId) {
+	if (customId) return customId;
+	let base;
+	if (typeof name === "function") base = `${name.name}_${name.toString()}`;
+	else if (typeof name === "symbol") base = `symbol_${name.toString()}`;
+	else base = `token_${name}`;
+	return `${base.split("_")[0]}_${simpleHash(base)}`;
+}
+var InjectionToken = class InjectionToken {
+	name;
+	schema;
+	id;
+	formattedName = null;
+	constructor(name, schema, customId) {
+		this.name = name;
+		this.schema = schema;
+		this.id = generateTokenId(name, customId);
+	}
+	static create(name, schema, customId) {
+		return new InjectionToken(name, schema, customId);
+	}
+	static bound(token, value) {
+		return new BoundInjectionToken(token, value);
+	}
+	static factory(token, factory) {
+		return new FactoryInjectionToken(token, factory);
+	}
+	static refineType(token) {
+		return token;
+	}
+	toString() {
+		if (this.formattedName) return this.formattedName;
+		const { name } = this;
+		if (typeof name === "function") this.formattedName = `${name.name}(${this.id})`;
+		else if (typeof name === "symbol") this.formattedName = `${name.toString()}(${this.id})`;
+		else this.formattedName = `${name}(${this.id})`;
+		return this.formattedName;
+	}
+};
+var BoundInjectionToken = class {
+	token;
+	value;
+	id;
+	name;
+	schema;
+	constructor(token, value) {
+		this.token = token;
+		this.value = value;
+		this.name = token.name;
+		this.id = token.id;
+		this.schema = token.schema;
+	}
+	toString() {
+		return this.token.toString();
+	}
+};
+var FactoryInjectionToken = class {
+	token;
+	factory;
+	value;
+	resolved = false;
+	id;
+	name;
+	schema;
+	constructor(token, factory) {
+		this.token = token;
+		this.factory = factory;
+		this.name = token.name;
+		this.id = token.id;
+		this.schema = token.schema;
+	}
+	async resolve(ctx) {
+		if (!this.value) {
+			this.value = await this.factory(ctx);
+			this.resolved = true;
+		}
+		return this.value;
+	}
+	toString() {
+		return this.token.toString();
+	}
+};
+
+//#endregion
+export { BoundInjectionToken, FactoryInjectionToken, InjectionToken };
+//# sourceMappingURL=injection-token.mjs.map

package/lib/browser/token/injection-token.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-token.mjs","names":["simpleHash","str","hash","i","length","char","charCodeAt","Math","abs","toString","generateTokenId","name","customId","base","split","InjectionToken","id","formattedName","schema","create","bound","token","value","BoundInjectionToken","factory","FactoryInjectionToken","refineType","className","resolved","resolve","ctx"],"sources":["../../../src/token/injection-token.mts"],"sourcesContent":["import type { z, ZodObject, ZodOptional, ZodRecord } from 'zod/v4'\n\nimport type { FactoryContext } from '../internal/context/factory-context.mjs'\n\nexport type ClassType = new (...args: any[]) => any\nexport type ClassTypeWithoutArguments = new () => any\nexport type ClassTypeWithArgument<Arg> = new (arg: Arg) => any\nexport type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any\n\nexport type ClassTypeWithInstance<T> = new (...args: any[]) => T\nexport type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T\nexport type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (\n  arg?: Arg,\n) => T\n\nexport type BaseInjectionTokenSchemaType = ZodObject | ZodRecord\n\nexport type OptionalInjectionTokenSchemaType =\n  | ZodOptional<ZodObject>\n  | ZodOptional<ZodRecord>\n\nexport type InjectionTokenSchemaType =\n  | BaseInjectionTokenSchemaType\n  | OptionalInjectionTokenSchemaType\n\n/**\n * Simple hash function for deterministic ID generation\n */\nfunction simpleHash(str: string): string {\n  let hash = 0\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i)\n    hash = (hash << 5) - hash + char\n    hash = hash & hash // Convert to 32-bit integer\n  }\n  return Math.abs(hash).toString(36)\n}\n\n/**\n * Generate deterministic ID from token name\n */\nfunction generateTokenId(name: string | symbol | ClassType, customId?: string): string {\n  if (customId) {\n    return customId\n  }\n\n  let base: string\n  if (typeof name === 'function') {\n    base = `${name.name}_${name.toString()}`\n  } else if (typeof name === 'symbol') {\n    base = `symbol_${name.toString()}`\n  } else {\n    base = `token_${name}`\n  }\n\n  return `${base.split('_')[0]}_${simpleHash(base)}`\n}\n\nexport class InjectionToken<\n  // oxlint-disable-next-line no-unused-vars\n  T,\n  S extends InjectionTokenSchemaType | unknown = unknown,\n  // oxlint-disable-next-line no-unused-vars\n  Required extends boolean = S extends ZodOptional<ZodObject>\n    ? false\n    : S extends ZodOptional<ZodRecord>\n      ? false\n      : S extends ZodObject\n        ? true\n        : S extends ZodRecord\n          ? true\n          : false,\n> {\n  public readonly id: string\n  private formattedName: string | null = null\n\n  constructor(\n    public readonly name: string | symbol | ClassType,\n    public readonly schema: ZodObject | undefined,\n    customId?: string,\n  ) {\n    this.id = generateTokenId(name, customId)\n  }\n\n  static create<T extends ClassType>(\n    name: T,\n  ): InjectionToken<InstanceType<T>, undefined>\n  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(\n    name: T,\n    schema: Schema,\n  ): Schema['_def']['type'] extends 'ZodOptional'\n    ? InjectionToken<InstanceType<T>, Schema, false>\n    : InjectionToken<InstanceType<T>, Schema, true>\n  static create<T>(name: string | symbol): InjectionToken<T, undefined>\n  static create<T, Schema extends InjectionTokenSchemaType>(\n    name: string | any,\n    schema: Schema,\n  ): InjectionToken<T, Schema>\n  static create(name: string | symbol, schema?: unknown, customId?: string) {\n    // @ts-expect-error\n    return new InjectionToken(name, schema, customId)\n  }\n\n  static bound<T, S extends InjectionTokenSchemaType>(\n    token: InjectionToken<T, S>,\n    value: z.input<S>,\n  ): BoundInjectionToken<T, S> {\n    return new BoundInjectionToken(token, value)\n  }\n\n  static factory<T, S extends InjectionTokenSchemaType>(\n    token: InjectionToken<T, S>,\n    factory: (ctx: FactoryContext) => Promise<z.input<S>>,\n  ): FactoryInjectionToken<T, S> {\n    return new FactoryInjectionToken(token, factory)\n  }\n\n  static refineType<T>(\n    token: BoundInjectionToken<any, any>,\n  ): BoundInjectionToken<T, any> {\n    return token as BoundInjectionToken<T, any>\n  }\n\n  toString() {\n    if (this.formattedName) {\n      return this.formattedName\n    }\n    const { name } = this\n    if (typeof name === 'function') {\n      const className = name.name\n      this.formattedName = `${className}(${this.id})`\n    } else if (typeof name === 'symbol') {\n      this.formattedName = `${name.toString()}(${this.id})`\n    } else {\n      this.formattedName = `${name}(${this.id})`\n    }\n\n    return this.formattedName\n  }\n}\n\nexport class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {\n  public id: string\n  public name: string | symbol | ClassType\n  public schema: InjectionTokenSchemaType\n\n  constructor(\n    public readonly token: InjectionToken<T, S>,\n    public readonly value: z.input<S>,\n  ) {\n    this.name = token.name\n    this.id = token.id\n    this.schema = token.schema as InjectionTokenSchemaType\n  }\n\n  toString() {\n    return this.token.toString()\n  }\n}\n\nexport class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {\n  public value?: z.input<S>\n  public resolved = false\n  public id: string\n  public name: string | symbol | ClassType\n  public schema: InjectionTokenSchemaType\n\n  constructor(\n    public readonly token: InjectionToken<T, S>,\n    public readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>,\n  ) {\n    this.name = token.name\n    this.id = token.id\n    this.schema = token.schema as InjectionTokenSchemaType\n  }\n\n  async resolve(ctx: FactoryContext): Promise<z.input<S>> {\n    if (!this.value) {\n      this.value = await this.factory(ctx)\n      this.resolved = true\n    }\n    return this.value\n  }\n\n  toString() {\n    return this.token.toString()\n  }\n}\n\nexport type AnyInjectableType =\n  | ClassType\n  | InjectionToken<any, any>\n  | BoundInjectionToken<any, any>\n  | FactoryInjectionToken<any, any>\n\nexport type InjectionTokenType =\n  | InjectionToken<any, any>\n  | BoundInjectionToken<any, any>\n  | FactoryInjectionToken<any, any>\n\n"],"mappings":";;;GA4BA,SAASA,WAAWC,KAAW;CAC7B,IAAIC,OAAO;AACX,MAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,QAAQD,KAAK;EACnC,MAAME,OAAOJ,IAAIK,WAAWH,EAAAA;AAC5BD,UAAQA,QAAQ,KAAKA,OAAOG;AAC5BH,SAAOA,OAAOA;;AAEhB,QAAOK,KAAKC,IAAIN,KAAAA,CAAMO,SAAS,GAAA;;;;GAMjC,SAASC,gBAAgBC,MAAmCC,UAAiB;AAC3E,KAAIA,SACF,QAAOA;CAGT,IAAIC;AACJ,KAAI,OAAOF,SAAS,WAClBE,QAAO,GAAGF,KAAKA,KAAK,GAAGA,KAAKF,UAAQ;UAC3B,OAAOE,SAAS,SACzBE,QAAO,UAAUF,KAAKF,UAAQ;KAE9BI,QAAO,SAASF;AAGlB,QAAO,GAAGE,KAAKC,MAAM,IAAI,CAAC,GAAG,GAAGd,WAAWa,KAAAA;;AAG7C,IAAaE,iBAAb,MAAaA,eAAAA;;;CAeKC;CACRC,gBAA+B;CAEvC,YACE,MACA,QACAL,UACA;OAHgBD,OAAAA;OACAO,SAAAA;AAGhB,OAAKF,KAAKN,gBAAgBC,MAAMC,SAAAA;;CAiBlC,OAAOO,OAAOR,MAAuBO,QAAkBN,UAAmB;AAExE,SAAO,IAAIG,eAAeJ,MAAMO,QAAQN,SAAAA;;CAG1C,OAAOQ,MACLC,OACAC,OAC2B;AAC3B,SAAO,IAAIC,oBAAoBF,OAAOC,MAAAA;;CAGxC,OAAOE,QACLH,OACAG,SAC6B;AAC7B,SAAO,IAAIC,sBAAsBJ,OAAOG,QAAAA;;CAG1C,OAAOE,WACLL,OAC6B;AAC7B,SAAOA;;CAGTZ,WAAW;AACT,MAAI,KAAKQ,cACP,QAAO,KAAKA;EAEd,MAAM,EAAEN,SAAS;AACjB,MAAI,OAAOA,SAAS,WAElB,MAAKM,gBAAgB,GADHN,KAAKA,KACW,GAAG,KAAKK,GAAG;WACpC,OAAOL,SAAS,SACzB,MAAKM,gBAAgB,GAAGN,KAAKF,UAAQ,CAAG,GAAG,KAAKO,GAAG;MAEnD,MAAKC,gBAAgB,GAAGN,KAAK,GAAG,KAAKK,GAAG;AAG1C,SAAO,KAAKC;;;AAIhB,IAAaM,sBAAb,MAAaA;;;CACJP;CACAL;CACAO;CAEP,YACE,OACA,OACA;OAFgBG,QAAAA;OACAC,QAAAA;AAEhB,OAAKX,OAAOU,MAAMV;AAClB,OAAKK,KAAKK,MAAML;AAChB,OAAKE,SAASG,MAAMH;;CAGtBT,WAAW;AACT,SAAO,KAAKY,MAAMZ,UAAQ;;;AAI9B,IAAagB,wBAAb,MAAaA;;;CACJH;CACAM,WAAW;CACXZ;CACAL;CACAO;CAEP,YACE,OACA,SACA;OAFgBG,QAAAA;OACAG,UAAAA;AAEhB,OAAKb,OAAOU,MAAMV;AAClB,OAAKK,KAAKK,MAAML;AAChB,OAAKE,SAASG,MAAMH;;CAGtB,MAAMW,QAAQC,KAA0C;AACtD,MAAI,CAAC,KAAKR,OAAO;AACf,QAAKA,QAAQ,MAAM,KAAKE,QAAQM,IAAAA;AAChC,QAAKF,WAAW;;AAElB,SAAO,KAAKN;;CAGdb,WAAW;AACT,SAAO,KAAKY,MAAMZ,UAAQ"}

package/lib/browser/token/registry.d.mts

@@ -0,0 +1,37 @@
+import { ClassType, InjectionToken } from "./injection-token.mjs";
+import { InjectableScope } from "../enums/injectable-scope.enum.mjs";
+import { InjectableType } from "../enums/injectable-type.enum.mjs";
+
+//#region src/token/registry.d.mts
+type FactoryRecord<Instance = any, Schema = any> = {
+  scope: InjectableScope;
+  originalToken: InjectionToken<Instance, Schema>;
+  target: ClassType;
+  type: InjectableType;
+  priority: number;
+};
+declare class Registry {
+  private readonly parent?;
+  private readonly factories;
+  private readonly highestPriority;
+  constructor(parent?: Registry | undefined);
+  has(token: InjectionToken<any, any>): boolean;
+  get<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>;
+  getAll<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>[];
+  set<Instance, Schema>(token: InjectionToken<Instance, Schema>, scope: InjectableScope, target: ClassType, type: InjectableType, priority?: number): void;
+  delete(token: InjectionToken<any, any>): void;
+  /**
+   * Updates the scope of an already registered factory.
+   * This is useful when you need to dynamically change a service's scope
+   * (e.g., when a singleton controller has request-scoped dependencies).
+   *
+   * @param token The injection token to update
+   * @param scope The new scope to set
+   * @returns true if the scope was updated, false if the token was not found
+   */
+  updateScope(token: InjectionToken<any, any>, scope: InjectableScope): boolean;
+}
+declare const globalRegistry: Registry;
+//#endregion
+export { FactoryRecord, Registry, globalRegistry };
+//# sourceMappingURL=registry.d.mts.map

package/lib/browser/token/registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.mts","names":[],"sources":["../../../src/token/registry.mts"],"sourcesContent":[],"mappings":";;;;;KAIY;SACH;iBACQ,eAAe,UAAU;EAF9B,MAAA,EAGF,SAHe;EAChB,IAAA,EAGD,cAHC;EACuB,QAAA,EAAA,MAAA;CAAU;AAAzB,cAMJ,QAAA,CANI;EACP,iBAAA,MAAA;EACF,iBAAA,SAAA;EAAc,iBAAA,eAAA;EAIT,WAAQ,CAAA,MAAA,CAAA,EAImB,QAJnB,GAAA,SAAA;EAImB,GAAA,CAAA,KAAA,EAE3B,cAF2B,CAAA,GAAA,EAAA,GAAA,CAAA,CAAA,EAAA,OAAA;EAE3B,GAAA,CAAA,QAAA,EAAA,MAAA,CAAA,CAAA,KAAA,EAWF,cAXE,CAWa,QAXb,EAWuB,MAXvB,CAAA,CAAA,EAYR,aAZQ,CAYM,QAZN,EAYgB,MAZhB,CAAA;EAWa,MAAA,CAAA,QAAA,EAAA,MAAA,CAAA,CAAA,KAAA,EAaf,cAbe,CAaA,QAbA,EAaU,MAbV,CAAA,CAAA,EAcrB,aAdqB,CAcP,QAdO,EAcG,MAdH,CAAA,EAAA;EAAU,GAAA,CAAA,QAAA,EAAA,MAAA,CAAA,CAAA,KAAA,EA2BzB,cA3ByB,CA2BV,QA3BU,EA2BA,MA3BA,CAAA,EAAA,KAAA,EA4BzB,eA5ByB,EAAA,MAAA,EA6BxB,SA7BwB,EAAA,IAAA,EA8B1B,cA9B0B,EAAA,QAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAzB,MAAA,CAAA,KAAA,EAqDK,cArDL,CAAA,GAAA,EAAA,GAAA,CAAA,CAAA,EAAA,IAAA;EACQ;;;;;;;;;EA0BO,WAAA,CAAA,KAAA,EA6Df,cA7De,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA,KAAA,EA8Df,eA9De,CAAA,EAAA,OAAA;;AAAf,cAoFE,cApFF,EAoFgB,QApFhB"}

package/lib/browser/token/registry.mjs

@@ -0,0 +1,86 @@
+//#region src/token/registry.mts
+var Registry = class {
+	parent;
+	factories = /* @__PURE__ */ new Map();
+	highestPriority = /* @__PURE__ */ new Map();
+	constructor(parent) {
+		this.parent = parent;
+	}
+	has(token) {
+		if (this.factories.has(token.id)) return true;
+		if (this.parent) return this.parent.has(token);
+		return false;
+	}
+	get(token) {
+		const factory = this.highestPriority.get(token.id);
+		if (!factory) {
+			if (this.parent) return this.parent.get(token);
+			throw new Error(`[Registry] No factory found for ${token.toString()}`);
+		}
+		return factory;
+	}
+	getAll(token) {
+		const records = this.factories.get(token.id);
+		if (!records || records.length === 0) {
+			if (this.parent) return this.parent.getAll(token);
+			return [];
+		}
+		return [...records].sort((a, b) => b.priority - a.priority);
+	}
+	set(token, scope, target, type, priority = 0) {
+		const record = {
+			scope,
+			originalToken: token,
+			target,
+			type,
+			priority
+		};
+		const existing = this.factories.get(token.id) || [];
+		existing.push(record);
+		this.factories.set(token.id, existing);
+		const currentHighest = this.highestPriority.get(token.id);
+		if (!currentHighest || priority > currentHighest.priority) this.highestPriority.set(token.id, record);
+	}
+	delete(token) {
+		const records = this.factories.get(token.id);
+		if (records) {
+			const deletedHighest = this.highestPriority.get(token.id);
+			this.factories.delete(token.id);
+			this.highestPriority.delete(token.id);
+			if (deletedHighest && records.length > 1) {
+				const remaining = records.filter((r) => r.originalToken.id !== deletedHighest.originalToken.id || r.priority !== deletedHighest.priority);
+				if (remaining.length > 0) {
+					const newHighest = remaining.reduce((max, current) => current.priority > max.priority ? current : max);
+					this.highestPriority.set(token.id, newHighest);
+					this.factories.set(token.id, remaining);
+				}
+			}
+		}
+	}
+	/**
+	* Updates the scope of an already registered factory.
+	* This is useful when you need to dynamically change a service's scope
+	* (e.g., when a singleton controller has request-scoped dependencies).
+	*
+	* @param token The injection token to update
+	* @param scope The new scope to set
+	* @returns true if the scope was updated, false if the token was not found
+	*/ updateScope(token, scope) {
+		const records = this.factories.get(token.id);
+		if (records && records.length > 0) {
+			records.forEach((record) => {
+				record.scope = scope;
+			});
+			const highest = this.highestPriority.get(token.id);
+			if (highest) highest.scope = scope;
+			return true;
+		}
+		if (this.parent) return this.parent.updateScope(token, scope);
+		return false;
+	}
+};
+const globalRegistry = /* @__PURE__ */ new Registry();
+
+//#endregion
+export { Registry, globalRegistry };
+//# sourceMappingURL=registry.mjs.map

package/lib/browser/token/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","names":["Registry","factories","Map","highestPriority","parent","has","token","id","get","factory","Error","toString","getAll","records","length","sort","a","b","priority","set","scope","target","type","record","originalToken","existing","push","currentHighest","delete","deletedHighest","remaining","filter","r","newHighest","reduce","max","current","updateScope","forEach","highest","globalRegistry"],"sources":["../../../src/token/registry.mts"],"sourcesContent":["import type { ClassType, InjectionToken } from './injection-token.mjs'\n\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\n\nexport type FactoryRecord<Instance = any, Schema = any> = {\n  scope: InjectableScope\n  originalToken: InjectionToken<Instance, Schema>\n  target: ClassType\n  type: InjectableType\n  priority: number\n}\n\nexport class Registry {\n  private readonly factories = new Map<string, FactoryRecord[]>()\n  private readonly highestPriority = new Map<string, FactoryRecord>()\n\n  constructor(private readonly parent?: Registry) {}\n\n  has(token: InjectionToken<any, any>): boolean {\n    if (this.factories.has(token.id)) {\n      return true\n    }\n    if (this.parent) {\n      return this.parent.has(token)\n    }\n    return false\n  }\n\n  get<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n  ): FactoryRecord<Instance, Schema> {\n    const factory = this.highestPriority.get(token.id)\n    if (!factory) {\n      if (this.parent) {\n        return this.parent.get(token)\n      }\n      throw new Error(`[Registry] No factory found for ${token.toString()}`)\n    }\n    return factory\n  }\n\n  getAll<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n  ): FactoryRecord<Instance, Schema>[] {\n    const records = this.factories.get(token.id)\n    if (!records || records.length === 0) {\n      if (this.parent) {\n        return this.parent.getAll(token)\n      }\n      return []\n    }\n    // Return sorted by priority (highest first)\n    return [...records].sort((a, b) => b.priority - a.priority)\n  }\n\n  set<Instance, Schema>(\n    token: InjectionToken<Instance, Schema>,\n    scope: InjectableScope,\n    target: ClassType,\n    type: InjectableType,\n    priority: number = 0,\n  ) {\n    const record: FactoryRecord<Instance, Schema> = {\n      scope,\n      originalToken: token,\n      target,\n      type,\n      priority,\n    }\n\n    // Add to factories array\n    const existing = this.factories.get(token.id) || []\n    existing.push(record)\n    this.factories.set(token.id, existing)\n\n    // Update highest priority cache if needed\n    const currentHighest = this.highestPriority.get(token.id)\n    if (!currentHighest || priority > currentHighest.priority) {\n      this.highestPriority.set(token.id, record)\n    }\n  }\n\n  delete(token: InjectionToken<any, any>) {\n    const records = this.factories.get(token.id)\n    if (records) {\n      const deletedHighest = this.highestPriority.get(token.id)\n      this.factories.delete(token.id)\n      this.highestPriority.delete(token.id)\n\n      // If we deleted the highest priority record, recalculate from remaining records\n      if (deletedHighest && records.length > 1) {\n        const remaining = records.filter(\n          (r) =>\n            r.originalToken.id !== deletedHighest.originalToken.id ||\n            r.priority !== deletedHighest.priority,\n        )\n        if (remaining.length > 0) {\n          const newHighest = remaining.reduce((max, current) =>\n            current.priority > max.priority ? current : max,\n          )\n          this.highestPriority.set(token.id, newHighest)\n          this.factories.set(token.id, remaining)\n        }\n      }\n    }\n  }\n\n  /**\n   * Updates the scope of an already registered factory.\n   * This is useful when you need to dynamically change a service's scope\n   * (e.g., when a singleton controller has request-scoped dependencies).\n   *\n   * @param token The injection token to update\n   * @param scope The new scope to set\n   * @returns true if the scope was updated, false if the token was not found\n   */\n  updateScope(\n    token: InjectionToken<any, any>,\n    scope: InjectableScope,\n  ): boolean {\n    const records = this.factories.get(token.id)\n    if (records && records.length > 0) {\n      // Update all records\n      records.forEach((record) => {\n        record.scope = scope\n      })\n      // Update highest priority cache if it exists\n      const highest = this.highestPriority.get(token.id)\n      if (highest) {\n        highest.scope = scope\n      }\n      return true\n    }\n    if (this.parent) {\n      return this.parent.updateScope(token, scope)\n    }\n    return false\n  }\n}\n\nexport const globalRegistry = /* #__PURE__ */ new Registry()\n"],"mappings":";AAYA,IAAaA,WAAb,MAAaA;;CACMC,4BAAY,IAAIC,KAAAA;CAChBC,kCAAkB,IAAID,KAAAA;CAEvC,YAAY,QAAoC;OAAnBE,SAAAA;;CAE7BC,IAAIC,OAA0C;AAC5C,MAAI,KAAKL,UAAUI,IAAIC,MAAMC,GAAE,CAC7B,QAAO;AAET,MAAI,KAAKH,OACP,QAAO,KAAKA,OAAOC,IAAIC,MAAAA;AAEzB,SAAO;;CAGTE,IACEF,OACiC;EACjC,MAAMG,UAAU,KAAKN,gBAAgBK,IAAIF,MAAMC,GAAE;AACjD,MAAI,CAACE,SAAS;AACZ,OAAI,KAAKL,OACP,QAAO,KAAKA,OAAOI,IAAIF,MAAAA;AAEzB,SAAM,IAAII,MAAM,mCAAmCJ,MAAMK,UAAQ,GAAI;;AAEvE,SAAOF;;CAGTG,OACEN,OACmC;EACnC,MAAMO,UAAU,KAAKZ,UAAUO,IAAIF,MAAMC,GAAE;AAC3C,MAAI,CAACM,WAAWA,QAAQC,WAAW,GAAG;AACpC,OAAI,KAAKV,OACP,QAAO,KAAKA,OAAOQ,OAAON,MAAAA;AAE5B,UAAO,EAAE;;AAGX,SAAO,IAAIO,QAAQ,CAACE,MAAMC,GAAGC,MAAMA,EAAEC,WAAWF,EAAEE,SAAQ;;CAG5DC,IACEb,OACAc,OACAC,QACAC,MACAJ,WAAmB,GACnB;EACA,MAAMK,SAA0C;GAC9CH;GACAI,eAAelB;GACfe;GACAC;GACAJ;GACF;EAGA,MAAMO,WAAW,KAAKxB,UAAUO,IAAIF,MAAMC,GAAE,IAAK,EAAE;AACnDkB,WAASC,KAAKH,OAAAA;AACd,OAAKtB,UAAUkB,IAAIb,MAAMC,IAAIkB,SAAAA;EAG7B,MAAME,iBAAiB,KAAKxB,gBAAgBK,IAAIF,MAAMC,GAAE;AACxD,MAAI,CAACoB,kBAAkBT,WAAWS,eAAeT,SAC/C,MAAKf,gBAAgBgB,IAAIb,MAAMC,IAAIgB,OAAAA;;CAIvCK,OAAOtB,OAAiC;EACtC,MAAMO,UAAU,KAAKZ,UAAUO,IAAIF,MAAMC,GAAE;AAC3C,MAAIM,SAAS;GACX,MAAMgB,iBAAiB,KAAK1B,gBAAgBK,IAAIF,MAAMC,GAAE;AACxD,QAAKN,UAAU2B,OAAOtB,MAAMC,GAAE;AAC9B,QAAKJ,gBAAgByB,OAAOtB,MAAMC,GAAE;AAGpC,OAAIsB,kBAAkBhB,QAAQC,SAAS,GAAG;IACxC,MAAMgB,YAAYjB,QAAQkB,QACvBC,MACCA,EAAER,cAAcjB,OAAOsB,eAAeL,cAAcjB,MACpDyB,EAAEd,aAAaW,eAAeX,SAAQ;AAE1C,QAAIY,UAAUhB,SAAS,GAAG;KACxB,MAAMmB,aAAaH,UAAUI,QAAQC,KAAKC,YACxCA,QAAQlB,WAAWiB,IAAIjB,WAAWkB,UAAUD,IAAAA;AAE9C,UAAKhC,gBAAgBgB,IAAIb,MAAMC,IAAI0B,WAAAA;AACnC,UAAKhC,UAAUkB,IAAIb,MAAMC,IAAIuB,UAAAA;;;;;;;;;;;;;IAerCO,YACE/B,OACAc,OACS;EACT,MAAMP,UAAU,KAAKZ,UAAUO,IAAIF,MAAMC,GAAE;AAC3C,MAAIM,WAAWA,QAAQC,SAAS,GAAG;AAEjCD,WAAQyB,SAASf,WAAAA;AACfA,WAAOH,QAAQA;KACjB;GAEA,MAAMmB,UAAU,KAAKpC,gBAAgBK,IAAIF,MAAMC,GAAE;AACjD,OAAIgC,QACFA,SAAQnB,QAAQA;AAElB,UAAO;;AAET,MAAI,KAAKhB,OACP,QAAO,KAAKA,OAAOiC,YAAY/B,OAAOc,MAAAA;AAExC,SAAO;;;AAIX,MAAaoB,iCAAiC,IAAIxC,UAAAA"}

package/lib/browser/utils/default-injectors.d.mts

@@ -0,0 +1,12 @@
+import { Injectors } from "./get-injectors.mjs";
+
+//#region src/utils/default-injectors.d.mts
+declare const defaultInjectors: Injectors;
+declare const inject: Injectors['inject'];
+declare const optional: Injectors['optional'];
+declare const asyncInject: Injectors['asyncInject'];
+declare const wrapSyncInit: Injectors['wrapSyncInit'];
+declare const provideFactoryContext: Injectors['provideFactoryContext'];
+//#endregion
+export { asyncInject, defaultInjectors, inject, optional, provideFactoryContext, wrapSyncInit };
+//# sourceMappingURL=default-injectors.d.mts.map

package/lib/browser/utils/default-injectors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-injectors.d.mts","names":[],"sources":["../../../src/utils/default-injectors.mts"],"sourcesContent":[],"mappings":";;;cAIa,kBAAgB;cAEhB,QAAQ;AAFR,cAIA,QAJiD,EAIvC,SAJM,CAAA,UAAiC,CAAA;AAEjD,cAIA,WAJQ,EAIK,SAJI,CAAA,aAAA,CAAA;AAEjB,cAIA,YAJU,EAII,SAJK,CAAA,cAAA,CAAA;AAEnB,cAIA,qBAJsB,EAIC,SAJD,CAAA,uBAAA,CAAA"}

package/lib/browser/utils/default-injectors.mjs

@@ -0,0 +1,13 @@
+import { getInjectors } from "./get-injectors.mjs";
+
+//#region src/utils/default-injectors.mts
+const defaultInjectors = /* @__PURE__ */ getInjectors();
+const inject = defaultInjectors.inject;
+const optional = defaultInjectors.optional;
+const asyncInject = defaultInjectors.asyncInject;
+const wrapSyncInit = defaultInjectors.wrapSyncInit;
+const provideFactoryContext = defaultInjectors.provideFactoryContext;
+
+//#endregion
+export { asyncInject, defaultInjectors, inject, optional, provideFactoryContext, wrapSyncInit };
+//# sourceMappingURL=default-injectors.mjs.map

package/lib/browser/utils/default-injectors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-injectors.mjs","names":["inject: Injectors['inject']","optional: Injectors['optional']","asyncInject: Injectors['asyncInject']","wrapSyncInit: Injectors['wrapSyncInit']","provideFactoryContext: Injectors['provideFactoryContext']"],"sources":["../../../src/utils/default-injectors.mts"],"sourcesContent":["import type { Injectors } from './get-injectors.mjs'\n\nimport { getInjectors } from './get-injectors.mjs'\n\nexport const defaultInjectors = /* #__PURE__ */ getInjectors()\n\nexport const inject: Injectors['inject'] =\n  /* #__PURE__ */ defaultInjectors.inject\nexport const optional: Injectors['optional'] =\n  /* #__PURE__ */ defaultInjectors.optional\nexport const asyncInject: Injectors['asyncInject'] =\n  /* #__PURE__ */ defaultInjectors.asyncInject\nexport const wrapSyncInit: Injectors['wrapSyncInit'] =\n  /* #__PURE__ */ defaultInjectors.wrapSyncInit\nexport const provideFactoryContext: Injectors['provideFactoryContext'] =\n  /* #__PURE__ */ defaultInjectors.provideFactoryContext\n"],"mappings":";;;AAIA,MAAa,mBAAmC,8BAAc;AAE9D,MAAaA,SACK,iBAAiB;AACnC,MAAaC,WACK,iBAAiB;AACnC,MAAaC,cACK,iBAAiB;AACnC,MAAaC,eACK,iBAAiB;AACnC,MAAaC,wBACK,iBAAiB"}

package/lib/browser/utils/get-injectable-token.d.mts

@@ -0,0 +1,9 @@
+import { ClassType, InjectionToken } from "../token/injection-token.mjs";
+
+//#region src/utils/get-injectable-token.d.mts
+declare function getInjectableToken<R>(target: ClassType): R extends {
+  create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+//#endregion
+export { getInjectableToken };
+//# sourceMappingURL=get-injectable-token.d.mts.map