katagami 3.0.0 → 3.0.2

package/dist/index.js

@@ -1,20 +1,24 @@
 import {
   INTERNALS
-} from "./index-jx8b52m0.js";
+} from "./chunk-J2NYR3SH.js";
 
 // src/container/index.ts
 function createContainer() {
-  return new Container;
+  return new Container();
 }
-
-class Container {
+var Container = class {
   registrations;
   singletonCache;
   disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
   [INTERNALS];
   constructor() {
-    this.registrations = new Map;
-    this.singletonCache = new Map;
+    this.registrations = /* @__PURE__ */ new Map();
+    this.singletonCache = /* @__PURE__ */ new Map();
     this[INTERNALS] = {
       isDisposed: () => this.disposed,
       markDisposed: () => {
@@ -40,23 +44,36 @@ class Container {
     }
     return this;
   }
+  /**
+   * Add a registration entry. Accumulates registrations for the same token.
+   *
+   * @param token Token
+   * @param factory Factory function
+   * @param lifetime Lifetime of the registration
+   * @returns The container for method chaining
+   */
   addRegistration(token, factory, lifetime) {
     const existing = this.registrations.get(token);
-    if (existing !== undefined) {
+    if (existing !== void 0) {
       existing.push({ factory, lifetime });
     } else {
       this.registrations.set(token, [{ factory, lifetime }]);
     }
     return this;
   }
-}
+};
+
 // src/error/index.ts
-class ContainerError extends Error {
+var ContainerError = class extends Error {
+  /**
+   * @param message Error message
+   */
   constructor(message) {
     super(message);
     this.name = "ContainerError";
   }
-}
+};
+
 // src/resolver/index.ts
 function tokenToString(token) {
   if (typeof token === "function") {
@@ -90,20 +107,24 @@ function createScope(source) {
   }
   return new Scope(internals.registrations, internals.singletonCache);
 }
-
-class Scope {
+var Scope = class {
   registrations;
   singletonCache;
   scopedCache;
   resolvingTokens;
   singletonDepth = 0;
   disposed = false;
+  /**
+   * Internal state accessor for extension modules (scope, disposable).
+   *
+   * @internal
+   */
   [INTERNALS];
   constructor(registrations, singletonCache) {
     this.registrations = registrations;
     this.singletonCache = singletonCache;
-    this.scopedCache = new Map;
-    this.resolvingTokens = new Set;
+    this.scopedCache = /* @__PURE__ */ new Map();
+    this.resolvingTokens = /* @__PURE__ */ new Set();
     this[INTERNALS] = {
       isDisposed: () => this.disposed,
       markDisposed: () => {
@@ -126,27 +147,37 @@ class Scope {
   tryResolveAll(token) {
     return this.resolveAllTokens(token, false);
   }
+  /**
+   * Internal resolution logic shared by resolve and tryResolve.
+   * Resolves the last registered factory for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns The resolved instance, or undefined if not registered and required is false
+   */
   resolveToken(token, required) {
     if (this.disposed) {
       throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     const registration = registrations[registrations.length - 1];
     const singletonCached = this.singletonCache.get(registration);
-    if (singletonCached !== undefined) {
+    if (singletonCached !== void 0) {
       return singletonCached;
     }
     if (registration.lifetime === "scoped" && this.singletonDepth > 0) {
-      throw new ContainerError(`Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`);
+      throw new ContainerError(
+        `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+      );
     }
     const scopedCached = this.scopedCache.get(registration);
-    if (scopedCached !== undefined) {
+    if (scopedCached !== void 0) {
       return scopedCached;
     }
     if (this.resolvingTokens.has(token)) {
@@ -157,7 +188,9 @@ class Scope {
       this.singletonDepth++;
     }
     try {
-      const instance = registration.factory(this);
+      const instance = registration.factory(
+        this
+      );
       if (registration.lifetime === "singleton") {
         this.singletonCache.set(registration, instance);
       } else if (registration.lifetime === "scoped") {
@@ -171,16 +204,24 @@ class Scope {
       this.resolvingTokens.delete(token);
     }
   }
+  /**
+   * Internal resolution logic shared by resolveAll and tryResolveAll.
+   * Resolves all registered factories for the token.
+   *
+   * @param token Token to resolve
+   * @param required If true, throws when the token is not registered. If false, returns undefined.
+   * @returns An array of resolved instances, or undefined if not registered and required is false
+   */
   resolveAllTokens(token, required) {
     if (this.disposed) {
       throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === undefined || registrations.length === 0) {
+    if (registrations === void 0 || registrations.length === 0) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
-      return;
+      return void 0;
     }
     if (this.resolvingTokens.has(token)) {
       throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
@@ -190,21 +231,25 @@ class Scope {
       return registrations.map((registration) => {
         const reg = registration;
         const singletonCached = this.singletonCache.get(registration);
-        if (singletonCached !== undefined) {
+        if (singletonCached !== void 0) {
           return singletonCached;
         }
         if (reg.lifetime === "scoped" && this.singletonDepth > 0) {
-          throw new ContainerError(`Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`);
+          throw new ContainerError(
+            `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
+          );
         }
         const scopedCached = this.scopedCache.get(registration);
-        if (scopedCached !== undefined) {
+        if (scopedCached !== void 0) {
           return scopedCached;
         }
         if (reg.lifetime === "singleton") {
           this.singletonDepth++;
         }
         try {
-          const instance = reg.factory(this);
+          const instance = reg.factory(
+            this
+          );
           if (reg.lifetime === "singleton") {
             this.singletonCache.set(registration, instance);
           } else if (reg.lifetime === "scoped") {
@@ -221,11 +266,11 @@ class Scope {
       this.resolvingTokens.delete(token);
     }
   }
-}
+};
 export {
-  createScope,
-  createContainer,
-  Scope,
+  Container,
   ContainerError,
-  Container
+  Scope,
+  createContainer,
+  createScope
 };

package/dist/internal.d.cts

@@ -0,0 +1,29 @@
+import type { Registration } from './resolver/index.cjs';
+/**
+ * Symbol used by extension modules (scope, disposable) to access container/scope internals.
+ *
+ * @internal
+ */
+export declare const INTERNALS: unique symbol;
+/** Type-only registration state retained by disposable views. No runtime property is emitted. */
+export declare const TYPE_STATE: unique symbol;
+/**
+ * Internal state exposed via the INTERNALS symbol.
+ *
+ * Both Container and Scope implement this interface so that extension modules
+ * (scope, disposable) can operate on either without importing the concrete class.
+ *
+ * @internal
+ */
+export interface ContainerInternals {
+    /** All registrations (singleton / transient / scoped). Each token maps to an array of registrations. */
+    readonly registrations: Map<unknown, Registration[]>;
+    /** Singleton cache keyed by Registration object (Container: singletons, Scope: shared with parent). */
+    readonly singletonCache: Map<Registration, unknown>;
+    /** Instances owned by this container / scope (disposal target), keyed by Registration object. */
+    readonly ownCache: Map<Registration, unknown>;
+    /** Whether this container / scope has been disposed. */
+    isDisposed(): boolean;
+    /** Mark this container / scope as disposed. */
+    markDisposed(): void;
+}

package/dist/internal.d.ts

@@ -1,10 +1,12 @@
-import type { Registration } from './resolver';
+import type { Registration } from './resolver/index.js';
 /**
  * Symbol used by extension modules (scope, disposable) to access container/scope internals.
  *
  * @internal
  */
 export declare const INTERNALS: unique symbol;
+/** Type-only registration state retained by disposable views. No runtime property is emitted. */
+export declare const TYPE_STATE: unique symbol;
 /**
  * Internal state exposed via the INTERNALS symbol.
  *

package/dist/lazy/index.cjs

@@ -1,37 +1,28 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lazy/index.ts
-var exports_lazy = {};
-__export(exports_lazy, {
+var lazy_exports = {};
+__export(lazy_exports, {
   lazy: () => lazy
 });
-module.exports = __toCommonJS(exports_lazy);
+module.exports = __toCommonJS(lazy_exports);
 function lazy(source, token) {
   let instance;
   let resolved = false;
@@ -42,7 +33,7 @@ function lazy(source, token) {
     }
     return instance;
   };
-  const proxyTarget = Object.create(null);
+  const proxyTarget = /* @__PURE__ */ Object.create(null);
   return new Proxy(proxyTarget, {
     defineProperty(_, prop, desc) {
       return Reflect.defineProperty(ensureResolved(), prop, desc);

package/dist/lazy/index.d.cts

@@ -0,0 +1,33 @@
+import type { DisposableScope } from '../disposable/index.cjs';
+import type { AbstractConstructor } from '../resolver/index.cjs';
+import type { Scope } from '../scope/index.cjs';
+/**
+ * Create a lazy proxy that defers resolution until the first property access.
+ *
+ * The returned object looks and behaves like `V`, but the underlying instance
+ * is not created until a property is read, written, or otherwise accessed.
+ * Once resolved the instance is cached — subsequent accesses hit the cache.
+ *
+ * Only **sync class tokens** are supported. Async tokens and PropertyKey tokens
+ * are rejected at the type level.
+ *
+ * @param source A Scope or DisposableScope
+ * @param token  A sync class constructor token
+ * @returns A proxy that transparently forwards to the lazily-resolved instance
+ *
+ * @example
+ * ```ts
+ * import { createContainer, createScope } from 'katagami';
+ * import { lazy } from 'katagami/lazy';
+ *
+ * const container = createContainer()
+ *   .registerSingleton(HeavyService, () => new HeavyService());
+ *
+ * const scope = createScope(container);
+ * const service = lazy(scope, HeavyService);
+ * // Instance is NOT created yet
+ * service.doSomething(); // resolved here, then cached
+ * ```
+ */
+export declare function lazy<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor, V>(source: Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>, token: AbstractConstructor<V> & (Sync | ScopedSync)): V;
+export declare function lazy<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor, V>(source: DisposableScope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>, token: AbstractConstructor<V> & (Sync | ScopedSync)): V;

package/dist/lazy/index.d.ts

@@ -1,6 +1,6 @@
-import type { DisposableScope } from '../disposable';
-import type { AbstractConstructor } from '../resolver';
-import type { Scope } from '../scope';
+import type { DisposableScope } from '../disposable/index.js';
+import type { AbstractConstructor } from '../resolver/index.js';
+import type { Scope } from '../scope/index.js';
 /**
  * Create a lazy proxy that defers resolution until the first property access.
  *

package/dist/lazy/index.js

@@ -9,7 +9,7 @@ function lazy(source, token) {
     }
     return instance;
   };
-  const proxyTarget = Object.create(null);
+  const proxyTarget = /* @__PURE__ */ Object.create(null);
   return new Proxy(proxyTarget, {
     defineProperty(_, prop, desc) {
       return Reflect.defineProperty(ensureResolved(), prop, desc);

package/dist/resolver/index.d.cts

@@ -0,0 +1,93 @@
+export type AbstractConstructor<T = unknown> = abstract new (...args: never[]) => T;
+/**
+ * Resolver passed to factory callbacks.
+ *
+ * @template T PropertyKey-based type map (defined via interface, order-independent)
+ * @template Sync Union of registered sync class constructors (order-dependent)
+ * @template Async Union of registered async class constructors (order-dependent)
+ */
+export interface Resolver<T, Sync extends AbstractConstructor = AbstractConstructor, Async extends AbstractConstructor = never> {
+    /**
+     * Resolve an instance for the given token.
+     *
+     * @param token A registered token
+     * @returns The instance associated with the token
+     */
+    resolve<V>(token: AbstractConstructor<V> & Async): Promise<V>;
+    resolve<V>(token: AbstractConstructor<V> & Sync): V;
+    resolve<K extends keyof T>(token: K): T[K];
+    /**
+     * Try to resolve an instance for the given token.
+     *
+     * Returns `undefined` instead of throwing when the token is not registered.
+     * Other errors (circular dependency, disposed container) are still thrown.
+     *
+     * @param token A token to resolve
+     * @returns The instance associated with the token, or `undefined` if not registered
+     */
+    tryResolve<V>(token: AbstractConstructor<V> & Async): Promise<V> | undefined;
+    tryResolve<V>(token: AbstractConstructor<V> & Sync): V | undefined;
+    tryResolve<K extends keyof T>(token: K): T[K] | undefined;
+    tryResolve<V>(token: AbstractConstructor<V>): V | Promise<V> | undefined;
+    tryResolve(token: PropertyKey): unknown;
+    /**
+     * Resolve all instances for the given token.
+     *
+     * Returns an array of instances from all registrations for the token.
+     *
+     * @param token A registered token
+     * @returns An array of instances associated with the token
+     */
+    resolveAll<V>(token: AbstractConstructor<V> & Async): Promise<V>[];
+    resolveAll<V>(token: AbstractConstructor<V> & Sync): V[];
+    resolveAll<K extends keyof T>(token: K): T[K][];
+    /**
+     * Try to resolve all instances for the given token.
+     *
+     * Returns `undefined` instead of throwing when the token is not registered.
+     * Other errors (circular dependency, disposed container) are still thrown.
+     *
+     * @param token A token to resolve
+     * @returns An array of instances associated with the token, or `undefined` if not registered
+     */
+    tryResolveAll<V>(token: AbstractConstructor<V> & Async): Promise<V>[] | undefined;
+    tryResolveAll<V>(token: AbstractConstructor<V> & Sync): V[] | undefined;
+    tryResolveAll<K extends keyof T>(token: K): T[K][] | undefined;
+    tryResolveAll<V>(token: AbstractConstructor<V>): (V | Promise<V>)[] | undefined;
+    tryResolveAll(token: PropertyKey): unknown;
+}
+/**
+ * Lifetime of a registration.
+ */
+export type Lifetime = 'singleton' | 'transient' | 'scoped';
+/**
+ * Factory registration entry.
+ */
+export interface Registration {
+    /**
+     * Factory function.
+     *
+     * @param resolver Resolver
+     * @returns Instance
+     */
+    readonly factory: (resolver: Resolver<never, never>) => unknown;
+    /**
+     * Lifetime of the registration.
+     */
+    readonly lifetime: Lifetime;
+}
+/**
+ * Convert a token to a human-readable string.
+ */
+export declare function tokenToString(token: unknown): string;
+/**
+ * Build a human-readable circular dependency path from the resolving tokens.
+ *
+ * Uses the insertion order of Set to extract only the cycle portion.
+ * e.g. if resolvingTokens is [X, A, B, C] and token is A, returns "A -> B -> C -> A"
+ *
+ * @param resolvingTokens The set of tokens currently being resolved
+ * @param token The token that caused the circular dependency
+ * @returns Formatted cycle path string
+ */
+export declare function buildCircularPath(resolvingTokens: Set<unknown>, token: unknown): string;

package/dist/scope/index.d.cts

@@ -0,0 +1,120 @@
+import type { Container } from '../container/index.cjs';
+import type { DisposableContainer, DisposableScope } from '../disposable/index.cjs';
+import { type ContainerInternals, INTERNALS } from '../internal.cjs';
+import type { AbstractConstructor, Registration } from '../resolver/index.cjs';
+/**
+ * Create a new scope (child container) from a Container, Scope, or their disposable variants.
+ *
+ * The scope inherits all registrations from the source.
+ * Singleton instances are shared with the parent, while scoped instances are local to the scope.
+ *
+ * @param source A Container, Scope, DisposableContainer, or DisposableScope to create a child scope from
+ * @returns A new Scope instance
+ * @throws ContainerError if the source has been disposed
+ */
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: Container<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: DisposableContainer<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+export declare function createScope<T, Sync extends AbstractConstructor, Async extends AbstractConstructor, ScopedT, ScopedSync extends AbstractConstructor, ScopedAsync extends AbstractConstructor>(source: DisposableScope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>): Scope<T, Sync, Async, ScopedT, ScopedSync, ScopedAsync>;
+/**
+ * Scoped child container.
+ *
+ * Inherits all registrations from the parent container.
+ * Singleton instances are shared with the parent, while scoped instances are local to this scope.
+ * Transient instances are always newly created.
+ *
+ * @template T PropertyKey-based token type map
+ * @template Sync Union of registered sync class constructors
+ * @template Async Union of registered async class constructors
+ * @template ScopedT PropertyKey-based token type map for scoped registrations
+ * @template ScopedSync Union of scoped sync class constructors
+ * @template ScopedAsync Union of scoped async class constructors
+ */
+export declare class Scope<T = Record<never, never>, Sync extends AbstractConstructor = never, Async extends AbstractConstructor = never, ScopedT = Record<never, never>, ScopedSync extends AbstractConstructor = never, ScopedAsync extends AbstractConstructor = never> {
+    private readonly registrations;
+    private readonly singletonCache;
+    private readonly scopedCache;
+    private readonly resolvingTokens;
+    private singletonDepth;
+    private disposed;
+    /**
+     * Internal state accessor for extension modules (scope, disposable).
+     *
+     * @internal
+     */
+    readonly [INTERNALS]: ContainerInternals;
+    constructor(registrations: Map<unknown, Registration[]>, singletonCache: Map<Registration, unknown>);
+    /**
+     * Resolve an instance for the given token.
+     *
+     * - Singleton: Returns the shared instance from the parent container (creates and caches on first access).
+     * - Scoped: Returns an instance local to this scope (creates and caches on first access within the scope).
+     * - Transient: Creates a new instance on every call.
+     *
+     * @param token A registered token
+     * @returns The instance associated with the token
+     * @throws ContainerError if the token is not registered
+     */
+    resolve<V>(token: AbstractConstructor<V> & (Async | ScopedAsync)): Promise<V>;
+    resolve<V>(token: AbstractConstructor<V> & (Sync | ScopedSync)): V;
+    resolve<K extends keyof (T & ScopedT)>(token: K): (T & ScopedT)[K];
+    /**
+     * Try to resolve an instance for the given token.
+     *
+     * Returns `undefined` instead of throwing when the token is not registered.
+     * Other errors (circular dependency, disposed scope) are still thrown.
+     *
+     * @param token A token to resolve
+     * @returns The instance associated with the token, or `undefined` if not registered
+     */
+    tryResolve<V>(token: AbstractConstructor<V> & (Async | ScopedAsync)): Promise<V> | undefined;
+    tryResolve<V>(token: AbstractConstructor<V> & (Sync | ScopedSync)): V | undefined;
+    tryResolve<K extends keyof (T & ScopedT)>(token: K): (T & ScopedT)[K] | undefined;
+    tryResolve<V>(token: AbstractConstructor<V>): V | Promise<V> | undefined;
+    tryResolve(token: PropertyKey): unknown;
+    /**
+     * Resolve all instances for the given token.
+     *
+     * Returns an array of instances from all registered factories for the token,
+     * in registration order.
+     *
+     * @param token A registered token
+     * @returns An array of instances associated with the token
+     * @throws ContainerError if the token is not registered
+     */
+    resolveAll<V>(token: AbstractConstructor<V> & (Async | ScopedAsync)): Promise<V>[];
+    resolveAll<V>(token: AbstractConstructor<V> & (Sync | ScopedSync)): V[];
+    resolveAll<K extends keyof (T & ScopedT)>(token: K): (T & ScopedT)[K][];
+    /**
+     * Try to resolve all instances for the given token.
+     *
+     * Returns `undefined` instead of throwing when the token is not registered.
+     * Other errors (circular dependency, disposed scope) are still thrown.
+     *
+     * @param token A token to resolve
+     * @returns An array of instances associated with the token, or `undefined` if not registered
+     */
+    tryResolveAll<V>(token: AbstractConstructor<V> & (Async | ScopedAsync)): Promise<V>[] | undefined;
+    tryResolveAll<V>(token: AbstractConstructor<V> & (Sync | ScopedSync)): V[] | undefined;
+    tryResolveAll<K extends keyof (T & ScopedT)>(token: K): (T & ScopedT)[K][] | undefined;
+    tryResolveAll<V>(token: AbstractConstructor<V>): (V | Promise<V>)[] | undefined;
+    tryResolveAll(token: PropertyKey): unknown;
+    /**
+     * Internal resolution logic shared by resolve and tryResolve.
+     * Resolves the last registered factory for the token.
+     *
+     * @param token Token to resolve
+     * @param required If true, throws when the token is not registered. If false, returns undefined.
+     * @returns The resolved instance, or undefined if not registered and required is false
+     */
+    private resolveToken;
+    /**
+     * Internal resolution logic shared by resolveAll and tryResolveAll.
+     * Resolves all registered factories for the token.
+     *
+     * @param token Token to resolve
+     * @param required If true, throws when the token is not registered. If false, returns undefined.
+     * @returns An array of resolved instances, or undefined if not registered and required is false
+     */
+    private resolveAllTokens;
+}

package/dist/scope/index.d.ts

@@ -1,7 +1,7 @@
-import type { Container } from '../container';
-import type { DisposableContainer, DisposableScope } from '../disposable';
-import { type ContainerInternals, INTERNALS } from '../internal';
-import type { AbstractConstructor, Registration } from '../resolver';
+import type { Container } from '../container/index.js';
+import type { DisposableContainer, DisposableScope } from '../disposable/index.js';
+import { type ContainerInternals, INTERNALS } from '../internal.js';
+import type { AbstractConstructor, Registration } from '../resolver/index.js';
 /**
  * Create a new scope (child container) from a Container, Scope, or their disposable variants.
  *