@fnioc/di 1.0.0 → 2.0.0

package/dist/builder.js

@@ -1,85 +0,0 @@
-// The registration builder. Holds the base token → registration map and hands
-// out a root Scope. `.add()` is the surface the transformer lowers to; the
-// override paths (`.register`) are the recommended plugin-less mechanism.
-import { Scope } from "./scope.js";
-/**
- * The registration builder.
- *
- * `Scopes` is the user-supplied scope-name union (e.g.
- * `"singleton" | "request"`). `"transient"` is NOT a member — transient is the
- * absence of a tag, not a scope.
- *
- * @example
- * ```ts
- * const services = new DiBuilder<"singleton" | "request">();
- * services.add("pkg:ILogger", ConsoleLogger).as("singleton"); // lowered form
- * const root = services.createScope("singleton");
- * const logger = root.resolve<ILogger>("pkg:ILogger");
- * ```
- */
-export class DiBuilder {
-    registrations = new Map();
-    add(tokenOrCtor, maybeCtor) {
-        // Only the string-token form reaches the engine at runtime. The type-only
-        // overload is never actually invoked post-transform; guard defensively so a
-        // hand-written type-form call fails loud rather than registering garbage.
-        if (typeof tokenOrCtor !== "string" || maybeCtor === undefined) {
-            throw new TypeError('add<I>(ctor) requires the @fnioc/transformer plugin. Without it, ' +
-                'register with an explicit token: add("my:token", MyClass).');
-        }
-        const registration = {
-            kind: "class",
-            ctor: maybeCtor,
-            tag: undefined,
-        };
-        this.registrations.set(tokenOrCtor, registration);
-        // `.as()` rebinds the registration with its tag. The map holds an immutable
-        // record, so swap in a fresh one rather than mutating the readonly field.
-        const token = tokenOrCtor;
-        const registrations = this.registrations;
-        return {
-            as(scope) {
-                // The lowered form always passes a value arg; the authored type-arg-only
-                // form never executes (the transformer rewrites it first). A no-arg call
-                // at runtime would leave the registration transient — guard so it is a
-                // no-op rather than overwriting the tag with `undefined`.
-                if (scope === undefined)
-                    return;
-                registrations.set(token, { ...registration, tag: scope });
-            },
-        };
-    }
-    /**
-     * The plugin-less override path. Registers a token against either a
-     * `useFactory` closure (which resolves its own deps from the scope passed to
-     * it) or a `useValue` instance. The recommended mechanism for test doubles,
-     * third-party instances, and plugin-less wiring.
-     *
-     * A `useFactory` may carry an optional `tag` so the factory's result is
-     * cached at a matching ancestor scope (singleton-style); without a tag it
-     * runs on every resolve. A `useValue` is the instance itself — always the
-     * same value, no lifetime.
-     */
-    register(token, spec) {
-        if ("useValue" in spec) {
-            this.registrations.set(token, { kind: "value", useValue: spec.useValue });
-        }
-        else {
-            this.registrations.set(token, {
-                kind: "factory",
-                useFactory: spec.useFactory,
-                tag: spec.tag,
-            });
-        }
-        return this;
-    }
-    /**
-     * Mints the root scope. The root must be a real, app-lifetime object — its
-     * name is the lifetime tag that singletons (or whatever the app's longest
-     * lifetime is) bind to.
-     */
-    createScope(rootScopeName) {
-        return new Scope(rootScopeName, undefined, this.registrations);
-    }
-}
-//# sourceMappingURL=builder.js.map

