@tiberjs/di 0.1.0

package/README.md

@@ -0,0 +1,123 @@
+# @tiberjs/di
+
+A hierarchical dependency container. It builds objects on demand, caches each one, and disposes what it built when the container closes.
+
+Requires **Node.js 24+**.
+
+```sh
+pnpm add @tiberjs/di @tiberjs/runner
+```
+
+## Quick start
+
+```ts
+import { Container, inject, onDispose, token } from "@tiberjs/di";
+
+const Config = token<{ url: string }>("config");
+
+class Db {
+  readonly config = inject(Config);
+
+  constructor() {
+    onDispose(() => this.close());
+  }
+
+  close(): void {}
+}
+
+await using container = new Container();
+container.provide(Config, () => ({ url: "postgres://localhost" }));
+
+const db = container.resolve(Db);
+```
+
+`Db` never mentions the container: `inject()` reads whichever container is constructing the object, and `onDispose()` registers cleanup with that same one.
+
+## The four things you will do
+
+**Register a value or interface.** A class needs no registration — it is its own token.
+
+```ts
+container.provide(Config, () => loadConfig());
+```
+
+**Resolve.** Constructed on first use, cached after that.
+
+```ts
+const db = container.resolve(Db);
+```
+
+**Scope.** A child sees its parent's providers and disposes only what it built itself.
+
+```ts
+const request = container.child();
+request.provide(CurrentUser, () => user);
+```
+
+**Dispose.** `await using`, or `await container[Symbol.asyncDispose]()`. Cleanup runs in reverse construction order.
+
+## Three things that will bite you
+
+**A token is built by the nearest container that provides it.** A class nobody provides ends up at the root and is shared. So overriding `Config` in a child does not change a `Db` the root already owns — provide `Db` in the child too:
+
+```ts
+const test = container.child();
+test.provide(Config, () => ({ url: "postgres://test" }));
+test.provide(Db, () => new Db()); // without this, Db stays the root's
+```
+
+**Register before you resolve.** Replacing a provider whose instance this container already handed out raises `ProviderConflictError`, because the cached instance would keep winning. Override in a child instead.
+
+**`inject()` needs an ambient container.** It works while an object is being constructed or disposed, inside `withContainer()`, and inside a Runner execution bound to `ContainerKey`. A method called later with none of those raises. Capture what you need during construction, or use `container.resolve()` directly.
+
+## API
+
+### Tokens
+
+|                         |                                                                            |
+| ----------------------- | -------------------------------------------------------------------------- |
+| `token<T>(description)` | A typed token for a value or interface. Same description, different token. |
+| a class                 | Its own token, default-constructed when nothing provides it.               |
+
+### `Container`
+
+|                                 |                                                                                            |
+| ------------------------------- | ------------------------------------------------------------------------------------------ |
+| `provide(token, factory)`       | Register a factory; it receives the resolving container.                                   |
+| `resolve(token)`                | Cached instance, or construct once and cache.                                              |
+| `use(token, factory, dispose?)` | Acquire an inline resource once per container, with optional explicit cleanup.             |
+| `defer(cleanup)`                | Register cleanup, including during this container's own teardown.                          |
+| `child()`                       | A container that resolves through this one.                                                |
+| `has(token)`                    | An explicit provider or a cached instance here or above — `false` for an unprovided class. |
+| `resolutionGraph()`             | Who resolved what in this tree, for diagnostics.                                           |
+| `disposeSync()`                 | Close a container that built nothing, without an `await`; `false` if it holds anything.    |
+
+### Ambient access
+
+Each reads the ambient container, so classes stay free of container plumbing.
+
+|                                     |                                                                       |
+| ----------------------------------- | --------------------------------------------------------------------- |
+| `inject(token)`                     | Resolve.                                                              |
+| `scoped(token, factory, dispose?)`  | Acquire an inline resource.                                           |
+| `onDispose(cleanup)`                | Register cleanup.                                                     |
+| `currentContainer()`                | The ambient container; raises when there is none.                     |
+| `withContainer(container, handler)` | Run `handler` with `container` ambient.                               |
+| `ContainerKey`                      | Runner context key, for binding a container to an execution yourself. |
+
+## Cleanup
+
+For each constructed value, the first of: the `dispose` you passed, `Symbol.asyncDispose`/`Symbol.dispose`, `onClose()`. A value with none is just cached.
+
+All cleanups run even if some fail; one failure is rethrown as-is, several arrive as an `AggregateError`.
+
+## Errors
+
+|                         |                                                                                                              |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `ResolutionError`       | No provider, or a cycle. Carries `reason` and `token`.                                                       |
+| `ProviderConflictError` | `provide()` after that token was resolved here. Carries `token`.                                             |
+| `ContainerClosedError`  | Used while `closing` or after `disposed`. Carries `state`.                                                   |
+| `DisposalConflictError` | Two cleanup protocols on one value, or an explicit disposer for a value someone else owns. Carries `reason`. |
+
+Errors from your own factories propagate unchanged.

package/dist/ambient.d.ts

@@ -0,0 +1,22 @@
+import { type ContextKey } from "@tiberjs/runner";
+import type { Container } from "./container.js";
+import type { Factory, InjectionToken } from "./tokens.js";
+/** The execution-context binding that carries a container across executions. */
+export declare const ContainerKey: ContextKey<Container>;
+/** Construction container first, otherwise the current execution's binding. */
+export declare function currentContainer(): Container;
+/** Resolve a dependency during construction or inside a bound execution. */
+export declare function inject<T>(token: InjectionToken<T>): T;
+/** Acquire a resource once per container and release it when that container closes. */
+export declare function scoped<T>(token: InjectionToken<T>, factory: Factory<T>, dispose?: (value: T) => unknown | Promise<unknown>): T;
+/** Register LIFO cleanup in the ambient container. */
+export declare function onDispose(cleanup: () => unknown | Promise<unknown>): void;
+/**
+ * Bind `container` as the ambient container for `handler`.
+ *
+ * The binding is always installed locally, so nested calls override an outer
+ * construction container. With an active execution it is additionally published
+ * on the context so derived executions observe the same container.
+ */
+export declare function withContainer<T>(container: Container, handler: () => T): T;
+//# sourceMappingURL=ambient.d.ts.map

package/dist/ambient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient.d.ts","sourceRoot":"","sources":["../src/ambient.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+C,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE3D,gFAAgF;AAChF,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,SAAS,CAAyC,CAAC;AAEzF,+EAA+E;AAC/E,wBAAgB,gBAAgB,IAAI,SAAS,CAgB5C;AAED,4EAA4E;AAC5E,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAErD;AAED,uFAAuF;AACvF,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjD,CAAC,CAEH;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ1E"}

package/dist/container.d.ts

