katagami 2.2.0 → 3.0.0

package/README.md

@@ -12,21 +12,21 @@ Lightweight TypeScript DI container with full type inference.
 
 ## Features
 
-| Feature                       | Description                                                                                                |
-| ----------------------------- | ---------------------------------------------------------------------------------------------------------- |
-| Zero dependencies             | No decorators, no reflect-metadata, no polyfills — works with any bundler out of the box                   |
-| Full type inference           | Types accumulate through method chaining; unregistered tokens are compile-time errors                      |
-| Tree-shakeable                | Subpath exports (`katagami/scope`, `katagami/disposable`) and `sideEffects: false` for minimal bundle size |
-| Captive dependency prevention | Singleton/Transient factories cannot access scoped tokens; caught at compile time                          |
-| Hybrid token strategy         | Class tokens for strict type safety, PropertyKey tokens for flexibility                                    |
-| Interface type map            | Pass an interface to `createContainer<T>()` for order-independent registration                             |
-| Three lifetimes               | Singleton, Transient, and Scoped with child containers                                                     |
-| Disposable support            | TC39 Explicit Resource Management (`Symbol.dispose` / `Symbol.asyncDispose` / `await using`)               |
-| Module composition            | Containers can be composed via `use()` to group and reuse registrations                                    |
-| Async factories               | Promise-returning factories are automatically tracked by the type system                                   |
-| Circular dependency detection | Clear error messages with the full cycle path                                                              |
-| Optional resolution           | `tryResolve` returns `undefined` for unregistered tokens instead of throwing                               |
-| Lazy resolution               | Proxy-based deferred instantiation via `lazy()` from `katagami/lazy`; instance created on first access     |
+| Feature                       | Description                                                                                               |
+| ----------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Zero dependencies             | No decorators, no reflect-metadata, no polyfills — works with any bundler out of the box                  |
+| Full type inference           | Types accumulate through method chaining; unregistered tokens are compile-time errors                     |
+| Tree-shakeable                | Subpath exports (`katagami/disposable`, `katagami/lazy`) and `sideEffects: false` for minimal bundle size |
+| Captive dependency prevention | Singleton/Transient factories cannot access scoped tokens; caught at compile time and runtime in scopes   |
+| Hybrid token strategy         | Class tokens for strict type safety, PropertyKey tokens for flexibility                                   |
+| Interface type map            | Pass an interface to `createContainer<T>()` for order-independent registration                            |
+| Three lifetimes               | Singleton, Transient, and Scoped with child containers                                                    |
+| Disposable support            | TC39 Explicit Resource Management (`Symbol.dispose` / `Symbol.asyncDispose` / `await using`)              |
+| Module composition            | Containers can be composed via `use()` to group and reuse registrations                                   |
+| Async factories               | Promise-returning factories are automatically tracked by the type system                                  |
+| Circular dependency detection | Clear error messages with the full cycle path                                                             |
+| Optional resolution           | `tryResolve` returns `undefined` for unregistered tokens instead of throwing                              |
+| Lazy resolution               | Proxy-based deferred instantiation via `lazy()` from `katagami/lazy`; instance created on first access    |
 
 ## Install
 