package/dist/builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.js","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAC3E,0EAA0E;AAI1E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAsCnC;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,SAAS;IACH,aAAa,GAAG,IAAI,GAAG,EAAuB,CAAC;IAezD,GAAG,CACR,WAAsD,EACtD,SAAgB;QAEhB,0EAA0E;QAC1E,4EAA4E;QAC5E,0EAA0E;QAC1E,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC/D,MAAM,IAAI,SAAS,CACjB,mEAAmE;gBACjE,4DAA4D,CAC/D,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAsB;YACtC,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,SAAS;YACf,GAAG,EAAE,SAAS;SACf,CAAC;QACF,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAElD,4EAA4E;QAC5E,0EAA0E;QAC1E,MAAM,KAAK,GAAG,WAAW,CAAC;QAC1B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,OAAO;YACL,EAAE,CAAmB,KAAS;gBAC5B,yEAAyE;gBACzE,yEAAyE;gBACzE,uEAAuE;gBACvE,0DAA0D;gBAC1D,IAAI,KAAK,KAAK,SAAS;oBAAE,OAAO;gBAChC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,GAAG,YAAY,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;YAC5D,CAAC;SACF,CAAC;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACI,QAAQ,CAAI,KAAY,EAAE,IAAqB;QACpD,IAAI,UAAU,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5E,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE;gBAC5B,IAAI,EAAE,SAAS;gBACf,UAAU,EAAE,IAAI,CAAC,UAA8C;gBAC/D,GAAG,EAAE,IAAI,CAAC,GAAG;aACd,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,aAAqB;QACtC,OAAO,IAAI,KAAK,CAAS,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IACzE,CAAC;CACF"}

package/dist/errors.d.ts