@@ -0,0 +1,38 @@
+import { type ResolutionGraph } from "./resolution/graph.js";
+import type { Factory, InjectionToken } from "./tokens.js";
+/**
+ * A hierarchical dependency container and resource owner. A child resolves its
+ * ancestors' providers but owns and disposes only what it constructed itself.
+ */
+export declare class Container {
+    #private;
+    constructor(parent?: Container);
+    /** A child container resolves application singletons through its parent. */
+    child(): Container;
+    /** Includes failed attempts and active children, but never disposed containers. */
+    resolutionGraph(): ResolutionGraph;
+    /** Register a provider before the token is resolved here. */
+    provide<T>(token: InjectionToken<T>, factory: Factory<T>): void;
+    has(token: InjectionToken<unknown>): boolean;
+    /** Resolve local cache/provider, then ancestors; default classes live at root. */
+    resolve<T>(token: InjectionToken<T>): T;
+    /**
+     * Acquire inline resources once per container, with explicit or automatic
+     * disposal. Like a provider factory, `factory` receives this container.
+     */
+    use<T>(token: InjectionToken<T>, factory: Factory<T>, dispose?: (value: T) => unknown | Promise<unknown>): T;
+    /**
+     * Register LIFO cleanup. Blind to the phase on purpose: a resource released
+     * mid-drain may still register its own cleanup, and only the queue knows
+     * whether anything is left to run it.
+     */
+    defer(cleanup: () => unknown | Promise<unknown>): void;
+    /**
+     * Close a container that never constructed or deferred anything, avoiding an
+     * `await`. Returns `false` and changes nothing otherwise.
+     */
+    disposeSync(): boolean;
+    /** Close acquisition synchronously, then clear resolution storage after teardown. */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=container.d.ts.map

package/dist/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAKhF,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAI3D;;;GAGG;AACH,qBAAa,SAAS;;gBAWR,MAAM,CAAC,EAAE,SAAS;IAwB9B,4EAA4E;IAC5E,KAAK,IAAI,SAAS;IAKlB,mFAAmF;IACnF,eAAe,IAAI,eAAe;IAIlC,6DAA6D;IAC7D,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAK/D,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO;IAI5C,kFAAkF;IAClF,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IA6BvC;;;OAGG;IACH,GAAG,CAAC,CAAC,EACH,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjD,CAAC;IAaJ;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;IAItD;;;OAGG;IACH,WAAW,IAAI,OAAO;IAUtB,qFAAqF;IACrF,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAuDvC"}

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+import { type InjectionToken } from "./tokens.js";
+/** A container resolution failure; provider exceptions propagate unchanged. */
+export declare class ResolutionError extends Error {
+    readonly reason: "missing-provider" | "circular-dependency";
+    readonly token: InjectionToken<unknown>;
+    constructor(reason: "missing-provider" | "circular-dependency", token: InjectionToken<unknown>, options?: ErrorOptions);
+}
+/** Resource admission failed because this container's teardown has begun. */
+export declare class ContainerClosedError extends Error {
+    readonly state: "closing" | "disposed";
+    constructor(state: "closing" | "disposed", options?: ErrorOptions);
+}
+/** A provider cannot replace an instance this container has already handed out. */
+export declare class ProviderConflictError extends Error {
+    readonly token: InjectionToken<unknown>;
+    constructor(token: InjectionToken<unknown>);
+}
+/** An object must have exactly one disposal owner and one automatic close protocol. */
+export declare class DisposalConflictError extends Error {
+    readonly reason: "multiple-hooks" | "already-owned";
+    constructor(reason: "multiple-hooks" | "already-owned");
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAEjE,+EAA+E;AAC/E,qBAAa,eAAgB,SAAQ,KAAK;IAEtC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,qBAAqB;IAC3D,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC;gBAD9B,MAAM,EAAE,kBAAkB,GAAG,qBAAqB,EAClD,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EACvC,OAAO,CAAC,EAAE,YAAY;CAUzB;AAED,6EAA6E;AAC7E,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU;gBAA7B,KAAK,EAAE,SAAS,GAAG,UAAU,EACtC,OAAO,CAAC,EAAE,YAAY;CAKzB;AAED,mFAAmF;AACnF,qBAAa,qBAAsB,SAAQ,KAAK;IAClC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC;gBAA9B,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC;CAMpD;AAED,uFAAuF;AACvF,qBAAa,qBAAsB,SAAQ,KAAK;IAClC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe;gBAA1C,MAAM,EAAE,gBAAgB,GAAG,eAAe;CAQhE"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/** Hierarchical dependency resolution and resource ownership. */
+export { ContainerKey, currentContainer, inject, onDispose, scoped, withContainer, } from "./ambient.js";
+export type { ContainerObject } from "./resources/cleanup.js";
+export { Container } from "./container.js";
+export { ContainerClosedError, DisposalConflictError, ProviderConflictError, ResolutionError, } from "./errors.js";
+export type { ResolutionGraph } from "./resolution/graph.js";
+export { token } from "./tokens.js";
+export type { Constructor, Factory, InjectionToken, Token } from "./tokens.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AAEjE,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,SAAS,EACT,MAAM,EACN,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,634 @@
+import { combinedError, contextKey, peekState, provide, withContext } from "@tiberjs/runner";
+import { AsyncLocalStorage } from "node:async_hooks";
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  mc: () => (/* reexport */ Container),
+  a$: () => (/* reexport */ ContainerClosedError),
+  jc: () => (/* reexport */ ContainerKey),
+  uP: () => (/* reexport */ DisposalConflictError),
+  kb: () => (/* reexport */ ProviderConflictError),
+  fe: () => (/* reexport */ ResolutionError),
+  zt: () => (/* reexport */ currentContainer),
+  WQ: () => (/* reexport */ inject),
+  zp: () => (/* reexport */ onDispose),
+  P1: () => (/* reexport */ scoped),
+  Sh: () => (/* reexport */ tokens_token),
+  Ub: () => (/* reexport */ withContainer)
+});
+
+;// CONCATENATED MODULE: external "@tiberjs/runner"
+
+;// CONCATENATED MODULE: external "node:async_hooks"
+
+;// CONCATENATED MODULE: ./src/resources/active-container.ts
+
+/**
+ * The container bound as ambient while one of its resources is constructed or
+ * torn down. Nested construction overrides it for the inner call only.
+ */ const activeContainer = new AsyncLocalStorage();
+
+;// CONCATENATED MODULE: ./src/ambient.ts
+
+
+/** The execution-context binding that carries a container across executions. */ const ContainerKey = contextKey("di.container");
+/** Construction container first, otherwise the current execution's binding. */ function currentContainer() {
+    const constructing = activeContainer.getStore();
+    if (constructing) {
+        return constructing;
+    }
+    // One state read and one frame walk: inject() runs on request paths, and a
+    // bound container is never undefined, so absence needs no separate probe.
+    const bound = peekState()?.context.values.get(ContainerKey.id);
+    if (!bound) {
+        throw new Error("No active container. This API requires construction, disposal, withContainer(), or an execution bound to ContainerKey.");
+    }
+    return bound;
+}
+/** Resolve a dependency during construction or inside a bound execution. */ function inject(token) {
+    return currentContainer().resolve(token);
+}
+/** Acquire a resource once per container and release it when that container closes. */ function scoped(token, factory, dispose) {
+    return currentContainer().use(token, factory, dispose);
+}
+/** Register LIFO cleanup in the ambient container. */ function onDispose(cleanup) {
+    currentContainer().defer(cleanup);
+}
+/**
+ * Bind `container` as the ambient container for `handler`.
+ *
+ * The binding is always installed locally, so nested calls override an outer
+ * construction container. With an active execution it is additionally published
+ * on the context so derived executions observe the same container.
+ */ function withContainer(container, handler) {
+    if (peekState()) {
+        return withContext([
+            provide(ContainerKey, container)
+        ], ()=>activeContainer.run(container, handler));
+    }
+    return activeContainer.run(container, handler);
+}
+
+;// CONCATENATED MODULE: ./src/tokens.ts
+function tokens_token(description) {
+    return {
+        key: Symbol(description)
+    };
+}
+function describeToken(token) {
+    if (typeof token === "function") {
+        return token.name || "anonymous class";
+    }
+    return token.key.description ?? "token";
+}
+
+;// CONCATENATED MODULE: ./src/errors.ts
+
+/** A container resolution failure; provider exceptions propagate unchanged. */ class ResolutionError extends Error {
+    reason;
+    token;
+    constructor(reason, token, options){
+        super(reason === "missing-provider" ? `No provider registered for token "${describeToken(token)}". Use provide(token, factory) for values/interfaces.` : `Circular dependency while resolving "${describeToken(token)}".`, options), this.reason = reason, this.token = token;
+        this.name = "ResolutionError";
+    }
+}
+/** Resource admission failed because this container's teardown has begun. */ class ContainerClosedError extends Error {
+    state;
+    constructor(state, options){
+        super(state === "closing" ? "Container is closing." : "Container has been disposed.", options), this.state = state;
+        this.name = "ContainerClosedError";
+    }
+}
+/** A provider cannot replace an instance this container has already handed out. */ class ProviderConflictError extends Error {
+    token;
+    constructor(token){
+        super(`"${describeToken(token)}" is already resolved in this container. Register providers before resolving, or override the token in a child container.`), this.token = token;
+        this.name = "ProviderConflictError";
+    }
+}
+/** An object must have exactly one disposal owner and one automatic close protocol. */ class DisposalConflictError extends Error {
+    reason;
+    constructor(reason){
+        super(reason === "multiple-hooks" ? "ContainerObject.onClose cannot coexist with Symbol.asyncDispose or Symbol.dispose." : "An explicit disposer cannot take ownership of an already-owned resource."), this.reason = reason;
+        this.name = "DisposalConflictError";
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resolution/graph.ts
+
+/**
+ * Root-local resolution diagnostics. Node identity is per container, and both
+ * edge directions are indexed so removing a disposed container costs its own
+ * nodes rather than a full scan.
+ */ class ResolutionTracker {
+    #nextId = 0;
+    #idsByOwner = new WeakMap();
+    #nodes = new Map();
+    #outgoing = new Map();
+    #incoming = new Map();
+    /** Records a resolution as a dependency of the construction that requested it. */ record(owner, token, parent) {
+        let ids = this.#idsByOwner.get(owner);
+        if (!ids) {
+            this.#idsByOwner.set(owner, ids = new Map());
+        }
+        let id = ids.get(token);
+        if (id === undefined) {
+            id = this.#nextId++;
+            ids.set(token, id);
+            this.#nodes.set(id, describeToken(token));
+        }
+        // A node never depends on itself, and a removed owner's frame links nothing.
+        if (parent && (parent.owner !== owner || parent.token !== token)) {
+            const from = this.#idsByOwner.get(parent.owner)?.get(parent.token);
+            if (from !== undefined) {
+                this.#link(from, id);
+            }
+        }
+    }
+    snapshot() {
+        const edges = [];
+        for (const [from, targets] of this.#outgoing){
+            for (const to of targets){
+                edges.push({
+                    from,
+                    to
+                });
+            }
+        }
+        return {
+            nodes: Array.from(this.#nodes, ([id, name])=>({
+                    id,
+                    name
+                })),
+            edges
+        };
+    }
+    /** Drops a disposed owner's nodes and every edge that touched them. */ remove(owner) {
+        const ids = this.#idsByOwner.get(owner);
+        if (!ids) {
+            return;
+        }
+        for (const id of ids.values()){
+            this.#nodes.delete(id);
+            this.#unlink(id);
+        }
+        this.#idsByOwner.delete(owner);
+    }
+    #link(from, to) {
+        let targets = this.#outgoing.get(from);
+        if (!targets) {
+            this.#outgoing.set(from, targets = new Set());
+        }
+        targets.add(to);
+        let sources = this.#incoming.get(to);
+        if (!sources) {
+            this.#incoming.set(to, sources = new Set());
+        }
+        sources.add(from);
+    }
+    #unlink(id) {
+        const targets = this.#outgoing.get(id);
+        if (targets) {
+            for (const to of targets){
+                this.#detach(this.#incoming, to, id);
+            }
+            this.#outgoing.delete(id);
+        }
+        const sources = this.#incoming.get(id);
+        if (sources) {
+            for (const from of sources){
+                this.#detach(this.#outgoing, from, id);
+            }
+            this.#incoming.delete(id);
+        }
+    }
+    #detach(index, node, peer) {
+        const peers = index.get(node);
+        if (peers?.delete(peer) && peers.size === 0) {
+            index.delete(node);
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resolution/path.ts
+
+/**
+ * The chain of constructions in flight under one container tree, newest last.
+ *
+ * A frame is a container and a token together, so the same token may be in
+ * flight in two containers while a child decorates an ancestor's
+ * implementation; only a container re-entering its own token is a cycle.
+ */ class ResolutionPath {
+    #frames = [];
+    /** The construction that whatever resolves next belongs to. */ get current() {
+        return this.#frames[this.#frames.length - 1];
+    }
+    /** Rejects a container that re-enters a token it is already constructing. */ enter(owner, token) {
+        for (const frame of this.#frames){
+            if (frame.owner === owner && frame.token === token) {
+                throw new ResolutionError("circular-dependency", token);
+            }
+        }
+        this.#frames.push({
+            owner,
+            token
+        });
+    }
+    /** A failed attempt leaves no trace, so the token stays resolvable. */ exit() {
+        this.#frames.pop();
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resolution/providers.ts
+
+/** One container's providers and the instances it has constructed. */ class ProviderRegistry {
+    #factories;
+    #instances;
+    /** Whether this container has ever cached an instance of its own. */ get hasInstances() {
+        return this.#instances !== undefined;
+    }
+    /** An explicit provider or a cached instance, never a constructibility probe. */ has(token) {
+        return (this.#instances?.has(token) ?? false) || (this.#factories?.has(token) ?? false);
+    }
+    /** Distinguishes a cached `undefined` from a missing instance. */ hasInstance(token) {
+        return this.#instances?.has(token) ?? false;
+    }
+    instance(token) {
+        return this.#instances?.get(token);
+    }
+    hasFactory(token) {
+        return this.#factories?.has(token) ?? false;
+    }
+    factory(token) {
+        return this.#factories?.get(token);
+    }
+    /**
+   * Replacing a factory whose instance this container already handed out is
+   * rejected: the cached instance would silently win. Override in a child.
+   */ provide(token, factory) {
+        if (this.#instances?.has(token)) {
+            throw new ProviderConflictError(token);
+        }
+        (this.#factories ??= new Map()).set(token, factory);
+    }
+    cache(token, value) {
+        (this.#instances ??= new Map()).set(token, value);
+    }
+    /** Disposal makes the container unusable, so its storage is released. */ clear() {
+        this.#factories = undefined;
+        this.#instances = undefined;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resources/cleanup.ts
+
+/**
+ * Precedence is explicit disposer, then `Symbol.asyncDispose`/`Symbol.dispose`,
+ * then `ContainerObject.onClose`. `onClose` beside a symbol disposer is
+ * ambiguous and refused, unless an explicit disposer overrides both shapes.
+ */ function planCleanup(value, explicitDispose) {
+    const asyncDispose = value[Symbol.asyncDispose];
+    const dispose = value[Symbol.dispose];
+    const onClose = value.onClose;
+    const symbolDispose = typeof asyncDispose === "function" ? asyncDispose : dispose;
+    const cleanup = explicitDispose ? ()=>explicitDispose(value) : typeof symbolDispose === "function" ? ()=>symbolDispose.call(value) : typeof onClose === "function" ? ()=>onClose.call(value) : undefined;
+    const conflict = !explicitDispose && typeof onClose === "function" && typeof symbolDispose === "function" ? new DisposalConflictError("multiple-hooks") : undefined;
+    return {
+        cleanup,
+        conflict
+    };
+}
+
+;// CONCATENATED MODULE: ./src/resources/queue.ts
+
+
+/**
+ * LIFO cleanup storage for one owner, drained once. Knows nothing about
+ * containers: every callback runs through the invoker its owner supplied.
+ */ class DisposalQueue {
+    invoke;
+    #cleanups;
+    #drained = false;
+    constructor(invoke){
+        this.invoke = invoke;
+    }
+    /** Cleanup registered while draining is drained too; after that nothing would run it. */ defer(cleanup) {
+        if (this.#drained) {
+            throw new ContainerClosedError("disposed");
+        }
+        (this.#cleanups ??= []).push(cleanup);
+    }
+    /** Drains in reverse registration order, retaining independent failures. */ async close() {
+        // Yield past a synchronous factory that initiated disposal before returning its resource.
+        await Promise.resolve();
+        const errors = [];
+        while(this.#cleanups?.length){
+            try {
+                await this.invoke(this.#cleanups.pop());
+            } catch (error) {
+                errors.push(error);
+            }
+        }
+        this.#drained = true;
+        this.#cleanups = undefined;
+        // Independent failures keep their identity, in drain order.
+        if (errors.length) {
+            throw combinedError(errors, "Errors during disposal.");
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resources/owner.ts
+
+
+
+
+/**
+ * The resources one container owns: it binds the ambient container around
+ * construction and teardown, claims each constructed value at most once, and
+ * releases what it claimed in LIFO order.
+ */ class ResourceOwner {
+    container;
+    ownership;
+    #queue;
+    constructor(container, ownership){
+        this.container = container;
+        this.ownership = ownership;
+        this.#queue = new DisposalQueue((cleanup)=>activeContainer.run(container, cleanup));
+    }
+    /** Only the queue knows whether it already drained, so admission is its call. */ defer(cleanup) {
+        this.#queue.defer(cleanup);
+    }
+    /** Construct with ambient resolution bound, then take disposal ownership. */ construct(factory, dispose) {
+        const value = activeContainer.run(this.container, factory, this.container);
+        this.#adopt(value, dispose);
+        return value;
+    }
+    /** Once drained, this owner is responsible for nothing it claimed. */ close() {
+        return this.#queue.close().finally(()=>this.ownership.release(this));
+    }
+    #adopt(value, explicitDispose) {
+        if (value === null || typeof value !== "object" && typeof value !== "function") {
+            if (explicitDispose) {
+                this.defer(()=>explicitDispose(value));
+            }
+            return;
+        }
+        const target = value;
+        if (this.ownership.hasLiveOwner(target)) {
+            // An alias of a live resource borrows it; a second disposer would double-release.
+            if (explicitDispose) {
+                throw new DisposalConflictError("already-owned");
+            }
+            return;
+        }
+        const plan = planCleanup(value, explicitDispose);
+        if (plan.cleanup) {
+            this.defer(plan.cleanup);
+            this.ownership.claim(target, this);
+        }
+        // Registered cleanup above survives refusal, because the value is never returned.
+        if (plan.conflict) {
+            this.ownership.reject(target, plan.conflict);
+            throw plan.conflict;
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/resources/ownership.ts
+/** A permanently refused value, boxed so it is never mistaken for an owner. */ class Rejection {
+    error;
+    constructor(error){
+        this.error = error;
+    }
+}
+// Keyed by root so surviving children share ownership without initializing a
+// closed ancestor's resources.
+const registriesByRoot = new WeakMap();
+/** At most one disposal owner per object, shared across one container tree. */ class OwnershipRegistry {
+    #entries = new WeakMap();
+    #drained = new WeakSet();
+    /** Every container descending from `root` claims into the same registry. */ static forRoot(root) {
+        let registry = registriesByRoot.get(root);
+        if (!registry) {
+            registriesByRoot.set(root, registry = new OwnershipRegistry());
+        }
+        return registry;
+    }
+    /**
+   * Whether someone is still responsible for releasing `value`; an owner that
+   * already drained leaves it adoptable again. Rethrows a refused shape's
+   * cached rejection so every later alias of that object fails identically.
+   */ hasLiveOwner(value) {
+        const entry = this.#entries.get(value);
+        if (entry instanceof Rejection) {
+            throw entry.error;
+        }
+        return entry !== undefined && !this.#drained.has(entry);
+    }
+    claim(value, owner) {
+        this.#entries.set(value, owner);
+    }
+    /** `owner` finished its cleanup: every value it claimed is unowned again. */ release(owner) {
+        this.#drained.add(owner);
+    }
+    /** Refusal is permanent: `value` can never gain a disposal owner afterwards. */ reject(value, error) {
+        this.#entries.set(value, new Rejection(error));
+    }
+}
+
+;// CONCATENATED MODULE: ./src/container.ts
+
+
+
+
+
+
+/**
+ * A hierarchical dependency container and resource owner. A child resolves its
+ * ancestors' providers but owns and disposes only what it constructed itself.
+ */ class Container {
+    #parent;
+    #root;
+    #providers = new ProviderRegistry();
+    #path;
+    /** Diagnostics live on the root; a child records into its root's tracker. */ #graph;
+    #resources;
+    #disposal;
+    #phase = "open";
+    constructor(parent){
+        this.#parent = parent;
+        this.#root = parent ? parent.#root : this;
+        this.#path = parent ? parent.#path : new ResolutionPath();
+    }
+    get #owner() {
+        if (!this.#resources) {
+            // A drained container must not build an owner whose queue nothing drains.
+            this.#admitRetainedAccess();
+            this.#resources = new ResourceOwner(this, OwnershipRegistry.forRoot(this.#root));
+        }
+        return this.#resources;
+    }
+    /** Undefined once the root is gone, so a surviving child cannot repopulate it. */ get #tracker() {
+        if (this.#root.#phase === "disposed") {
+            return undefined;
+        }
+        return this.#root.#graph ??= new ResolutionTracker();
+    }
+    /** A child container resolves application singletons through its parent. */ child() {
+        this.#admitNewAcquisition();
+        return new Container(this);
+    }
+    /** Includes failed attempts and active children, but never disposed containers. */ resolutionGraph() {
+        return this.#root.#graph?.snapshot() ?? {
+            nodes: [],
+            edges: []
+        };
+    }
+    /** Register a provider before the token is resolved here. */ provide(token, factory) {
+        this.#admitNewAcquisition();
+        this.#providers.provide(token, factory);
+    }
+    has(token) {
+        return this.#providers.has(token) || (this.#parent?.has(token) ?? false);
+    }
+    /** Resolve local cache/provider, then ancestors; default classes live at root. */ resolve(token) {
+        if (this.#providers.hasInstance(token)) {
+            this.#admitRetainedAccess();
+            this.#tracker?.record(this, token, this.#path.current);
+            return this.#providers.instance(token);
+        }
+        // Ancestors own their own admission; a closing child may still read singletons.
+        if (!this.#providers.hasFactory(token) && this.#parent) {
+            this.#admitRetainedAccess();
+            return this.#parent.resolve(token);
+        }
+        this.#admitNewAcquisition();
+        return this.#acquire(token, ()=>{
+            const factory = this.#providers.factory(token);
+            if (factory) {
+                return factory(this);
+            }
+            if (typeof token === "function") {
+                return new token();
+            }
+            throw new ResolutionError("missing-provider", token);
+        });
+    }
+    /**
+   * Acquire inline resources once per container, with explicit or automatic
+   * disposal. Like a provider factory, `factory` receives this container.
+   */ use(token, factory, dispose) {
+        if (this.#providers.hasInstance(token)) {
+            this.#admitRetainedAccess();
+            this.#tracker?.record(this, token, this.#path.current);
+            return this.#providers.instance(token);
+        }
+        this.#admitNewAcquisition();
+        return this.#acquire(token, factory, dispose);
+    }
+    /**
+   * Register LIFO cleanup. Blind to the phase on purpose: a resource released
+   * mid-drain may still register its own cleanup, and only the queue knows
+   * whether anything is left to run it.
+   */ defer(cleanup) {
+        this.#owner.defer(cleanup);
+    }
+    /**
+   * Close a container that never constructed or deferred anything, avoiding an
+   * `await`. Returns `false` and changes nothing otherwise.
+   */ disposeSync() {
+        if (this.#resources || this.#providers.hasInstances) {
+            return false;
+        }
+        if (this.#phase !== "disposed") {
+            this.#clearResolution();
+        }
+        return true;
+    }
+    /** Close acquisition synchronously, then clear resolution storage after teardown. */ [Symbol.asyncDispose]() {
+        if (this.#phase === "open") {
+            this.#phase = "closing";
+            this.#disposal = this.#owner.close().finally(()=>{
+                this.#clearResolution();
+            });
+        }
+        return this.#disposal ??= Promise.resolve();
+    }
+    /** Reading what this container already holds stays legal until it is disposed. */ #admitRetainedAccess() {
+        if (this.#phase === "disposed") {
+            throw new ContainerClosedError("disposed");
+        }
+    }
+    /** Providers, children, and construction stop the moment teardown begins. */ #admitNewAcquisition() {
+        const phase = this.#phase;
+        if (phase !== "open") {
+            throw new ContainerClosedError(phase);
+        }
+    }
+    #clearResolution() {
+        this.#phase = "disposed";
+        this.#providers.clear();
+        if (this === this.#root) {
+            this.#graph = undefined;
+        } else {
+            this.#root.#graph?.remove(this);
+        }
+    }
+    #acquire(token, factory, dispose) {
+        // A cycle is still an attempt worth reporting, so record before guarding.
+        this.#tracker?.record(this, token, this.#path.current);
+        this.#path.enter(this, token);
+        try {
+            const value = this.#owner.construct(factory, dispose);
+            this.#providers.cache(token, value);
+            return value;
+        } finally{
+            this.#path.exit();
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/index.ts
+/** Hierarchical dependency resolution and resource ownership. */ 
+
+
+
+
+var __webpack_exports__Container = __webpack_exports__.mc;
+var __webpack_exports__ContainerClosedError = __webpack_exports__.a$;
+var __webpack_exports__ContainerKey = __webpack_exports__.jc;
+var __webpack_exports__DisposalConflictError = __webpack_exports__.uP;
+var __webpack_exports__ProviderConflictError = __webpack_exports__.kb;
+var __webpack_exports__ResolutionError = __webpack_exports__.fe;
+var __webpack_exports__currentContainer = __webpack_exports__.zt;
+var __webpack_exports__inject = __webpack_exports__.WQ;
+var __webpack_exports__onDispose = __webpack_exports__.zp;
+var __webpack_exports__scoped = __webpack_exports__.P1;
+var __webpack_exports__token = __webpack_exports__.Sh;
+var __webpack_exports__withContainer = __webpack_exports__.Ub;
+export { __webpack_exports__Container as Container, __webpack_exports__ContainerClosedError as ContainerClosedError, __webpack_exports__ContainerKey as ContainerKey, __webpack_exports__DisposalConflictError as DisposalConflictError, __webpack_exports__ProviderConflictError as ProviderConflictError, __webpack_exports__ResolutionError as ResolutionError, __webpack_exports__currentContainer as currentContainer, __webpack_exports__inject as inject, __webpack_exports__onDispose as onDispose, __webpack_exports__scoped as scoped, __webpack_exports__token as token, __webpack_exports__withContainer as withContainer };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["webpack://@tiberjs/di/webpack/runtime/define_property_getters","webpack://@tiberjs/di/webpack/runtime/has_own_property","webpack://@tiberjs/di/./src/resources/active-container.ts","webpack://@tiberjs/di/./src/ambient.ts","webpack://@tiberjs/di/./src/tokens.ts","webpack://@tiberjs/di/./src/errors.ts","webpack://@tiberjs/di/./src/resolution/graph.ts","webpack://@tiberjs/di/./src/resolution/path.ts","webpack://@tiberjs/di/./src/resolution/providers.ts","webpack://@tiberjs/di/./src/resources/cleanup.ts","webpack://@tiberjs/di/./src/resources/queue.ts","webpack://@tiberjs/di/./src/resources/owner.ts","webpack://@tiberjs/di/./src/resources/ownership.ts","webpack://@tiberjs/di/./src/container.ts","webpack://@tiberjs/di/./src/index.ts"],"sourcesContent":["__webpack_require__.d = (exports, getters, values) => {\n\tvar define = (defs, kind) => {\n\t\tfor(var key in defs) {\n\t\t\tif(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {\n\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });\n\t\t\t}\n\t\t}\n\t};\n\tdefine(getters, \"get\");\n\tdefine(values, \"value\");\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { Container } from \"../container.js\";\n\n/**\n * The container bound as ambient while one of its resources is constructed or\n * torn down. Nested construction overrides it for the inner call only.\n */\nexport const activeContainer = new AsyncLocalStorage<Container>();\n","import { contextKey, peekState, provide, withContext, type ContextKey } from \"@tiberjs/runner\";\nimport type { Container } from \"./container.js\";\nimport { activeContainer } from \"./resources/active-container.js\";\nimport type { Factory, InjectionToken } from \"./tokens.js\";\n\n/** The execution-context binding that carries a container across executions. */\nexport const ContainerKey: ContextKey<Container> = contextKey<Container>(\"di.container\");\n\n/** Construction container first, otherwise the current execution's binding. */\nexport function currentContainer(): Container {\n  const constructing = activeContainer.getStore();\n  if (constructing) {\n    return constructing;\n  }\n\n  // One state read and one frame walk: inject() runs on request paths, and a\n  // bound container is never undefined, so absence needs no separate probe.\n  const bound = peekState()?.context.values.get(ContainerKey.id) as Container | undefined;\n  if (!bound) {\n    throw new Error(\n      \"No active container. This API requires construction, disposal, withContainer(), or an execution bound to ContainerKey.\",\n    );\n  }\n\n  return bound;\n}\n\n/** Resolve a dependency during construction or inside a bound execution. */\nexport function inject<T>(token: InjectionToken<T>): T {\n  return currentContainer().resolve(token);\n}\n\n/** Acquire a resource once per container and release it when that container closes. */\nexport function scoped<T>(\n  token: InjectionToken<T>,\n  factory: Factory<T>,\n  dispose?: (value: T) => unknown | Promise<unknown>,\n): T {\n  return currentContainer().use(token, factory, dispose);\n}\n\n/** Register LIFO cleanup in the ambient container. */\nexport function onDispose(cleanup: () => unknown | Promise<unknown>): void {\n  currentContainer().defer(cleanup);\n}\n\n/**\n * Bind `container` as the ambient container for `handler`.\n *\n * The binding is always installed locally, so nested calls override an outer\n * construction container. With an active execution it is additionally published\n * on the context so derived executions observe the same container.\n */\nexport function withContainer<T>(container: Container, handler: () => T): T {\n  if (peekState()) {\n    return withContext([provide(ContainerKey, container)], () =>\n      activeContainer.run(container, handler),\n    );\n  }\n\n  return activeContainer.run(container, handler);\n}\n","import type { Container } from \"./container.js\";\n\n/** A zero-argument constructor usable as its own injection token. */\nexport type Constructor<T = object> = new (...args: never[]) => T;\n\n/** An opaque token for values/interfaces that have no runtime class. */\nexport interface Token<T> {\n  readonly key: symbol;\n  /** Phantom carrier; never present at runtime. */\n  readonly _type?: T;\n}\n\nexport type InjectionToken<T> = Constructor<T> | Token<T>;\nexport type Factory<T> = (container: Container) => T;\n\nexport function token<T>(description: string): Token<T> {\n  return { key: Symbol(description) };\n}\n\nexport function describeToken(token: InjectionToken<unknown>): string {\n  if (typeof token === \"function\") {\n    return token.name || \"anonymous class\";\n  }\n\n  return token.key.description ?? \"token\";\n}\n","import { describeToken, type InjectionToken } from \"./tokens.js\";\n\n/** A container resolution failure; provider exceptions propagate unchanged. */\nexport class ResolutionError extends Error {\n  constructor(\n    readonly reason: \"missing-provider\" | \"circular-dependency\",\n    readonly token: InjectionToken<unknown>,\n    options?: ErrorOptions,\n  ) {\n    super(\n      reason === \"missing-provider\"\n        ? `No provider registered for token \"${describeToken(token)}\". Use provide(token, factory) for values/interfaces.`\n        : `Circular dependency while resolving \"${describeToken(token)}\".`,\n      options,\n    );\n    this.name = \"ResolutionError\";\n  }\n}\n\n/** Resource admission failed because this container's teardown has begun. */\nexport class ContainerClosedError extends Error {\n  constructor(\n    readonly state: \"closing\" | \"disposed\",\n    options?: ErrorOptions,\n  ) {\n    super(state === \"closing\" ? \"Container is closing.\" : \"Container has been disposed.\", options);\n    this.name = \"ContainerClosedError\";\n  }\n}\n\n/** A provider cannot replace an instance this container has already handed out. */\nexport class ProviderConflictError extends Error {\n  constructor(readonly token: InjectionToken<unknown>) {\n    super(\n      `\"${describeToken(token)}\" is already resolved in this container. Register providers before resolving, or override the token in a child container.`,\n    );\n    this.name = \"ProviderConflictError\";\n  }\n}\n\n/** An object must have exactly one disposal owner and one automatic close protocol. */\nexport class DisposalConflictError extends Error {\n  constructor(readonly reason: \"multiple-hooks\" | \"already-owned\") {\n    super(\n      reason === \"multiple-hooks\"\n        ? \"ContainerObject.onClose cannot coexist with Symbol.asyncDispose or Symbol.dispose.\"\n        : \"An explicit disposer cannot take ownership of an already-owned resource.\",\n    );\n    this.name = \"DisposalConflictError\";\n  }\n}\n","import { describeToken, type InjectionToken } from \"../tokens.js\";\nimport type { ResolutionFrame } from \"./path.js\";\n\n/** The root container's resolution attempts: `from` resolves `to`. */\nexport interface ResolutionGraph {\n  readonly nodes: ReadonlyArray<{ readonly id: number; readonly name: string }>;\n  readonly edges: ReadonlyArray<{ readonly from: number; readonly to: number }>;\n}\n\n/**\n * Root-local resolution diagnostics. Node identity is per container, and both\n * edge directions are indexed so removing a disposed container costs its own\n * nodes rather than a full scan.\n */\nexport class ResolutionTracker {\n  #nextId = 0;\n  readonly #idsByOwner = new WeakMap<object, Map<InjectionToken<unknown>, number>>();\n  readonly #nodes = new Map<number, string>();\n  readonly #outgoing = new Map<number, Set<number>>();\n  readonly #incoming = new Map<number, Set<number>>();\n\n  /** Records a resolution as a dependency of the construction that requested it. */\n  record(owner: object, token: InjectionToken<unknown>, parent?: ResolutionFrame): void {\n    let ids = this.#idsByOwner.get(owner);\n    if (!ids) {\n      this.#idsByOwner.set(owner, (ids = new Map()));\n    }\n\n    let id = ids.get(token);\n    if (id === undefined) {\n      id = this.#nextId++;\n      ids.set(token, id);\n      this.#nodes.set(id, describeToken(token));\n    }\n\n    // A node never depends on itself, and a removed owner's frame links nothing.\n    if (parent && (parent.owner !== owner || parent.token !== token)) {\n      const from = this.#idsByOwner.get(parent.owner)?.get(parent.token);\n      if (from !== undefined) {\n        this.#link(from, id);\n      }\n    }\n  }\n\n  snapshot(): ResolutionGraph {\n    const edges: Array<{ from: number; to: number }> = [];\n    for (const [from, targets] of this.#outgoing) {\n      for (const to of targets) {\n        edges.push({ from, to });\n      }\n    }\n\n    return { nodes: Array.from(this.#nodes, ([id, name]) => ({ id, name })), edges };\n  }\n\n  /** Drops a disposed owner's nodes and every edge that touched them. */\n  remove(owner: object): void {\n    const ids = this.#idsByOwner.get(owner);\n    if (!ids) {\n      return;\n    }\n\n    for (const id of ids.values()) {\n      this.#nodes.delete(id);\n      this.#unlink(id);\n    }\n\n    this.#idsByOwner.delete(owner);\n  }\n\n  #link(from: number, to: number): void {\n    let targets = this.#outgoing.get(from);\n    if (!targets) {\n      this.#outgoing.set(from, (targets = new Set()));\n    }\n    targets.add(to);\n\n    let sources = this.#incoming.get(to);\n    if (!sources) {\n      this.#incoming.set(to, (sources = new Set()));\n    }\n    sources.add(from);\n  }\n\n  #unlink(id: number): void {\n    const targets = this.#outgoing.get(id);\n    if (targets) {\n      for (const to of targets) {\n        this.#detach(this.#incoming, to, id);\n      }\n      this.#outgoing.delete(id);\n    }\n\n    const sources = this.#incoming.get(id);\n    if (sources) {\n      for (const from of sources) {\n        this.#detach(this.#outgoing, from, id);\n      }\n      this.#incoming.delete(id);\n    }\n  }\n\n  #detach(index: Map<number, Set<number>>, node: number, peer: number): void {\n    const peers = index.get(node);\n    if (peers?.delete(peer) && peers.size === 0) {\n      index.delete(node);\n    }\n  }\n}\n","import { ResolutionError } from \"../errors.js\";\nimport type { InjectionToken } from \"../tokens.js\";\n\n/** One construction in flight: `owner` is building `token` right now. */\nexport interface ResolutionFrame {\n  readonly owner: object;\n  readonly token: InjectionToken<unknown>;\n}\n\n/**\n * The chain of constructions in flight under one container tree, newest last.\n *\n * A frame is a container and a token together, so the same token may be in\n * flight in two containers while a child decorates an ancestor's\n * implementation; only a container re-entering its own token is a cycle.\n */\nexport class ResolutionPath {\n  readonly #frames: ResolutionFrame[] = [];\n\n  /** The construction that whatever resolves next belongs to. */\n  get current(): ResolutionFrame | undefined {\n    return this.#frames[this.#frames.length - 1];\n  }\n\n  /** Rejects a container that re-enters a token it is already constructing. */\n  enter(owner: object, token: InjectionToken<unknown>): void {\n    for (const frame of this.#frames) {\n      if (frame.owner === owner && frame.token === token) {\n        throw new ResolutionError(\"circular-dependency\", token);\n      }\n    }\n\n    this.#frames.push({ owner, token });\n  }\n\n  /** A failed attempt leaves no trace, so the token stays resolvable. */\n  exit(): void {\n    this.#frames.pop();\n  }\n}\n","import { ProviderConflictError } from \"../errors.js\";\nimport type { Factory, InjectionToken } from \"../tokens.js\";\n\n/** One container's providers and the instances it has constructed. */\nexport class ProviderRegistry {\n  #factories: Map<InjectionToken<unknown>, Factory<unknown>> | undefined;\n  #instances: Map<InjectionToken<unknown>, unknown> | undefined;\n\n  /** Whether this container has ever cached an instance of its own. */\n  get hasInstances(): boolean {\n    return this.#instances !== undefined;\n  }\n\n  /** An explicit provider or a cached instance, never a constructibility probe. */\n  has(token: InjectionToken<unknown>): boolean {\n    return (this.#instances?.has(token) ?? false) || (this.#factories?.has(token) ?? false);\n  }\n\n  /** Distinguishes a cached `undefined` from a missing instance. */\n  hasInstance(token: InjectionToken<unknown>): boolean {\n    return this.#instances?.has(token) ?? false;\n  }\n\n  instance<T>(token: InjectionToken<T>): T {\n    return this.#instances?.get(token) as T;\n  }\n\n  hasFactory(token: InjectionToken<unknown>): boolean {\n    return this.#factories?.has(token) ?? false;\n  }\n\n  factory<T>(token: InjectionToken<T>): Factory<T> | undefined {\n    return this.#factories?.get(token) as Factory<T> | undefined;\n  }\n\n  /**\n   * Replacing a factory whose instance this container already handed out is\n   * rejected: the cached instance would silently win. Override in a child.\n   */\n  provide<T>(token: InjectionToken<T>, factory: Factory<T>): void {\n    if (this.#instances?.has(token)) {\n      throw new ProviderConflictError(token);\n    }\n    (this.#factories ??= new Map()).set(token, factory as Factory<unknown>);\n  }\n\n  cache(token: InjectionToken<unknown>, value: unknown): void {\n    (this.#instances ??= new Map()).set(token, value);\n  }\n\n  /** Disposal makes the container unusable, so its storage is released. */\n  clear(): void {\n    this.#factories = undefined;\n    this.#instances = undefined;\n  }\n}\n","import { DisposalConflictError } from \"../errors.js\";\n\n/** Releases one resource; a returned promise is awaited during disposal. */\nexport type Cleanup = () => unknown | Promise<unknown>;\n\n/** Structural resource hook. Do not combine onClose with a symbol disposer. */\nexport interface ContainerObject {\n  onClose?(): unknown | Promise<unknown>;\n}\n\n/**\n * How a constructed value is released, plus the conflict that must reject it.\n *\n * A conflicting shape still yields `cleanup`: the caller registers it to roll\n * back an object it will never hand out, then throws `conflict`.\n */\nexport interface CleanupPlan {\n  readonly cleanup: Cleanup | undefined;\n  readonly conflict: DisposalConflictError | undefined;\n}\n\n/**\n * Precedence is explicit disposer, then `Symbol.asyncDispose`/`Symbol.dispose`,\n * then `ContainerObject.onClose`. `onClose` beside a symbol disposer is\n * ambiguous and refused, unless an explicit disposer overrides both shapes.\n */\nexport function planCleanup<T>(\n  value: T,\n  explicitDispose?: (value: T) => unknown | Promise<unknown>,\n): CleanupPlan {\n  const asyncDispose = (value as Partial<AsyncDisposable>)[Symbol.asyncDispose];\n  const dispose = (value as Partial<Disposable>)[Symbol.dispose];\n  const onClose = (value as ContainerObject).onClose;\n  const symbolDispose = typeof asyncDispose === \"function\" ? asyncDispose : dispose;\n\n  const cleanup = explicitDispose\n    ? () => explicitDispose(value)\n    : typeof symbolDispose === \"function\"\n      ? () => symbolDispose.call(value)\n      : typeof onClose === \"function\"\n        ? () => onClose.call(value)\n        : undefined;\n  const conflict =\n    !explicitDispose && typeof onClose === \"function\" && typeof symbolDispose === \"function\"\n      ? new DisposalConflictError(\"multiple-hooks\")\n      : undefined;\n\n  return { cleanup, conflict };\n}\n","import { combinedError } from \"@tiberjs/runner\";\nimport { ContainerClosedError } from \"../errors.js\";\nimport type { Cleanup } from \"./cleanup.js\";\n\n/** Runs one cleanup callback with the owner's ambient binding installed. */\nexport type CleanupInvoker = (cleanup: Cleanup) => unknown;\n\n/**\n * LIFO cleanup storage for one owner, drained once. Knows nothing about\n * containers: every callback runs through the invoker its owner supplied.\n */\nexport class DisposalQueue {\n  #cleanups: Cleanup[] | undefined;\n  #drained = false;\n\n  constructor(private readonly invoke: CleanupInvoker) {}\n\n  /** Cleanup registered while draining is drained too; after that nothing would run it. */\n  defer(cleanup: Cleanup): void {\n    if (this.#drained) {\n      throw new ContainerClosedError(\"disposed\");\n    }\n    (this.#cleanups ??= []).push(cleanup);\n  }\n\n  /** Drains in reverse registration order, retaining independent failures. */\n  async close(): Promise<void> {\n    // Yield past a synchronous factory that initiated disposal before returning its resource.\n    await Promise.resolve();\n\n    const errors: unknown[] = [];\n    while (this.#cleanups?.length) {\n      try {\n        await this.invoke(this.#cleanups.pop()!);\n      } catch (error) {\n        errors.push(error);\n      }\n    }\n\n    this.#drained = true;\n    this.#cleanups = undefined;\n\n    // Independent failures keep their identity, in drain order.\n    if (errors.length) {\n      throw combinedError(errors, \"Errors during disposal.\");\n    }\n  }\n}\n","import type { Container } from \"../container.js\";\nimport { DisposalConflictError } from \"../errors.js\";\nimport { activeContainer } from \"./active-container.js\";\nimport { type Cleanup, planCleanup } from \"./cleanup.js\";\nimport type { OwnershipRegistry } from \"./ownership.js\";\nimport { DisposalQueue } from \"./queue.js\";\n\n/**\n * The resources one container owns: it binds the ambient container around\n * construction and teardown, claims each constructed value at most once, and\n * releases what it claimed in LIFO order.\n */\nexport class ResourceOwner {\n  readonly #queue: DisposalQueue;\n\n  constructor(\n    private readonly container: Container,\n    private readonly ownership: OwnershipRegistry,\n  ) {\n    this.#queue = new DisposalQueue((cleanup) => activeContainer.run(container, cleanup));\n  }\n\n  /** Only the queue knows whether it already drained, so admission is its call. */\n  defer(cleanup: Cleanup): void {\n    this.#queue.defer(cleanup);\n  }\n\n  /** Construct with ambient resolution bound, then take disposal ownership. */\n  construct<T>(\n    factory: (container: Container) => T,\n    dispose?: (value: T) => unknown | Promise<unknown>,\n  ): T {\n    const value = activeContainer.run(this.container, factory, this.container);\n    this.#adopt(value, dispose);\n\n    return value;\n  }\n\n  /** Once drained, this owner is responsible for nothing it claimed. */\n  close(): Promise<void> {\n    return this.#queue.close().finally(() => this.ownership.release(this));\n  }\n\n  #adopt<T>(value: T, explicitDispose?: (value: T) => unknown | Promise<unknown>): void {\n    if (value === null || (typeof value !== \"object\" && typeof value !== \"function\")) {\n      if (explicitDispose) {\n        this.defer(() => explicitDispose(value));\n      }\n      return;\n    }\n\n    const target = value as object;\n    if (this.ownership.hasLiveOwner(target)) {\n      // An alias of a live resource borrows it; a second disposer would double-release.\n      if (explicitDispose) {\n        throw new DisposalConflictError(\"already-owned\");\n      }\n      return;\n    }\n\n    const plan = planCleanup(value, explicitDispose);\n    if (plan.cleanup) {\n      this.defer(plan.cleanup);\n      this.ownership.claim(target, this);\n    }\n    // Registered cleanup above survives refusal, because the value is never returned.\n    if (plan.conflict) {\n      this.ownership.reject(target, plan.conflict);\n      throw plan.conflict;\n    }\n  }\n}\n","/** A permanently refused value, boxed so it is never mistaken for an owner. */\nclass Rejection {\n  constructor(readonly error: unknown) {}\n}\n\n// Keyed by root so surviving children share ownership without initializing a\n// closed ancestor's resources.\nconst registriesByRoot = new WeakMap<object, OwnershipRegistry>();\n\n/** At most one disposal owner per object, shared across one container tree. */\nexport class OwnershipRegistry {\n  readonly #entries = new WeakMap<object, object>();\n  readonly #drained = new WeakSet<object>();\n\n  /** Every container descending from `root` claims into the same registry. */\n  static forRoot(root: object): OwnershipRegistry {\n    let registry = registriesByRoot.get(root);\n    if (!registry) {\n      registriesByRoot.set(root, (registry = new OwnershipRegistry()));\n    }\n\n    return registry;\n  }\n\n  /**\n   * Whether someone is still responsible for releasing `value`; an owner that\n   * already drained leaves it adoptable again. Rethrows a refused shape's\n   * cached rejection so every later alias of that object fails identically.\n   */\n  hasLiveOwner(value: object): boolean {\n    const entry = this.#entries.get(value);\n    if (entry instanceof Rejection) {\n      throw entry.error;\n    }\n\n    return entry !== undefined && !this.#drained.has(entry);\n  }\n\n  claim(value: object, owner: object): void {\n    this.#entries.set(value, owner);\n  }\n\n  /** `owner` finished its cleanup: every value it claimed is unowned again. */\n  release(owner: object): void {\n    this.#drained.add(owner);\n  }\n\n  /** Refusal is permanent: `value` can never gain a disposal owner afterwards. */\n  reject(value: object, error: unknown): void {\n    this.#entries.set(value, new Rejection(error));\n  }\n}\n","import { ContainerClosedError, ResolutionError } from \"./errors.js\";\nimport { ResolutionTracker, type ResolutionGraph } from \"./resolution/graph.js\";\nimport { ResolutionPath } from \"./resolution/path.js\";\nimport { ProviderRegistry } from \"./resolution/providers.js\";\nimport { ResourceOwner } from \"./resources/owner.js\";\nimport { OwnershipRegistry } from \"./resources/ownership.js\";\nimport type { Factory, InjectionToken } from \"./tokens.js\";\n\ntype ContainerPhase = \"open\" | \"closing\" | \"disposed\";\n\n/**\n * A hierarchical dependency container and resource owner. A child resolves its\n * ancestors' providers but owns and disposes only what it constructed itself.\n */\nexport class Container {\n  readonly #parent: Container | undefined;\n  readonly #root: Container;\n  readonly #providers = new ProviderRegistry();\n  readonly #path: ResolutionPath;\n  /** Diagnostics live on the root; a child records into its root's tracker. */\n  #graph: ResolutionTracker | undefined;\n  #resources: ResourceOwner | undefined;\n  #disposal: Promise<void> | undefined;\n  #phase: ContainerPhase = \"open\";\n\n  constructor(parent?: Container) {\n    this.#parent = parent;\n    this.#root = parent ? parent.#root : this;\n    this.#path = parent ? parent.#path : new ResolutionPath();\n  }\n\n  get #owner(): ResourceOwner {\n    if (!this.#resources) {\n      // A drained container must not build an owner whose queue nothing drains.\n      this.#admitRetainedAccess();\n      this.#resources = new ResourceOwner(this, OwnershipRegistry.forRoot(this.#root));\n    }\n    return this.#resources;\n  }\n\n  /** Undefined once the root is gone, so a surviving child cannot repopulate it. */\n  get #tracker(): ResolutionTracker | undefined {\n    if (this.#root.#phase === \"disposed\") {\n      return undefined;\n    }\n\n    return (this.#root.#graph ??= new ResolutionTracker());\n  }\n\n  /** A child container resolves application singletons through its parent. */\n  child(): Container {\n    this.#admitNewAcquisition();\n    return new Container(this);\n  }\n\n  /** Includes failed attempts and active children, but never disposed containers. */\n  resolutionGraph(): ResolutionGraph {\n    return this.#root.#graph?.snapshot() ?? { nodes: [], edges: [] };\n  }\n\n  /** Register a provider before the token is resolved here. */\n  provide<T>(token: InjectionToken<T>, factory: Factory<T>): void {\n    this.#admitNewAcquisition();\n    this.#providers.provide(token, factory);\n  }\n\n  has(token: InjectionToken<unknown>): boolean {\n    return this.#providers.has(token) || (this.#parent?.has(token) ?? false);\n  }\n\n  /** Resolve local cache/provider, then ancestors; default classes live at root. */\n  resolve<T>(token: InjectionToken<T>): T {\n    if (this.#providers.hasInstance(token)) {\n      this.#admitRetainedAccess();\n      this.#tracker?.record(this, token, this.#path.current);\n\n      return this.#providers.instance(token);\n    }\n\n    // Ancestors own their own admission; a closing child may still read singletons.\n    if (!this.#providers.hasFactory(token) && this.#parent) {\n      this.#admitRetainedAccess();\n      return this.#parent.resolve(token);\n    }\n\n    this.#admitNewAcquisition();\n\n    return this.#acquire(token, () => {\n      const factory = this.#providers.factory(token);\n      if (factory) {\n        return factory(this);\n      }\n      if (typeof token === \"function\") {\n        return new token();\n      }\n\n      throw new ResolutionError(\"missing-provider\", token);\n    });\n  }\n\n  /**\n   * Acquire inline resources once per container, with explicit or automatic\n   * disposal. Like a provider factory, `factory` receives this container.\n   */\n  use<T>(\n    token: InjectionToken<T>,\n    factory: Factory<T>,\n    dispose?: (value: T) => unknown | Promise<unknown>,\n  ): T {\n    if (this.#providers.hasInstance(token)) {\n      this.#admitRetainedAccess();\n      this.#tracker?.record(this, token, this.#path.current);\n\n      return this.#providers.instance(token);\n    }\n\n    this.#admitNewAcquisition();\n\n    return this.#acquire(token, factory, dispose);\n  }\n\n  /**\n   * Register LIFO cleanup. Blind to the phase on purpose: a resource released\n   * mid-drain may still register its own cleanup, and only the queue knows\n   * whether anything is left to run it.\n   */\n  defer(cleanup: () => unknown | Promise<unknown>): void {\n    this.#owner.defer(cleanup);\n  }\n\n  /**\n   * Close a container that never constructed or deferred anything, avoiding an\n   * `await`. Returns `false` and changes nothing otherwise.\n   */\n  disposeSync(): boolean {\n    if (this.#resources || this.#providers.hasInstances) {\n      return false;\n    }\n    if (this.#phase !== \"disposed\") {\n      this.#clearResolution();\n    }\n    return true;\n  }\n\n  /** Close acquisition synchronously, then clear resolution storage after teardown. */\n  [Symbol.asyncDispose](): Promise<void> {\n    if (this.#phase === \"open\") {\n      this.#phase = \"closing\";\n      this.#disposal = this.#owner.close().finally(() => {\n        this.#clearResolution();\n      });\n    }\n\n    return (this.#disposal ??= Promise.resolve());\n  }\n\n  /** Reading what this container already holds stays legal until it is disposed. */\n  #admitRetainedAccess(): void {\n    if (this.#phase === \"disposed\") {\n      throw new ContainerClosedError(\"disposed\");\n    }\n  }\n\n  /** Providers, children, and construction stop the moment teardown begins. */\n  #admitNewAcquisition(): void {\n    const phase = this.#phase;\n    if (phase !== \"open\") {\n      throw new ContainerClosedError(phase);\n    }\n  }\n\n  #clearResolution(): void {\n    this.#phase = \"disposed\";\n    this.#providers.clear();\n\n    if (this === this.#root) {\n      this.#graph = undefined;\n    } else {\n      this.#root.#graph?.remove(this);\n    }\n  }\n\n  #acquire<T>(\n    token: InjectionToken<T>,\n    factory: Factory<T>,\n    dispose?: (value: T) => unknown | Promise<unknown>,\n  ): T {\n    // A cycle is still an attempt worth reporting, so record before guarding.\n    this.#tracker?.record(this, token, this.#path.current);\n    this.#path.enter(this, token);\n\n    try {\n      const value = this.#owner.construct(factory, dispose);\n      this.#providers.cache(token, value);\n\n      return value;\n    } finally {\n      this.#path.exit();\n    }\n  }\n}\n","/** Hierarchical dependency resolution and resource ownership. */\n\nexport {\n  ContainerKey,\n  currentContainer,\n  inject,\n  onDispose,\n  scoped,\n  withContainer,\n} from \"./ambient.js\";\nexport type { ContainerObject } from \"./resources/cleanup.js\";\nexport { Container } from \"./container.js\";\nexport {\n  ContainerClosedError,\n  DisposalConflictError,\n  ProviderConflictError,\n  ResolutionError,\n} from \"./errors.js\";\nexport type { ResolutionGraph } from \"./resolution/graph.js\";\nexport { token } from \"./tokens.js\";\nexport type { Constructor, Factory, InjectionToken, Token } from \"./tokens.js\";\n"],"names":["AsyncLocalStorage","activeContainer","contextKey","peekState","provide","withContext","ContainerKey","currentContainer","constructing","bound","Error","inject","token","scoped","factory","dispose","onDispose","cleanup","withContainer","container","handler","description","Symbol","describeToken","ResolutionError","reason","options","ContainerClosedError","state","ProviderConflictError","DisposalConflictError","ResolutionTracker","WeakMap","Map","owner","parent","ids","id","undefined","from","edges","targets","to","Array","name","Set","sources","index","node","peer","peers","ResolutionPath","frame","ProviderRegistry","value","planCleanup","explicitDispose","asyncDispose","onClose","symbolDispose","conflict","combinedError","DisposalQueue","invoke","Promise","errors","error","ResourceOwner","ownership","target","plan","Rejection","registriesByRoot","OwnershipRegistry","WeakSet","root","registry","entry","Container","phase"],"mappings":"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"}

package/dist/resolution/graph.d.ts

@@ -0,0 +1,27 @@
+import { type InjectionToken } from "../tokens.js";
+import type { ResolutionFrame } from "./path.js";
+/** The root container's resolution attempts: `from` resolves `to`. */
+export interface ResolutionGraph {
+    readonly nodes: ReadonlyArray<{
+        readonly id: number;
+        readonly name: string;
+    }>;
+    readonly edges: ReadonlyArray<{
+        readonly from: number;
+        readonly to: number;
+    }>;
+}
+/**
+ * Root-local resolution diagnostics. Node identity is per container, and both
+ * edge directions are indexed so removing a disposed container costs its own
+ * nodes rather than a full scan.
+ */
+export declare class ResolutionTracker {
+    #private;
+    /** Records a resolution as a dependency of the construction that requested it. */
+    record(owner: object, token: InjectionToken<unknown>, parent?: ResolutionFrame): void;
+    snapshot(): ResolutionGraph;
+    /** Drops a disposed owner's nodes and every edge that touched them. */
+    remove(owner: object): void;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/resolution/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/resolution/graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9E,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/E;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;;IAO5B,kFAAkF;IAClF,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI;IAsBrF,QAAQ,IAAI,eAAe;IAW3B,uEAAuE;IACvE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAoD5B"}

package/dist/resolution/path.d.ts

@@ -0,0 +1,23 @@
+import type { InjectionToken } from "../tokens.js";
+/** One construction in flight: `owner` is building `token` right now. */
+export interface ResolutionFrame {
+    readonly owner: object;
+    readonly token: InjectionToken<unknown>;
+}
+/**
+ * The chain of constructions in flight under one container tree, newest last.
+ *
+ * A frame is a container and a token together, so the same token may be in
+ * flight in two containers while a child decorates an ancestor's
+ * implementation; only a container re-entering its own token is a cycle.
+ */
+export declare class ResolutionPath {
+    #private;
+    /** The construction that whatever resolves next belongs to. */
+    get current(): ResolutionFrame | undefined;
+    /** Rejects a container that re-enters a token it is already constructing. */
+    enter(owner: object, token: InjectionToken<unknown>): void;
+    /** A failed attempt leaves no trace, so the token stays resolvable. */
+    exit(): void;
+}
+//# sourceMappingURL=path.d.ts.map

package/dist/resolution/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/resolution/path.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACzC;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;;IAGzB,+DAA+D;IAC/D,IAAI,OAAO,IAAI,eAAe,GAAG,SAAS,CAEzC;IAED,6EAA6E;IAC7E,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI;IAU1D,uEAAuE;IACvE,IAAI,IAAI,IAAI;CAGb"}

package/dist/resolution/providers.d.ts

@@ -0,0 +1,23 @@
+import type { Factory, InjectionToken } from "../tokens.js";
+/** One container's providers and the instances it has constructed. */
+export declare class ProviderRegistry {
+    #private;
+    /** Whether this container has ever cached an instance of its own. */
+    get hasInstances(): boolean;
+    /** An explicit provider or a cached instance, never a constructibility probe. */
+    has(token: InjectionToken<unknown>): boolean;
+    /** Distinguishes a cached `undefined` from a missing instance. */
+    hasInstance(token: InjectionToken<unknown>): boolean;
+    instance<T>(token: InjectionToken<T>): T;
+    hasFactory(token: InjectionToken<unknown>): boolean;
+    factory<T>(token: InjectionToken<T>): Factory<T> | undefined;
+    /**
+     * Replacing a factory whose instance this container already handed out is
+     * rejected: the cached instance would silently win. Override in a child.
+     */
+    provide<T>(token: InjectionToken<T>, factory: Factory<T>): void;
+    cache(token: InjectionToken<unknown>, value: unknown): void;
+    /** Disposal makes the container unusable, so its storage is released. */
+    clear(): void;
+}
+//# sourceMappingURL=providers.d.ts.map

package/dist/resolution/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/resolution/providers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE5D,sEAAsE;AACtE,qBAAa,gBAAgB;;IAI3B,qEAAqE;IACrE,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,iFAAiF;IACjF,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO;IAI5C,kEAAkE;IAClE,WAAW,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO;IAIpD,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IAIxC,UAAU,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO;IAInD,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS;IAI5D;;;OAGG;IACH,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAO/D,KAAK,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAI3D,yEAAyE;IACzE,KAAK,IAAI,IAAI;CAId"}

package/dist/resources/active-container.d.ts

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { Container } from "../container.js";
+/**
+ * The container bound as ambient while one of its resources is constructed or
+ * torn down. Nested construction overrides it for the inner call only.
+ */
+export declare const activeContainer: AsyncLocalStorage<Container>;
+//# sourceMappingURL=active-container.d.ts.map

package/dist/resources/active-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-container.d.ts","sourceRoot":"","sources":["../../src/resources/active-container.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,eAAe,8BAAqC,CAAC"}

package/dist/resources/cleanup.d.ts

@@ -0,0 +1,24 @@
+import { DisposalConflictError } from "../errors.js";
+/** Releases one resource; a returned promise is awaited during disposal. */
+export type Cleanup = () => unknown | Promise<unknown>;
+/** Structural resource hook. Do not combine onClose with a symbol disposer. */
+export interface ContainerObject {
+    onClose?(): unknown | Promise<unknown>;
+}
+/**
+ * How a constructed value is released, plus the conflict that must reject it.
+ *
+ * A conflicting shape still yields `cleanup`: the caller registers it to roll
+ * back an object it will never hand out, then throws `conflict`.
+ */
+export interface CleanupPlan {
+    readonly cleanup: Cleanup | undefined;
+    readonly conflict: DisposalConflictError | undefined;
+}
+/**
+ * Precedence is explicit disposer, then `Symbol.asyncDispose`/`Symbol.dispose`,
+ * then `ContainerObject.onClose`. `onClose` beside a symbol disposer is
+ * ambiguous and refused, unless an explicit disposer overrides both shapes.
+ */
+export declare function planCleanup<T>(value: T, explicitDispose?: (value: T) => unknown | Promise<unknown>): CleanupPlan;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/resources/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/resources/cleanup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAErD,4EAA4E;AAC5E,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEvD,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,IAAI,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,GAAG,SAAS,CAAC;CACtD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EACR,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACzD,WAAW,CAmBb"}

package/dist/resources/owner.d.ts

@@ -0,0 +1,21 @@
+import type { Container } from "../container.js";
+import { type Cleanup } from "./cleanup.js";
+import type { OwnershipRegistry } from "./ownership.js";
+/**
+ * The resources one container owns: it binds the ambient container around
+ * construction and teardown, claims each constructed value at most once, and
+ * releases what it claimed in LIFO order.
+ */
+export declare class ResourceOwner {
+    #private;
+    private readonly container;
+    private readonly ownership;
+    constructor(container: Container, ownership: OwnershipRegistry);
+    /** Only the queue knows whether it already drained, so admission is its call. */
+    defer(cleanup: Cleanup): void;
+    /** Construct with ambient resolution bound, then take disposal ownership. */
+    construct<T>(factory: (container: Container) => T, dispose?: (value: T) => unknown | Promise<unknown>): T;
+    /** Once drained, this owner is responsible for nothing it claimed. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=owner.d.ts.map

package/dist/resources/owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../src/resources/owner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,KAAK,OAAO,EAAe,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD;;;;GAIG;AACH,qBAAa,aAAa;;IAItB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;gBADT,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,iBAAiB;IAK/C,iFAAiF;IACjF,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI7B,6EAA6E;IAC7E,SAAS,CAAC,CAAC,EACT,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,CAAC,EACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjD,CAAC;IAOJ,sEAAsE;IACtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAgCvB"}

package/dist/resources/ownership.d.ts

@@ -0,0 +1,18 @@
+/** At most one disposal owner per object, shared across one container tree. */
+export declare class OwnershipRegistry {
+    #private;
+    /** Every container descending from `root` claims into the same registry. */
+    static forRoot(root: object): OwnershipRegistry;
+    /**
+     * Whether someone is still responsible for releasing `value`; an owner that
+     * already drained leaves it adoptable again. Rethrows a refused shape's
+     * cached rejection so every later alias of that object fails identically.
+     */
+    hasLiveOwner(value: object): boolean;
+    claim(value: object, owner: object): void;
+    /** `owner` finished its cleanup: every value it claimed is unowned again. */
+    release(owner: object): void;
+    /** Refusal is permanent: `value` can never gain a disposal owner afterwards. */
+    reject(value: object, error: unknown): void;
+}
+//# sourceMappingURL=ownership.d.ts.map

package/dist/resources/ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","sourceRoot":"","sources":["../../src/resources/ownership.ts"],"names":[],"mappings":"AASA,+EAA+E;AAC/E,qBAAa,iBAAiB;;IAI5B,4EAA4E;IAC5E,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB;IAS/C;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IASpC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzC,6EAA6E;IAC7E,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5B,gFAAgF;IAChF,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;CAG5C"}

package/dist/resources/queue.d.ts

@@ -0,0 +1,17 @@
+import type { Cleanup } from "./cleanup.js";
+/** Runs one cleanup callback with the owner's ambient binding installed. */
+export type CleanupInvoker = (cleanup: Cleanup) => unknown;
+/**
+ * LIFO cleanup storage for one owner, drained once. Knows nothing about
+ * containers: every callback runs through the invoker its owner supplied.
+ */
+export declare class DisposalQueue {
+    #private;
+    private readonly invoke;
+    constructor(invoke: CleanupInvoker);
+    /** Cleanup registered while draining is drained too; after that nothing would run it. */
+    defer(cleanup: Cleanup): void;
+    /** Drains in reverse registration order, retaining independent failures. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/resources/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../src/resources/queue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;AAE3D;;;GAGG;AACH,qBAAa,aAAa;;IAIZ,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,cAAc;IAEnD,yFAAyF;IACzF,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAO7B,4EAA4E;IACtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB7B"}

package/dist/tokens.d.ts

@@ -0,0 +1,14 @@
+import type { Container } from "./container.js";
+/** A zero-argument constructor usable as its own injection token. */
+export type Constructor<T = object> = new (...args: never[]) => T;
+/** An opaque token for values/interfaces that have no runtime class. */
+export interface Token<T> {
+    readonly key: symbol;
+    /** Phantom carrier; never present at runtime. */
+    readonly _type?: T;
+}
+export type InjectionToken<T> = Constructor<T> | Token<T>;
+export type Factory<T> = (container: Container) => T;
+export declare function token<T>(description: string): Token<T>;
+export declare function describeToken(token: InjectionToken<unknown>): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,qEAAqE;AACrE,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAElE,wEAAwE;AACxE,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACpB;AAED,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC1D,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,KAAK,CAAC,CAAC;AAErD,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAEtD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,MAAM,CAMpE"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@tiberjs/di",
+  "version": "0.1.0",
+  "description": "Hierarchical dependency container and resource ownership for tiberjs.",
+  "author": "miinhho",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@tiberjs/runner": "^0.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tiberjs/manager.git",
+    "directory": "packages/di"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "rspack build --config ../../rspack.config.mjs && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm -w exec vitest run --project @tiberjs/di"
+  }
+}