@@ -37,7 +37,7 @@ npm install katagami
 ## Quick Start
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class Logger {
 	log(msg: string) {
@@ -56,7 +56,7 @@ const container = createContainer()
 	.registerSingleton(Logger, () => new Logger())
 	.registerSingleton(UserService, r => new UserService(r.resolve(Logger)));
 
-const userService = container.resolve(UserService);
+const userService = createScope(container).resolve(UserService);
 //    ^? UserService (fully inferred)
 userService.greet('world');
 ```
@@ -65,20 +65,42 @@ userService.greet('world');
 
 Most TypeScript DI containers rely on decorators, reflect-metadata, or string-based tokens — each bringing trade-offs in tooling compatibility, type safety, or bundle size. Katagami takes a different approach.
 
+> **Note:** This comparison was researched on 2026-02-09. Features may have changed since then.
+
+| Aspect                            | Katagami                                                         | InversifyJS                      | tsyringe                                        | TypeDI                                  | Awilix                              | NestJS                                | Effect                            | typed-inject                   |
+| --------------------------------- | ---------------------------------------------------------------- | -------------------------------- | ----------------------------------------------- | --------------------------------------- | ----------------------------------- | ------------------------------------- | --------------------------------- | ------------------------------ |
+| **Runtime requirements**          | ✅ None                                                          | ❌ reflect-metadata, decorators  | ❌ reflect-metadata, decorators                 | ❌ reflect-metadata, decorators         | ✅ None                             | ❌ reflect-metadata, decorators       | ✅ None                           | ✅ None                        |
+| **Lifetimes**                     | ✅ Singleton, Transient, Scoped                                  | ✅ Singleton, Transient, Request | ✅ Singleton, Transient, Resolution / Container | Singleton, Transient (named containers) | ✅ Singleton, Transient, Scoped     | ✅ Singleton, Transient, Request      | Shared (memoized), Scoped         | ❌ Singleton, Transient        |
+| **Injection style**               | Constructor (explicit factory)                                   | Constructor, Property            | Constructor                                     | Constructor, Property                   | Constructor (proxy / classic)       | Constructor                           | Functional (Tag + Layer)          | Constructor (static inject)    |
+| **Token types**                   | Class, PropertyKey, Interface map                                | Class, String, Symbol            | Class, String, Symbol                           | Class, String, Token\<T\>               | String                              | Class, String, Symbol, InjectionToken | Context.Tag                       | String literal                 |
+| **Type safety**                   | ✅ Compile-time; full inference, captive-dep guard (+ runtime)   | ❌ Generic binding types         | ❌ Generic types                                | ❌ Generic types, Token\<T\>            | ❌ Cradle interface typing          | ❌ Generic types                      | ✅ Compile-time; R type parameter | ✅ Compile-time; static inject |
+| **Resource cleanup**              | ✅ TC39 Symbol.dispose / asyncDispose; await using               | Deactivation handlers            | container.dispose()                             | Container.reset()                       | Disposer functions                  | Lifecycle hooks (onModuleDestroy)     | Scope finalizers; acquireRelease  | injector.dispose()             |
+| **Tree-shaking**                  | ✅ Subpath exports; sideEffects: false                           | ❌                               | ❌                                              | ❌                                      | ✅ No decorator / metadata overhead | ❌                                    | ✅ Subpath exports; ESM           | ✅ Zero deps; small bundle     |
+| **Async factories**               | ✅                                                               | ✅                               | ❌                                              | ❌                                      | ❌                                  | ✅                                    | ✅                                | ❌                             |
+| **Optional resolution**           | ✅                                                               | ✅                               | ✅                                              | ✅                                      | ✅                                  | ✅                                    | ✅                                | ❌                             |
+| **Multi-binding**                 | ✅                                                               | ✅                               | ✅                                              | ✅                                      | ❌                                  | ❌                                    | ❌                                | ❌                             |
+| **Lazy resolution**               | ✅                                                               | ✅                               | ✅                                              | ❌                                      | ✅                                  | ✅ LazyModuleLoader                   | ✅ Lazy by design                 | ❌                             |
+| **Conditional bindings**          | ✅ Token separation + factory logic + scopes                     | ✅ Named, tagged, contextual     | ❌                                              | ❌                                      | ❌                                  | ❌                                    | ❌                                | ❌                             |
+| **Auto-loading**                  | ✅ use() module composition (explicit, decorator-free by design) | ✅                               | ❌                                              | ❌                                      | ✅                                  | ❌                                    | ❌                                | ❌                             |
+| **Child containers**              | ✅                                                               | ✅                               | ✅                                              | ✅                                      | ✅                                  | ✅                                    | ✅                                | ✅                             |
+| **Module system**                 | ✅                                                               | ✅                               | ❌                                              | ❌                                      | ✅                                  | ✅                                    | ✅                                | ❌                             |
+| **Circular dependency detection** | ✅                                                               | ✅                               | ✅                                              | ❌                                      | ✅                                  | ✅                                    | ✅                                | ❌                             |
+| **Middleware / Interceptors**     | ✅ Higher-order factory wrappers                                 | ✅                               | ✅                                              | ❌                                      | ❌                                  | ❌                                    | ❌                                | ❌                             |
+| **Snapshot / Restore**            | ✅ Immutable containers; use() for test isolation                | ✅                               | ❌                                              | ❌                                      | ❌                                  | ❌                                    | ❌                                | ❌                             |
+
 ### No decorators, no reflect-metadata
 
 Decorator-based DI requires `experimentalDecorators` and `emitDecoratorMetadata` compiler options. Modern build tools such as esbuild and Vite (default configuration) do not support `emitDecoratorMetadata`, and the TC39 standard decorators proposal does not include an equivalent for automatic type metadata emission. Katagami depends on none of these — it works with any build tool out of the box.
 
 ### Tree-shakeable
 
-Katagami is split into subpath exports. Import only what you use — `katagami/scope`, `katagami/disposable`, and `katagami/lazy` are completely eliminated from the bundle if not imported. Combined with `sideEffects: false`, bundlers can remove every unused byte.
+Katagami is split into subpath exports. Import only what you use — `katagami/disposable` and `katagami/lazy` are completely eliminated from the bundle if not imported. Combined with `sideEffects: false`, bundlers can remove every unused byte.
 
 ```ts
-// Core only — scope, disposable, and lazy are not included in the bundle
-import { createContainer } from 'katagami';
+// Core only — disposable and lazy are not included in the bundle
+import { createContainer, createScope } from 'katagami';
 
 // Import only what you need
-import { createScope } from 'katagami/scope';
 import { disposable } from 'katagami/disposable';
 import { lazy } from 'katagami/lazy';
 ```
@@ -106,7 +128,7 @@ No runtime dependencies, no polyfills. No need to add reflect-metadata (~50 KB u
 Singleton creates the instance on the first `resolve` and caches it. Transient creates a new instance every time.
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class Database {
 	constructor(public id = Math.random()) {}
@@ -120,20 +142,21 @@ const container = createContainer()
 	.registerSingleton(Database, () => new Database())
 	.registerTransient(RequestHandler, () => new RequestHandler());
 
+const scope = createScope(container);
+
 // Singleton — same instance every time
-container.resolve(Database) === container.resolve(Database); // true
+scope.resolve(Database) === scope.resolve(Database); // true
 
 // Transient — new instance every time
-container.resolve(RequestHandler) === container.resolve(RequestHandler); // false
+scope.resolve(RequestHandler) === scope.resolve(RequestHandler); // false
 ```
 
 ### Scoped Lifetime & Child Containers
 
-Scoped registrations behave like singletons within a scope but produce a fresh instance in each new scope. Import `createScope` from `katagami/scope` to create a child container. Scoped tokens cannot be resolved from the root container.
+Scoped registrations behave like singletons within a scope but produce a fresh instance in each new scope. Use `createScope` to create a child container. Scoped tokens cannot be resolved from the root container.
 
 ```ts
-import { createContainer } from 'katagami';
-import { createScope } from 'katagami/scope';
+import { createContainer, createScope } from 'katagami';
 
 class DbPool {
 	constructor(public name = 'main') {}
@@ -224,7 +247,7 @@ const container = createContainer().use(appModule);
 Factories that return a `Promise` are automatically tracked by the type system. When you `resolve` an async token, the return type is `Promise<V>` instead of `V`:
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class Database {
 	constructor(public connected: boolean) {}
@@ -243,10 +266,12 @@ const container = createContainer()
 		return new Database(true);
 	});
 
-const logger = container.resolve(Logger);
+const scope = createScope(container);
+
+const logger = scope.resolve(Logger);
 //    ^? Logger
 
-const db = await container.resolve(Database);
+const db = await scope.resolve(Database);
 //    ^? Promise<Database>  (awaited → Database)
 db.connected; // true
 ```
@@ -268,7 +293,7 @@ const container = createContainer()
 Katagami tracks which tokens are currently being resolved. If a circular dependency is found, a `ContainerError` is thrown with a clear message showing the full cycle path:
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class ServiceA {
 	constructor(public b: ServiceB) {}
@@ -282,7 +307,7 @@ const container = createContainer()
 	.registerSingleton(ServiceA, r => new ServiceA(r.resolve(ServiceB)))
 	.registerSingleton(ServiceB, r => new ServiceB(r.resolve(ServiceA)));
 
-container.resolve(ServiceA);
+createScope(container).resolve(ServiceA);
 // ContainerError: Circular dependency detected: ServiceA -> ServiceB -> ServiceA
 ```
 
@@ -297,7 +322,7 @@ ContainerError: Circular dependency detected: ServiceX -> ServiceY -> ServiceZ -
 Disposal is provided by the `disposable()` wrapper from `katagami/disposable`. Wrapping a container or scope attaches `[Symbol.asyncDispose]`, enabling `await using` syntax. When disposed, owned instances are iterated in reverse creation order (LIFO) and their `[Symbol.asyncDispose]()` or `[Symbol.dispose]()` methods are called automatically.
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 import { disposable } from 'katagami/disposable';
 
 class Connection {
@@ -307,17 +332,18 @@ class Connection {
 }
 
 // Manual disposal
-const container = disposable(createContainer().registerSingleton(Connection, () => new Connection()));
+const container = createContainer().registerSingleton(Connection, () => new Connection());
+const dc = disposable(container);
 
-container.resolve(Connection);
-await container[Symbol.asyncDispose]();
+createScope(container).resolve(Connection);
+await dc[Symbol.asyncDispose]();
 // => "Connection closed"
 ```
 
 With `await using`, scopes are automatically disposed at the end of the block:
 
 ```ts
-import { createScope } from 'katagami/scope';
+import { createContainer, createScope } from 'katagami';
 import { disposable } from 'katagami/disposable';
 
 const root = createContainer()
@@ -336,10 +362,9 @@ Scope disposal only affects scoped instances. Singleton instances are owned by t
 The `disposable()` wrapper also narrows the returned type so that registration methods (`registerSingleton`, `registerTransient`, `registerScoped`, `use`) are removed at the type level. This prevents accidental registration on a potentially-disposed container:
 
 ```ts
-const container = disposable(createContainer().registerSingleton(Connection, () => new Connection()));
+const dc = disposable(createContainer().registerSingleton(Connection, () => new Connection()));
 
-container.resolve(Connection); // OK
-container.registerSingleton(/* ... */); // Compile-time error
+dc.registerSingleton(/* ... */); // Compile-time error — registration methods are hidden
 ```
 
 ### Lazy Resolution
@@ -347,7 +372,7 @@ container.registerSingleton(/* ... */); // Compile-time error
 The `lazy()` function from `katagami/lazy` creates a proxy that defers instance creation until the first property access. This is useful for optimizing startup time or breaking circular dependencies.
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 import { lazy } from 'katagami/lazy';
 
 class HeavyService {
@@ -360,8 +385,9 @@ class HeavyService {
 }
 
 const container = createContainer().registerSingleton(HeavyService, () => new HeavyService());
+const scope = createScope(container);
 
-const service = lazy(container, HeavyService);
+const service = lazy(scope, HeavyService);
 // HeavyService is NOT instantiated yet
 
 service.process(); // instance created here, then cached
@@ -372,11 +398,9 @@ The proxy transparently forwards all property access, method calls, `in` checks,
 
 Only **sync class tokens** are supported. Async tokens and PropertyKey tokens are rejected at the type level because Proxy traps are synchronous.
 
-`lazy()` works with Container, Scope, DisposableContainer, and DisposableScope:
+`lazy()` works with Scope and DisposableScope:
 
 ```ts
-import { createScope } from 'katagami/scope';
-
 const root = createContainer().registerScoped(RequestContext, () => new RequestContext());
 const scope = createScope(root);
 
@@ -385,14 +409,13 @@ const ctx = lazy(scope, RequestContext); // deferred scoped resolution
 
 ### Tree Shaking
 
-Katagami uses subpath exports to split functionality into independent entry points. If you only need the core container, `katagami/scope`, `katagami/disposable`, and `katagami/lazy` are completely excluded from the bundle. The package declares `sideEffects: false`, so bundlers can safely eliminate any unused code.
+Katagami uses subpath exports to split functionality into independent entry points. If you only need the core container, `katagami/disposable` and `katagami/lazy` are completely excluded from the bundle. The package declares `sideEffects: false`, so bundlers can safely eliminate any unused code.
 
 ```ts
-// Core only — scope, disposable, and lazy are not included in the bundle
-import { createContainer } from 'katagami';
+// Core only — disposable and lazy are not included in the bundle
+import { createContainer, createScope } from 'katagami';
 
 // Import only what you need
-import { createScope } from 'katagami/scope';
 import { disposable } from 'katagami/disposable';
 import { lazy } from 'katagami/lazy';
 ```
@@ -402,7 +425,7 @@ import { lazy } from 'katagami/lazy';
 When you pass an interface to `createContainer<T>()`, PropertyKey tokens are typed from the interface rather than accumulated through chaining. This means you can register and resolve tokens in any order:
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class Logger {
 	log(msg: string) {
@@ -423,7 +446,7 @@ const container = createContainer<Services>()
 	})
 	.registerSingleton('logger', () => new Logger());
 
-const greeting = container.resolve('greeting');
+const greeting = createScope(container).resolve('greeting');
 //    ^? string
 ```
 
@@ -468,12 +491,29 @@ const container = createContainer()
 	});
 ```
 
+Katagami also enforces this rule at runtime within scopes. If a singleton factory attempts to resolve a scoped token — directly or through intermediaries — a `ContainerError` is thrown:
+
+```ts
+import { createContainer, createScope } from 'katagami';
+
+class DbPool {}
+class RequestContext {}
+
+const container = createContainer()
+	.registerScoped(RequestContext, () => new RequestContext())
+	.registerSingleton(DbPool, r => new DbPool(r.resolve(RequestContext)));
+
+const scope = createScope(container);
+scope.resolve(DbPool);
+// ContainerError: Captive dependency detected: scoped token "RequestContext" cannot be resolved inside a singleton factory.
+```
+
 ### Optional Resolution (tryResolve)
 
 When you need to handle optional dependencies or want to check if a token is registered without throwing an error, use `tryResolve`. Unlike `resolve`, it returns `undefined` for unregistered tokens instead of throwing `ContainerError`:
 
 ```ts
-import { createContainer } from 'katagami';
+import { createContainer, createScope } from 'katagami';
 
 class Logger {
 	log(msg: string) {
@@ -488,12 +528,13 @@ class Analytics {
 }
 
 const container = createContainer().registerSingleton(Logger, () => new Logger());
+const scope = createScope(container);
 
 // resolve throws for unregistered tokens
-container.resolve(Analytics); // ContainerError: Token "Analytics" is not registered.
+scope.resolve(Analytics); // ContainerError: Token "Analytics" is not registered.
 
 // tryResolve returns undefined for unregistered tokens
-const analytics = container.tryResolve(Analytics);
+const analytics = scope.tryResolve(Analytics);
 //    ^? Analytics | undefined
 if (analytics) {
 	analytics.track('event');
@@ -542,15 +583,7 @@ Registers a factory as scoped. Within a scope, the instance is created on the fi
 
 Copies all registrations from `source` (another `Container`) into this container. Only factory and lifetime entries are copied — singleton instance caches are not shared. Returns the container for method chaining.
 
-### `Container.prototype.resolve(token)`
-
-Resolves and returns the instance for the given token. Throws `ContainerError` if the token is not registered or if a circular dependency is detected.
-
-### `Container.prototype.tryResolve(token)`
-
-Attempts to resolve the instance for the given token. Returns `undefined` if the token is not registered, instead of throwing. Still throws `ContainerError` for circular dependencies or operations on disposed containers/scopes.
-
-### `createScope(source)` — `katagami/scope`
+### `createScope(source)`
 
 Creates a new `Scope` (child container) from a `Container` or an existing `Scope`. The scope inherits all registrations from the source. Singleton instances are shared with the parent, while scoped instances are local to the scope.
 
@@ -560,7 +593,7 @@ A scoped child container created by `createScope()`.
 
 ### `Scope.prototype.resolve(token)`
 
-Resolves and returns the instance for the given token. Behaves the same as `Container.prototype.resolve`, but can also resolve scoped tokens.
+Resolves and returns the instance for the given token. Throws `ContainerError` if the token is not registered or if a circular dependency is detected. Can resolve both non-scoped and scoped tokens.
 
 ### `Scope.prototype.tryResolve(token)`
 
@@ -568,11 +601,11 @@ Attempts to resolve the instance for the given token. Returns `undefined` if the
 
 ### `lazy(source, token)` — `katagami/lazy`
 
-Creates a Proxy that defers `resolve()` until the first property access. The resolved instance is cached — subsequent accesses use the cache. Only sync class tokens are supported; async tokens and PropertyKey tokens are rejected at the type level. Works with `Container`, `Scope`, `DisposableContainer`, and `DisposableScope`.
+Creates a Proxy that defers `resolve()` until the first property access. The resolved instance is cached — subsequent accesses use the cache. Only sync class tokens are supported; async tokens and PropertyKey tokens are rejected at the type level. Works with `Scope` and `DisposableScope`.
 
 ### `disposable(container)` — `katagami/disposable`
 
-Attaches `[Symbol.asyncDispose]` to a `Container` or `Scope`, enabling `await using` syntax. Disposes all owned instances in reverse creation order (LIFO). Calls `[Symbol.asyncDispose]()` or `[Symbol.dispose]()` on each instance that implements them. Idempotent — subsequent calls are no-ops. After disposal, `resolve()` and `createScope()` will throw `ContainerError`. The returned type is narrowed to `DisposableContainer` or `DisposableScope`, which only expose `resolve` and `tryResolve` — registration methods are excluded at the type level.
+Attaches `[Symbol.asyncDispose]` to a `Container` or `Scope`, enabling `await using` syntax. Disposes all owned instances in reverse creation order (LIFO). Calls `[Symbol.asyncDispose]()` or `[Symbol.dispose]()` on each instance that implements them. Idempotent — subsequent calls are no-ops. After disposal, `resolve()` and `createScope()` will throw `ContainerError`. The returned type is narrowed to `DisposableContainer` or `DisposableScope`. `DisposableContainer` exposes only disposal capability — registration and resolution methods are excluded. `DisposableScope` retains `resolve`, `tryResolve`, `resolveAll`, and `tryResolveAll` for resolution.
 
 ### `class ContainerError`
 

package/dist/container/index.d.ts

@@ -16,15 +16,12 @@ import type { AbstractConstructor, Resolver } from '../resolver';
  */
 export declare function createContainer<T = Record<never, never>, ScopedT = Record<never, never>>(): Container<T, never, never, ScopedT>;
 /**
- * Lightweight DI container.
+ * Lightweight DI container — registration only.
  *
- * Provides type inference through method chaining with registerSingleton/registerTransient/resolve.
- *
- * - Singleton: Creates the instance on the first resolve and returns the cached value thereafter.
- * - Transient: Creates a new instance via the factory function on every resolve.
+ * Provides type inference through method chaining with registerSingleton/registerTransient/registerScoped.
+ * Resolution is performed through a Scope created via `createScope(container)`.
  *
  * Registering the same token multiple times accumulates all factories.
- * `resolve()` returns the last registered instance, while `resolveAll()` returns all.
  *
  * @template T PropertyKey-based token type map (defined via interface, order-independent)
  * @template Sync Union of registered sync class constructors (accumulated via chaining, order-dependent)
@@ -36,7 +33,6 @@ export declare function createContainer<T = Record<never, never>, ScopedT = Reco
 export declare class Container<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 resolvingTokens;
     private disposed;
     /**
      * Internal state accessor for extension modules (scope, disposable).
@@ -100,79 +96,6 @@ export declare class Container<T = Record<never, never>, Sync extends AbstractCo
      * @returns The container for method chaining
      */
     use<MT, MSync extends AbstractConstructor, MAsync extends AbstractConstructor, MScopedT, MScopedSync extends AbstractConstructor, MScopedAsync extends AbstractConstructor>(source: Container<MT, MSync, MAsync, MScopedT, MScopedSync, MScopedAsync>): Container<T & MT, Sync | MSync, Async | MAsync, ScopedT & MScopedT, ScopedSync | MScopedSync, ScopedAsync | MScopedAsync>;
-    /**
-     * Resolve an instance for the given token.
-     *
-     * Returns the instance from the last registered factory for the token.
-     * For singleton registrations, creates the instance on the first call and caches it.
-     * For transient registrations, 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): 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 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): 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;
-    /**
-     * 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;
     /**
      * Add a registration entry. Accumulates registrations for the same token.
      *

package/dist/disposable/index.d.ts

@@ -5,9 +5,9 @@ import type { Scope } from '../scope';
 /**
  * A container wrapped with `disposable()`.
  *
- * Only `resolve`, `tryResolve`, `resolveAll`, and `tryResolveAll` are available at the type level.
  * Registration methods (`registerSingleton`, `registerTransient`, `registerScoped`, `use`)
  * are excluded, preventing accidental registration on a potentially-disposed container.
+ * Use `createScope()` to create a scope for resolution.
  *
  * @template T PropertyKey-based token type map
  * @template Sync Union of registered sync class constructors
@@ -16,7 +16,7 @@ import type { Scope } from '../scope';
  * @template ScopedSync Union of scoped sync class constructors
  * @template ScopedAsync Union of scoped async class constructors
  */
-export interface DisposableContainer<T = Record<never, never>, Sync extends AbstractConstructor = never, Async extends AbstractConstructor = never, _ScopedT = Record<never, never>, _ScopedSync extends AbstractConstructor = never, _ScopedAsync extends AbstractConstructor = never> extends Resolver<T, Sync, Async>, AsyncDisposable {
+export interface DisposableContainer<_T = Record<never, never>, _Sync extends AbstractConstructor = never, _Async extends AbstractConstructor = never, _ScopedT = Record<never, never>, _ScopedSync extends AbstractConstructor = never, _ScopedAsync extends AbstractConstructor = never> extends AsyncDisposable {
     readonly [INTERNALS]: ContainerInternals;
 }
 /**
@@ -41,8 +41,8 @@ export interface DisposableScope<T = Record<never, never>, Sync extends Abstract
  * Disposes owned instances in reverse creation order (LIFO), calling
  * `[Symbol.asyncDispose]()` or `[Symbol.dispose]()` on each instance that implements them.
  *
- * The returned type is narrowed to only expose `resolve`, `tryResolve`, `resolveAll`, and `tryResolveAll`,
- * preventing registration methods from being called on a potentially-disposed container.
+ * The returned type prevents registration methods from being called on a potentially-disposed container.
+ * For scopes, `resolve`, `tryResolve`, `resolveAll`, and `tryResolveAll` remain available.
  *
  * @param container A Container or Scope to make disposable
  * @returns The same object with `AsyncDisposable` capability added and registration methods removed from the type