@@ -1,73 +0,0 @@
-import type { Token } from "@fnioc/core";
-/** Base class for every error the container raises. */
-export declare class DiError extends Error {
-    constructor(message: string);
-}
-/**
- * A token was requested but no registration exists for it anywhere in the
- * resolving scope's chain (nor on the builder's base map).
- */
-export declare class UnregisteredTokenError extends DiError {
-    readonly token: Token;
-    constructor(token: Token);
-}
-/**
- * A registration carries a lifetime tag, but no ancestor scope in the resolving
- * chain has a matching name. This is the captive-dependency / misconfiguration
- * detector — the engine never auto-creates a scope to satisfy the tag.
- */
-export declare class MissingScopeError extends DiError {
-    readonly token: Token;
-    readonly tag: string;
-    readonly availableScopes: readonly string[];
-    constructor(token: Token, tag: string, availableScopes: readonly string[]);
-}
-/**
- * A constructor with parameters has no DepRecord in the WeakMap — the
- * transformer never saw it and it was never hand-annotated.
- */
-export declare class MissingMetadataError extends DiError {
-    readonly token: Token;
-    readonly ctorName: string;
-    constructor(token: Token, ctorName: string);
-}
-/**
- * A constructor has DepRecord signatures, but none of them is directly
- * satisfiable in the owning scope (every signature names at least one token
- * that is not registered, or contains a hole this phase cannot fill).
- */
-export declare class NoSatisfiableSignatureError extends DiError {
-    readonly token: Token;
-    readonly ctorName: string;
-    readonly unsatisfiable: readonly Token[];
-    constructor(token: Token, ctorName: string, unsatisfiable: readonly Token[]);
-}
-/**
- * A token reappeared on the active resolution stack — the dependency graph has
- * a cycle. The message includes the full path that closed the loop.
- */
-export declare class CircularDependencyError extends DiError {
-    readonly path: readonly Token[];
-    constructor(path: readonly Token[]);
-}
-/**
- * A constructor parameter is typed as a factory of some token (a `FactoryRef`),
- * but that token cannot be turned into a factory: either it is not registered,
- * or it is registered as a `useValue` / `useFactory` override rather than a
- * class. A factory injects a callable that constructs the target class on
- * demand, so the target must be a class registration.
- */
-export declare class FactoryTargetError extends DiError {
-    readonly factoryToken: Token;
-    readonly reason: "unregistered" | "not-a-class";
-    constructor(factoryToken: Token, reason: "unregistered" | "not-a-class");
-}
-/**
- * Sync `dispose()` was called on a scope that owns a Promise-valued (thenable)
- * cached instance. A pending Promise cannot be disposed synchronously — the
- * caller must use `disposeAsync()`.
- */
-export declare class AsyncDisposalRequiredError extends DiError {
-    constructor();
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,uDAAuD;AACvD,qBAAa,OAAQ,SAAQ,KAAK;gBACb,OAAO,EAAE,MAAM;CAInC;AAED;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,OAAO;aACd,KAAK,EAAE,KAAK;gBAAZ,KAAK,EAAE,KAAK;CAMhD;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,OAAO;aAE1B,KAAK,EAAE,KAAK;aACZ,GAAG,EAAE,MAAM;aACX,eAAe,EAAE,SAAS,MAAM,EAAE;gBAFlC,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,EACX,eAAe,EAAE,SAAS,MAAM,EAAE;CAerD;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;aAE7B,KAAK,EAAE,KAAK;aACZ,QAAQ,EAAE,MAAM;gBADhB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM;CAUnC;AAED;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,OAAO;aAEpC,KAAK,EAAE,KAAK;aACZ,QAAQ,EAAE,MAAM;aAChB,aAAa,EAAE,SAAS,KAAK,EAAE;gBAF/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,KAAK,EAAE;CAelD;AAED;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,OAAO;aACf,IAAI,EAAE,SAAS,KAAK,EAAE;gBAAtB,IAAI,EAAE,SAAS,KAAK,EAAE;CAG1D;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,OAAO;aAE3B,YAAY,EAAE,KAAK;aACnB,MAAM,EAAE,cAAc,GAAG,aAAa;gBADtC,YAAY,EAAE,KAAK,EACnB,MAAM,EAAE,cAAc,GAAG,aAAa;CAezD;AAED;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,OAAO;;CAQtD"}

package/dist/errors.js

@@ -1,139 +0,0 @@
-// Typed error classes for the runtime engine.
-//
-// Each failure mode the resolver can hit gets its own class so consumers can
-// branch on `instanceof` rather than string-matching messages. Messages are
-// written for a human reading a stack trace at the moment a graph fails to
-// resolve.
-/** Base class for every error the container raises. */
-export class DiError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = new.target.name;
-    }
-}
-/**
- * A token was requested but no registration exists for it anywhere in the
- * resolving scope's chain (nor on the builder's base map).
- */
-export class UnregisteredTokenError extends DiError {
-    token;
-    constructor(token) {
-        super(`No registration found for token "${token}". Register it with ` +
-            `services.add(...)/.register(...) before resolving.`);
-        this.token = token;
-    }
-}
-/**
- * A registration carries a lifetime tag, but no ancestor scope in the resolving
- * chain has a matching name. This is the captive-dependency / misconfiguration
- * detector — the engine never auto-creates a scope to satisfy the tag.
- */
-export class MissingScopeError extends DiError {
-    token;
-    tag;
-    availableScopes;
-    constructor(token, tag, availableScopes) {
-        super(`Cannot resolve "${token}": its lifetime is tagged "${tag}", but no ` +
-            `ancestor scope with that name exists in the resolving chain ` +
-            `(available: ${availableScopes.length > 0
-                ? availableScopes.map((s) => `"${s}"`).join(" → ")
-                : "none"}). ` +
-            `This usually means a longer-lived service depends on a ` +
-            `shorter-lived one (e.g. a "singleton" needing a "request"). Never ` +
-            `auto-created — fix the registration's lifetime or create the scope.`);
-        this.token = token;
-        this.tag = tag;
-        this.availableScopes = availableScopes;
-    }
-}
-/**
- * A constructor with parameters has no DepRecord in the WeakMap — the
- * transformer never saw it and it was never hand-annotated.
- */
-export class MissingMetadataError extends DiError {
-    token;
-    ctorName;
-    constructor(token, ctorName) {
-        super(`No dep metadata found for ${ctorName} (resolving "${token}"). The ` +
-            `constructor has parameters but no @signature, forCtor, or ` +
-            `transformer-generated defineDeps call was found. Use ` +
-            `forCtor(...).signature(...) or register it with useFactory to wire ` +
-            `it manually.`);
-        this.token = token;
-        this.ctorName = ctorName;
-    }
-}
-/**
- * A constructor has DepRecord signatures, but none of them is directly
- * satisfiable in the owning scope (every signature names at least one token
- * that is not registered, or contains a hole this phase cannot fill).
- */
-export class NoSatisfiableSignatureError extends DiError {
-    token;
-    ctorName;
-    unsatisfiable;
-    constructor(token, ctorName, unsatisfiable) {
-        super(`No satisfiable constructor signature for ${ctorName} (resolving ` +
-            `"${token}"). Every candidate signature names a dependency that is ` +
-            `not registered in the owning scope` +
-            (unsatisfiable.length > 0
-                ? `; unsatisfiable tokens: ${unsatisfiable
-                    .map((t) => `"${t}"`)
-                    .join(", ")}`
-                : "") +
-            `. Register the missing dependencies, or provide a useFactory ` +
-            `override.`);
-        this.token = token;
-        this.ctorName = ctorName;
-        this.unsatisfiable = unsatisfiable;
-    }
-}
-/**
- * A token reappeared on the active resolution stack — the dependency graph has
- * a cycle. The message includes the full path that closed the loop.
- */
-export class CircularDependencyError extends DiError {
-    path;
-    constructor(path) {
-        super(`Circular dependency detected:\n  ${path.join(" → ")}`);
-        this.path = path;
-    }
-}
-/**
- * A constructor parameter is typed as a factory of some token (a `FactoryRef`),
- * but that token cannot be turned into a factory: either it is not registered,
- * or it is registered as a `useValue` / `useFactory` override rather than a
- * class. A factory injects a callable that constructs the target class on
- * demand, so the target must be a class registration.
- */
-export class FactoryTargetError extends DiError {
-    factoryToken;
-    reason;
-    constructor(factoryToken, reason) {
-        super(reason === "unregistered"
-            ? `Cannot inject a factory for "${factoryToken}": no registration ` +
-                `found for it. A factory parameter (typed \`() => IFoo\`) needs ` +
-                `the target registered as a class with ` +
-                `services.add(...) before it can build instances.`
-            : `Cannot inject a factory for "${factoryToken}": it is registered ` +
-                `as a useValue/useFactory override, not a class. A factory builds ` +
-                `its target with \`new\`, so the target must be a class ` +
-                `registration. Resolve it directly instead of as a factory, or ` +
-                `register the class with services.add(...).`);
-        this.factoryToken = factoryToken;
-        this.reason = reason;
-    }
-}
-/**
- * Sync `dispose()` was called on a scope that owns a Promise-valued (thenable)
- * cached instance. A pending Promise cannot be disposed synchronously — the
- * caller must use `disposeAsync()`.
- */
-export class AsyncDisposalRequiredError extends DiError {
-    constructor() {
-        super(`Cannot dispose synchronously: this scope owns a Promise-valued ` +
-            `instance (an async useFactory result). Awaiting it is required ` +
-            `before disposal — call disposeAsync() instead of dispose().`);
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,YAAY,EACV,IAAI,EACJ,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,GACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,OAAO,EACP,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,8CAA8C;AAC9C,EAAE;AACF,+EAA+E;AAC/E,sEAAsE;AACtE,qEAAqE;AACrE,EAAE;AACF,gFAAgF;AAChF,0EAA0E;AAC1E,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAanC,OAAO,EACL,OAAO,EACP,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AAErB,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,kDAAkD;AAClD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC"}

package/dist/scope.d.ts

@@ -1,180 +0,0 @@
-import type { Token } from "@fnioc/core";
-import type { Registration, ResolveScope } from "./types.js";
-/**
- * A node in the scope chain. Created from a `DiBuilder` (the root) or from a
- * parent scope (`.createScope`). Holds the instances it owns and any local
- * override registrations.
- *
- * The generic `Scopes` is the user's scope-name union, threaded so
- * `.createScope` only accepts declared names.
- */
-export declare class Scope<Scopes extends string = string> implements ResolveScope {
-    /** This scope's tag name. The root scope's name is its lifetime. */
-    readonly name: Scopes;
-    /** The parent scope, or `undefined` for the root. */
-    private readonly parent;
-    /** The builder's base registration map (shared, walked last). */
-    private readonly baseRegistrations;
-    /** Local override registrations held at this scope (shadow ancestors). */
-    private readonly localRegistrations;
-    /** Instances this scope owns and caches, keyed by token. */
-    private readonly instances;
-    /** Owned instances in construction order — disposed in reverse. */
-    private readonly ownedOrder;
-    private disposed;
-    constructor(
-    /** This scope's tag name. The root scope's name is its lifetime. */
-    name: Scopes, 
-    /** The parent scope, or `undefined` for the root. */
-    parent: Scope<Scopes> | undefined, 
-    /** The builder's base registration map (shared, walked last). */
-    baseRegistrations: ReadonlyMap<Token, Registration>);
-    /** Creates a parent-linked child scope with the given (declared) name. */
-    createScope(childName: Scopes): Scope<Scopes>;
-    /**
-     * Registers a scope-local override. Shadows any ancestor or base registration
-     * for the same token, for this scope and its descendants only. The override
-     * paths (`useFactory` / `useValue`) are also available here so a single scope
-     * (e.g. a test scope) can swap an implementation without rebuilding the
-     * builder.
-     */
-    registerFactory<T>(token: Token, useFactory: (scope: ResolveScope) => T, tag?: Scopes): this;
-    /** Registers a scope-local `useValue` override (see `registerFactory`). */
-    registerValue<T>(token: Token, useValue: T): this;
-    /**
-     * Resolves a token to an instance, walking the parent chain for both the
-     * registration and the owning scope. The public entry point starts a fresh
-     * cycle-detection stack.
-     */
-    resolve<T>(token: Token): T;
-    /**
-     * Walks UP the chain (this scope's locals → ancestors' locals → base map),
-     * returning the nearest registration for `token`. Child shadows parent.
-     */
-    private lookup;
-    /**
-     * Finds the nearest ancestor scope (inclusive of this one) whose name matches
-     * `tag`, walking UP the chain. Returns `undefined` when none matches.
-     */
-    private findOwner;
-    /** The chain of scope names from this scope up to the root, for diagnostics. */
-    private chainNames;
-    /**
-     * The internal resolver. `stack` is the active resolution path (for cycle
-     * detection); it is shared across the whole `resolve()` call but never across
-     * separate calls.
-     */
-    private resolveWith;
-    /**
-     * Builds an instance for `registration`. `owningScope` is the scope whose
-     * chain the dependencies are resolved against — THE critical rule. For a
-     * factory override that is the scope passed to the closure; for a class it is
-     * the scope its ctor deps resolve relative to.
-     */
-    private instantiate;
-    /**
-     * Constructs a class instance on a DIRECT resolve, resolving its constructor
-     * dependencies relative to THIS scope (the owning scope). Performs greedy
-     * signature selection over the ctor's DepRecord, then fills each slot:
-     *
-     *   - a string token → resolved through this scope's chain (selection
-     *     guarantees every string-token slot here is resolvable);
-     *   - a `FactoryRef` → injected as a callable (see `makeFactory`);
-     *   - a `null` hole → there is no caller on a direct resolve, so it lands as
-     *     `undefined`. Holes are meaningfully filled only when the class is a
-     *     factory target — see `constructPartitioned`.
-     */
-    private construct;
-    /**
-     * Builds the callable injected for a `FactoryRef` parameter.
-     *
-     * The target ctor's signature is partitioned at CALL time against the live
-     * registration map: each slot that is a registered token is resolved; each
-     * slot that is an unregistered token or a `null` hole takes the next
-     * caller-supplied argument, positionally. The injected callable therefore
-     * exposes only the target's unregistered parameters, in their relative order
-     * — no Ramda-style placeholders, no leaked constructor arity.
-     *
-     * Lifetime semantics:
-     *   - A ZERO-ARG factory (the target ctor has no holes / unregistered params)
-     *     routes the build through the normal `resolve` path, so it RESPECTS the
-     *     target's registered lifetime: a singleton target yields the same
-     *     instance on every call; a transient target yields a fresh one.
-     *   - A PARAMETERIZED factory (the target has holes / unregistered params
-     *     filled per call) constructs a FRESH instance on every call and BYPASSES
-     *     the instance cache. Caller args differ per call, so caching would be
-     *     wrong — two calls with different arguments must not collapse to one
-     *     cached instance.
-     *
-     * The closure captures `this` as the owning scope. §5.4 holds at call time:
-     * the target's deps resolve relative to the scope that owns the
-     * factory-holding instance, exactly as a direct resolve would — so a factory
-     * captured by a singleton that tries to build a request-scoped target still
-     * throws `MissingScopeError` when invoked.
-     */
-    private makeFactory;
-    /**
-     * Constructs a factory target, partitioning its already-selected signature
-     * against the live registration map: a registered token is resolved; an
-     * unregistered token or a `null` hole takes the next caller-supplied argument
-     * positionally. Always a fresh instance — a parameterized factory bypasses
-     * the instance cache (caller args differ per call). Runs on a fresh cycle
-     * stack since the factory is invoked outside the original resolve.
-     */
-    private constructPartitioned;
-    /**
-     * Greedy signature selection. Scans signatures longest → shortest and returns
-     * the first SATISFIABLE one. A slot is satisfiable when it is:
-     *
-     *   - a `null` hole — always satisfiable; filled by a caller arg (a direct
-     *     resolve supplies nothing, so it lands as `undefined`);
-     *   - a `FactoryRef` — always satisfiable; injected as a callable. The
-     *     factory's target need not be resolvable for the slot to count (an
-     *     unregistered target surfaces a `FactoryTargetError` when the factory is
-     *     built / called, not here); or
-     *   - a string token whose registration is resolvable in this (the owning)
-     *     scope's chain.
-     *
-     * Only string tokens can be UNsatisfiable. A signature is satisfiable iff
-     * every string-token slot is resolvable.
-     *
-     * - Equal-arity ties break by registration order (the order signatures appear
-     *   in the DepRecord), which `sort`'s stability preserves.
-     * - None satisfiable ⇒ throw naming the unsatisfiable tokens.
-     */
-    private selectSignature;
-    /**
-     * Greedy signature selection for a FACTORY TARGET. Unlike `selectSignature`,
-     * there is no resolvability gate: a target's unregistered tokens are not
-     * unsatisfiable — they are the factory's caller-supplied parameters. So the
-     * choice is purely the longest signature, equal-arity ties broken by
-     * registration order (`sort` stability). Always returns a signature (the
-     * caller has already checked `signatures.length > 0`).
-     */
-    private selectTargetSignature;
-    /** True when `token` has a registration somewhere in this scope's chain. */
-    private isResolvable;
-    /**
-     * Closes this scope synchronously, disposing the instances it owns in REVERSE
-     * construction order. Only native `Disposable` instances are disposed.
-     *
-     * Throws `AsyncDisposalRequiredError` if any owned instance is a Promise
-     * (thenable) — a pending Promise cannot be disposed synchronously; the caller
-     * must use `disposeAsync()`. Idempotent: a second call is a no-op.
-     */
-    dispose(): void;
-    /**
-     * Closes this scope asynchronously. Awaits each owned Promise-valued instance
-     * first (so an async factory's result settles before teardown), then disposes
-     * owned instances in REVERSE construction order — honoring both
-     * `Symbol.asyncDispose` and `Symbol.dispose`. Idempotent.
-     */
-    disposeAsync(): Promise<void>;
-    /** Drops owned references after disposal so they can be collected. */
-    private clear;
-    /** Native `using` support — delegates to `dispose()`. */
-    [Symbol.dispose](): void;
-    /** Native `await using` support — delegates to `disposeAsync()`. */
-    [Symbol.asyncDispose](): Promise<void>;
-}
-//# sourceMappingURL=scope.d.ts.map

package/dist/scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAuB,KAAK,EAAE,MAAM,aAAa,CAAC;AAW9D,OAAO,KAAK,EAGV,YAAY,EACZ,YAAY,EACb,MAAM,YAAY,CAAC;AA4CpB;;;;;;;GAOG;AACH,qBAAa,KAAK,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,CAAE,YAAW,YAAY;IAatE,oEAAoE;aACpD,IAAI,EAAE,MAAM;IAC5B,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAjBpC,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAkC;IAErE,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiB;IAE5C,OAAO,CAAC,QAAQ,CAAS;;IAGvB,oEAAoE;IACpD,IAAI,EAAE,MAAM;IAC5B,qDAAqD;IACpC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS;IAClD,iEAAiE;IAChD,iBAAiB,EAAE,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC;IAGtE,0EAA0E;IACnE,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAIpD;;;;;;OAMG;IACI,eAAe,CAAC,CAAC,EACtB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,CAAC,EACtC,GAAG,CAAC,EAAE,MAAM,GACX,IAAI;IASP,2EAA2E;IACpE,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAKxD;;;;OAIG;IACI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC;IAMlC;;;OAGG;IACH,OAAO,CAAC,MAAM;IAWd;;;OAGG;IACH,OAAO,CAAC,SAAS;IAUjB,gFAAgF;IAChF,OAAO,CAAC,UAAU;IAalB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAsDnB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAmBnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,SAAS;IAgCjB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,OAAO,CAAC,WAAW;IAgDnB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAY7B,4EAA4E;IAC5E,OAAO,CAAC,YAAY;IAMpB;;;;;;;OAOG;IACI,OAAO,IAAI,IAAI;IAmBtB;;;;;OAKG;IACU,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB1C,sEAAsE;IACtE,OAAO,CAAC,KAAK;IAKb,yDAAyD;IAClD,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;IAI/B,oEAAoE;IAC7D,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9C"}