@codefast/di 0.5.0-canary.4 → 0.5.0-canary.6

package/dist/container.js

@@ -0,0 +1,853 @@
+import { DEFAULT_BINDING_SLOT, generateBindingId } from "#/binding";
+import { effectiveBindingScope } from "#/binding-scope";
+import { normalizeToDescriptor } from "#/decorators/inject";
+import { buildDependencyGraph } from "#/dependency-graph";
+import { AsyncModuleLoadError, CircularDependencyError, DisposedContainerError, InternalError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, } from "#/errors";
+import { Inspector } from "#/inspector";
+import { LifecycleManager } from "#/lifecycle";
+import { MetadataReaderToken } from "#/metadata/metadata-reader-token";
+import { defaultMetadataReader } from "#/metadata/symbol-metadata-reader";
+import { isSyncModule } from "#/module";
+import { BindingRegistry } from "#/registry";
+import { injectionSlotToResolveOptions, bindingSlotToResolveOptions } from "#/resolve-options";
+import { DependencyResolver } from "#/resolver";
+import { ScopeManager } from "#/scope";
+import { tokenName } from "#/token";
+// ── DefaultContainer ──────────────────────────────────────────────────────────
+class DefaultContainer {
+    _disposed = false;
+    _registry;
+    _scope;
+    _lifecycle;
+    _resolver;
+    _inspector;
+    _parent;
+    // Module tracking: module -> ref count
+    _moduleRefs = new Map();
+    // Module bindings: module -> array of binding IDs registered by it
+    _moduleBindingIds = new Map();
+    constructor(parent) {
+        this._parent = parent;
+        this._registry = new BindingRegistry();
+        this._scope = new ScopeManager(parent !== undefined);
+        this._lifecycle = new LifecycleManager();
+        this._inspector = new Inspector(this._registry, this._scope, parent !== undefined, () => this._disposed);
+        this._initResolver();
+    }
+    _initResolver() {
+        const metadataReader = this._getMetadataReader();
+        const parentResolver = this._parent?._resolver;
+        this._resolver = new DependencyResolver(this._registry, this._scope, this._lifecycle, metadataReader, this, parentResolver);
+    }
+    _getMetadataReader() {
+        // Check if a custom MetadataReader has been bound
+        const metaBindings = this._registry.getAll(MetadataReaderToken);
+        if (metaBindings.length > 0) {
+            try {
+                return this._resolver.resolve(MetadataReaderToken, undefined, [], []);
+            }
+            catch {
+                // fall through to default
+            }
+        }
+        if (this._parent !== undefined) {
+            return this._parent._getMetadataReader();
+        }
+        return defaultMetadataReader;
+    }
+    get isDisposed() {
+        return this._disposed;
+    }
+    // ── Binding ──────────────────────────────────────────────────────────────
+    bind(token) {
+        this._assertNotDisposed();
+        return this._createBindToBuilder(token);
+    }
+    _createBindToBuilder(token, moduleRef) {
+        const registry = this._registry;
+        const commitBinding = (binding, previousId) => {
+            if (previousId !== undefined) {
+                registry.removeById(previousId);
+                if (moduleRef !== undefined) {
+                    const ids = this._moduleBindingIds.get(moduleRef);
+                    if (ids !== undefined) {
+                        const idx = ids.indexOf(previousId);
+                        if (idx !== -1) {
+                            ids.splice(idx, 1);
+                        }
+                    }
+                }
+            }
+            registry.add(binding);
+            if (moduleRef !== undefined) {
+                let ids = this._moduleBindingIds.get(moduleRef);
+                if (ids === undefined) {
+                    ids = [];
+                    this._moduleBindingIds.set(moduleRef, ids);
+                }
+                ids.push(binding.id);
+            }
+            return binding.id;
+        };
+        return new BindingEntry(token, commitBinding);
+    }
+    unbind(tokenOrId) {
+        this._assertNotDisposed();
+        this._unbindSync(tokenOrId);
+    }
+    /** Remove bindings from registry + scope and collect [binding, instance] pairs for deactivation. */
+    _collectDeactivationPairs(tokenOrId) {
+        const pairs = [];
+        for (const binding of this._getBindingsForTokenOrId(tokenOrId)) {
+            this._registry.removeById(binding.id);
+            if (this._scope.hasSingleton(binding.id)) {
+                pairs.push([binding, this._scope.getSingleton(binding.id)]);
+                this._scope.deleteSingleton(binding.id);
+            }
+        }
+        return pairs;
+    }
+    /** Drain singleton scope entries for a set of already-removed bindings. */
+    _drainSingletons(bindings) {
+        const pairs = [];
+        for (const binding of bindings) {
+            if (this._scope.hasSingleton(binding.id)) {
+                pairs.push([binding, this._scope.getSingleton(binding.id)]);
+                this._scope.deleteSingleton(binding.id);
+            }
+        }
+        return pairs;
+    }
+    _unbindSync(tokenOrId) {
+        const reader = this._getMetadataReader();
+        for (const [binding, instance] of this._collectDeactivationPairs(tokenOrId)) {
+            this._lifecycle.runDeactivationSync(binding, instance, reader);
+        }
+    }
+    async unbindAsync(tokenOrId) {
+        this._assertNotDisposed();
+        const reader = this._getMetadataReader();
+        for (const [binding, instance] of this._collectDeactivationPairs(tokenOrId)) {
+            await this._lifecycle.runDeactivation(binding, instance, reader);
+        }
+    }
+    unbindAll() {
+        this._assertNotDisposed();
+        const reader = this._getMetadataReader();
+        for (const [binding, instance] of this._drainSingletons(this._registry.clear())) {
+            this._lifecycle.runDeactivationSync(binding, instance, reader);
+        }
+    }
+    async unbindAllAsync() {
+        this._assertNotDisposed();
+        const reader = this._getMetadataReader();
+        for (const [binding, instance] of this._drainSingletons(this._registry.clear())) {
+            await this._lifecycle.runDeactivation(binding, instance, reader);
+        }
+    }
+    rebind(token) {
+        this._assertNotDisposed();
+        if (!this._registry.has(token)) {
+            throw new RebindUnboundTokenError(tokenName(token));
+        }
+        // Unbind existing (sync — if async deactivation, will throw AsyncDeactivationError)
+        this._unbindSync(token);
+        return this._createBindToBuilder(token);
+    }
+    _getBindingsForTokenOrId(tokenOrId) {
+        if (typeof tokenOrId === "string") {
+            // It's a BindingIdentifier (string)
+            const binding = this._registry.getById(tokenOrId);
+            return binding !== undefined ? [binding] : [];
+        }
+        return [...this._registry.getAll(tokenOrId)];
+    }
+    // ── Module ────────────────────────────────────────────────────────────────
+    load(...modules) {
+        this._assertNotDisposed();
+        this._loadSyncModules(modules);
+    }
+    _loadSyncModules(modules) {
+        // Collect all modules in topological order (dedup by identity)
+        const toLoad = this._collectModuleDeps(modules);
+        for (const module of toLoad) {
+            if (!isSyncModule(module)) {
+                throw new AsyncModuleLoadError(module.name);
+            }
+            const moduleRef = module;
+            const existing = this._moduleRefs.get(moduleRef);
+            if (existing !== undefined) {
+                this._moduleRefs.set(moduleRef, existing + 1);
+                continue;
+            }
+            this._moduleRefs.set(moduleRef, 1);
+            const builder = this._createModuleBuilder(moduleRef);
+            module._setup(builder);
+        }
+    }
+    _collectModuleDeps(modules) {
+        const seen = new Set();
+        const result = [];
+        const visit = (module) => {
+            const moduleRef = module;
+            if (seen.has(moduleRef)) {
+                return;
+            }
+            seen.add(moduleRef);
+            // We'll collect deps during setup via the builder's import()
+            result.push(module);
+        };
+        for (const module of modules) {
+            visit(module);
+        }
+        return result;
+    }
+    async loadAsync(...modules) {
+        this._assertNotDisposed();
+        for (const module of modules) {
+            await this._loadOneModuleAsync(module);
+        }
+    }
+    async _loadOneModuleAsync(module) {
+        const moduleRef = module;
+        const existing = this._moduleRefs.get(moduleRef);
+        if (existing !== undefined) {
+            this._moduleRefs.set(moduleRef, existing + 1);
+            return;
+        }
+        this._moduleRefs.set(moduleRef, 1);
+        if (isSyncModule(module)) {
+            const builder = this._createModuleBuilder(moduleRef);
+            module._setup(builder);
+        }
+        else {
+            const importPromises = [];
+            const builder = this._createAsyncModuleBuilder(moduleRef, importPromises);
+            await module._setup(builder);
+            // Await nested async imports triggered inside _setup
+            if (importPromises.length > 0) {
+                await Promise.all(importPromises);
+            }
+        }
+    }
+    _createModuleBuilder(moduleRef) {
+        return {
+            bind: (token) => this._createBindToBuilder(token, moduleRef),
+            import: (...modules) => {
+                this._loadSyncModules(modules);
+            },
+        };
+    }
+    _createAsyncModuleBuilder(moduleRef, importPromises) {
+        return {
+            bind: (token) => this._createBindToBuilder(token, moduleRef),
+            import: (...modules) => {
+                for (const module of modules) {
+                    importPromises.push(this._loadOneModuleAsync(module));
+                }
+            },
+        };
+    }
+    unload(...modules) {
+        this._assertNotDisposed();
+        for (const module of modules) {
+            this._unloadModuleSync(module);
+        }
+    }
+    /** Unregister module bindings and collect [binding, instance] pairs for deactivation. */
+    _removeModuleBindings(ref) {
+        this._moduleRefs.delete(ref);
+        const ids = this._moduleBindingIds.get(ref) ?? [];
+        this._moduleBindingIds.delete(ref);
+        const pairs = [];
+        for (const id of ids) {
+            const binding = this._registry.getById(id);
+            if (binding !== undefined) {
+                this._registry.removeById(id);
+                if (this._scope.hasSingleton(id)) {
+                    pairs.push([binding, this._scope.getSingleton(id)]);
+                    this._scope.deleteSingleton(id);
+                }
+            }
+        }
+        return pairs;
+    }
+    _unloadModuleSync(ref) {
+        const count = this._moduleRefs.get(ref) ?? 0;
+        if (count <= 1) {
+            const reader = this._getMetadataReader();
+            for (const [binding, instance] of this._removeModuleBindings(ref)) {
+                this._lifecycle.runDeactivationSync(binding, instance, reader);
+            }
+        }
+        else {
+            this._moduleRefs.set(ref, count - 1);
+        }
+    }
+    async unloadAsync(...modules) {
+        this._assertNotDisposed();
+        for (const module of modules) {
+            await this._unloadModuleAsync(module);
+        }
+    }
+    async _unloadModuleAsync(ref) {
+        const count = this._moduleRefs.get(ref) ?? 0;
+        if (count <= 1) {
+            const reader = this._getMetadataReader();
+            for (const [binding, instance] of this._removeModuleBindings(ref)) {
+                await this._lifecycle.runDeactivation(binding, instance, reader);
+            }
+        }
+        else {
+            this._moduleRefs.set(ref, count - 1);
+        }
+    }
+    loadAutoRegistered(registry) {
+        this._assertNotDisposed();
+        const entries = registry.entries();
+        for (const { target, scope } of entries) {
+            const builder = this._createBindToBuilder(target);
+            const bindingBuilder = builder.toSelf();
+            if (scope === "singleton") {
+                bindingBuilder.singleton();
+            }
+            else if (scope === "scoped") {
+                bindingBuilder.scoped();
+            }
+            else {
+                bindingBuilder.transient();
+            }
+        }
+        return entries.length;
+    }
+    // ── Lifecycle hooks ────────────────────────────────────────────────────────
+    onActivation(token, handler) {
+        this._assertNotDisposed();
+        this._lifecycle.registerActivation(token, handler);
+    }
+    onDeactivation(token, handler) {
+        this._assertNotDisposed();
+        this._lifecycle.registerDeactivation(token, handler);
+    }
+    // ── Resolution ────────────────────────────────────────────────────────────
+    resolve(token, options) {
+        this._assertNotDisposed();
+        if (options === undefined) {
+            return this._resolver.resolveFromContext(token, [], []);
+        }
+        return this._resolver.resolve(token, options, [], []);
+    }
+    resolveAsync(token, options) {
+        this._assertNotDisposed();
+        if (options === undefined) {
+            return this._resolver.resolveAsyncFromContext(token, [], []);
+        }
+        return this._resolver.resolveAsync(token, options, [], []);
+    }
+    resolveOptional(token, options) {
+        this._assertNotDisposed();
+        return this._resolver.resolveOptional(token, options, [], []);
+    }
+    resolveOptionalAsync(token, options) {
+        this._assertNotDisposed();
+        return this._resolver.resolveOptionalAsync(token, options, [], []);
+    }
+    resolveAll(token, options) {
+        this._assertNotDisposed();
+        return this._resolver.resolveAll(token, options, [], []);
+    }
+    resolveAllAsync(token, options) {
+        this._assertNotDisposed();
+        return this._resolver.resolveAllAsync(token, options, [], []);
+    }
+    // ── Child ─────────────────────────────────────────────────────────────────
+    createChild() {
+        this._assertNotDisposed();
+        return new DefaultContainer(this);
+    }
+    // ── Dispose ───────────────────────────────────────────────────────────────
+    async dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        // Deactivate all singletons in this container (own only)
+        const reader = this._getMetadataReader();
+        for (const [id, instance] of this._scope.getAllSingletons()) {
+            const binding = this._registry.getById(id);
+            if (binding !== undefined) {
+                await this._lifecycle.runDeactivation(binding, instance, reader);
+            }
+        }
+        this._scope.clearAll();
+    }
+    [Symbol.asyncDispose]() {
+        return this.dispose();
+    }
+    [Symbol.dispose]() {
+        throw new SyncDisposalNotSupportedError();
+    }
+    // ── Initialization ────────────────────────────────────────────────────────
+    async initializeAsync() {
+        this._assertNotDisposed();
+        const allBindings = this._registry.allBindings();
+        for (const binding of allBindings) {
+            if (binding.kind === "alias") {
+                continue;
+            }
+            const scope = effectiveBindingScope(binding);
+            if (scope === "singleton" && !this._scope.hasSingleton(binding.id)) {
+                if (binding.predicate !== undefined) {
+                    continue;
+                }
+                // Has activation — need to resolve
+                if (binding.kind === "constant" && binding.onActivation === undefined) {
+                    continue;
+                }
+                const slotOptions = bindingSlotToResolveOptions(binding.slot);
+                await this.resolveAsync(binding.token, slotOptions);
+            }
+        }
+    }
+    // ── Validate ──────────────────────────────────────────────────────────────
+    validate() {
+        this._assertNotDisposed();
+        const reader = this._getMetadataReader();
+        const allBindings = this._registry.allBindings();
+        for (const binding of allBindings) {
+            if (!this._isSingletonStaticAnalyzableBinding(binding)) {
+                continue;
+            }
+            this._validateSingletonBindingGraph(binding, reader);
+        }
+    }
+    _isSingletonStaticAnalyzableBinding(binding) {
+        if (effectiveBindingScope(binding) !== "singleton") {
+            return false;
+        }
+        return binding.kind === "class" || binding.kind === "resolved" || binding.kind === "resolved-async";
+    }
+    /**
+     * DFS over explicit constructor / `toResolved*` dependency edges. Follows `toAlias` chains to the
+     * terminal binding for scope checks (SPEC §6.9). Skips `toDynamic*` subtrees (opaque).
+     */
+    _validateSingletonBindingGraph(root, reader) {
+        const rootName = tokenName(root.token);
+        const dfs = (current, pathNames, pathBindingIds) => {
+            if (pathBindingIds.has(current.id)) {
+                return;
+            }
+            const extendedPathIds = new Set(pathBindingIds);
+            extendedPathIds.add(current.id);
+            for (const edge of this._collectStaticDependencyEdges(current, reader)) {
+                const { terminal, depTokenName } = edge;
+                const depScope = this._validationScopeFromTerminal(terminal);
+                if (depScope === "opaque") {
+                    continue;
+                }
+                if (depScope === "scoped" || depScope === "transient") {
+                    throw new ScopeViolationError({
+                        consumerToken: rootName,
+                        consumerScope: "singleton",
+                        dependencyToken: depTokenName,
+                        dependencyScope: depScope,
+                        path: [...pathNames, depTokenName],
+                    });
+                }
+                if (terminal.kind === "class" || terminal.kind === "resolved" || terminal.kind === "resolved-async") {
+                    dfs(terminal, [...pathNames, depTokenName], extendedPathIds);
+                }
+            }
+        };
+        dfs(root, [rootName], new Set());
+    }
+    _validationScopeFromTerminal(terminal) {
+        switch (terminal.kind) {
+            case "constant":
+                return "singleton";
+            case "dynamic":
+            case "dynamic-async":
+                return "opaque";
+            case "class":
+            case "resolved":
+            case "resolved-async":
+                return terminal.scope;
+            case "alias":
+                throw new InternalError("validate: expected terminal binding after alias resolution");
+            default: {
+                const exhaustive = terminal;
+                return exhaustive;
+            }
+        }
+    }
+    _followAliasChainToTerminal(binding, options) {
+        const cyclePath = [];
+        const seenAliasIds = new Set();
+        let current = binding;
+        while (current !== undefined && current.kind === "alias") {
+            if (seenAliasIds.has(current.id)) {
+                throw new CircularDependencyError(cyclePath);
+            }
+            seenAliasIds.add(current.id);
+            cyclePath.push(tokenName(current.token));
+            const nextToken = current.target;
+            const next = this._resolver.peekBindingForValidate(nextToken, options);
+            if (next === undefined) {
+                return undefined;
+            }
+            current = next.binding;
+        }
+        return current;
+    }
+    _collectStaticDependencyEdges(binding, reader) {
+        const edges = [];
+        const pushTerminal = (terminal, displayName) => {
+            if (terminal === undefined) {
+                return;
+            }
+            edges.push({ terminal, depTokenName: displayName });
+        };
+        if (binding.kind === "class") {
+            const meta = reader.getConstructorMetadata(binding.target);
+            if (meta === undefined) {
+                return edges;
+            }
+            for (const param of meta.params) {
+                const paramOptions = injectionSlotToResolveOptions(param);
+                if (param.optional) {
+                    continue;
+                }
+                const tokenRef = param.token;
+                if (param.multi) {
+                    const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramOptions);
+                    for (const cand of candidates) {
+                        const term = this._followAliasChainToTerminal(cand, paramOptions);
+                        pushTerminal(term, term !== undefined ? tokenName(term.token) : "");
+                    }
+                    continue;
+                }
+                const found = paramOptions === undefined
+                    ? this._resolver.peekBindingForValidate(tokenRef, undefined)
+                    : this._resolver.peekBindingForValidate(tokenRef, paramOptions);
+                if (found === undefined) {
+                    continue;
+                }
+                const term = this._followAliasChainToTerminal(found.binding, paramOptions);
+                pushTerminal(term, term !== undefined ? tokenName(term.token) : "");
+            }
+            return edges;
+        }
+        if (binding.kind === "resolved" || binding.kind === "resolved-async") {
+            for (const dep of binding.deps) {
+                const depOptions = injectionSlotToResolveOptions(dep);
+                if (dep.optional) {
+                    continue;
+                }
+                const tokenRef = dep.token;
+                if (dep.multi) {
+                    const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depOptions);
+                    for (const cand of candidates) {
+                        const term = this._followAliasChainToTerminal(cand, depOptions);
+                        pushTerminal(term, term !== undefined ? tokenName(term.token) : "");
+                    }
+                    continue;
+                }
+                const found = depOptions === undefined
+                    ? this._resolver.peekBindingForValidate(tokenRef, undefined)
+                    : this._resolver.peekBindingForValidate(tokenRef, depOptions);
+                if (found === undefined) {
+                    continue;
+                }
+                const term = this._followAliasChainToTerminal(found.binding, depOptions);
+                pushTerminal(term, term !== undefined ? tokenName(term.token) : "");
+            }
+        }
+        return edges;
+    }
+    // ── Introspection ─────────────────────────────────────────────────────────
+    has(token, options) {
+        this._assertNotDisposed();
+        return this._inspector.has(token, options, () => this._parent?.has(token, options) ?? false);
+    }
+    hasOwn(token, options) {
+        this._assertNotDisposed();
+        return this._inspector.hasOwn(token, options);
+    }
+    lookupBindings(token) {
+        this._assertNotDisposed();
+        return this._inspector.lookupBindings(token);
+    }
+    inspect() {
+        this._assertNotDisposed();
+        return this._inspector.inspect();
+    }
+    generateDependencyGraph(options) {
+        this._assertNotDisposed();
+        return buildDependencyGraph(this._registry, this._getMetadataReader(), options, this._parent?._registry);
+    }
+    // ── Internal ──────────────────────────────────────────────────────────────
+    _assertNotDisposed() {
+        if (this._disposed) {
+            throw new DisposedContainerError();
+        }
+    }
+}
+function updateSlotTag(slot, tag, value) {
+    const existing = [...slot.tags];
+    const idx = existing.findIndex(([k]) => k === tag);
+    if (idx !== -1) {
+        existing[idx] = [tag, value];
+    }
+    else {
+        existing.push([tag, value]);
+    }
+    return { ...slot, tags: existing };
+}
+// ── SlotBuilder ───────────────────────────────────────────────────────────────
+class SlotBuilder {
+    _slot = DEFAULT_BINDING_SLOT; // ✓ T3-1: no redundant spread
+    _predicate;
+    _committed;
+    when(predicate) {
+        this._predicate = predicate;
+        this._doCommit();
+        return this;
+    }
+    whenNamed(name) {
+        this._slot = { ...this._slot, name };
+        this._doCommit();
+        return this;
+    }
+    whenTagged(tag, value) {
+        this._slot = updateSlotTag(this._slot, tag, value);
+        this._doCommit();
+        return this;
+    }
+    whenDefault() {
+        return this;
+    }
+    id() {
+        return this._committed;
+    }
+}
+// ── BindingEntry ──────────────────────────────────────────────────────────────
+class BindingEntry {
+    _token;
+    _commit;
+    constructor(_token, _commit) {
+        this._token = _token;
+        this._commit = _commit;
+    }
+    to(type) {
+        return new ConstraintBuilder(this._token, { kind: "class", target: type, scope: "transient" }, this._commit);
+    }
+    toSelf() {
+        if (typeof this._token !== "function") {
+            throw new Error("toSelf() requires token to be a Constructor");
+        }
+        return new ConstraintBuilder(this._token, { kind: "class", target: this._token, scope: "transient" }, this._commit);
+    }
+    toConstantValue(value) {
+        return new ConstantBuilder(this._token, value, this._commit);
+    }
+    toDynamic(factory) {
+        return new ConstraintBuilder(this._token, { kind: "dynamic", factory, scope: "transient" }, this._commit);
+    }
+    toDynamicAsync(factory) {
+        return new ConstraintBuilder(this._token, { kind: "dynamic-async", factory, scope: "transient" }, this._commit);
+    }
+    toResolved(factory, deps) {
+        const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
+        return new ConstraintBuilder(this._token, {
+            kind: "resolved",
+            factory: factory,
+            deps: normalizedDeps,
+            scope: "transient",
+        }, this._commit);
+    }
+    toResolvedAsync(factory, deps) {
+        const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
+        return new ConstraintBuilder(this._token, {
+            kind: "resolved-async",
+            factory: factory,
+            deps: normalizedDeps,
+            scope: "transient",
+        }, this._commit);
+    }
+    toAlias(target) {
+        return new AliasBuilder(this._token, target, this._commit);
+    }
+}
+// ── ConstraintBuilder ─────────────────────────────────────────────────────────
+class ConstraintBuilder extends SlotBuilder {
+    _token;
+    _partial;
+    _commit;
+    constructor(_token, _partial, _commit) {
+        super();
+        this._token = _token;
+        this._partial = _partial;
+        this._commit = _commit;
+        this._doCommit();
+    }
+    _doCommit() {
+        const previousId = this._committed;
+        const binding = {
+            ...this._partial,
+            id: generateBindingId(),
+            token: this._token,
+            slot: this._slot,
+            predicate: this._predicate,
+        };
+        this._committed = this._commit(binding, previousId);
+    }
+    singleton() {
+        const previousId = this._committed;
+        this._committed = undefined;
+        return new ScopeBuilder(this._token, { ...this._partial, scope: "singleton" }, this._slot, this._predicate, this._commit, "singleton", previousId);
+    }
+    transient() {
+        const previousId = this._committed;
+        this._committed = undefined;
+        return new ScopeBuilder(this._token, { ...this._partial, scope: "transient" }, this._slot, this._predicate, this._commit, "transient", previousId);
+    }
+    scoped() {
+        const previousId = this._committed;
+        this._committed = undefined;
+        return new ScopeBuilder(this._token, { ...this._partial, scope: "scoped" }, this._slot, this._predicate, this._commit, "scoped", previousId);
+    }
+}
+// ── ScopeBuilder ─────────────────────────────────────────────────────────────
+class ScopeBuilder {
+    _token;
+    _partial;
+    _slot;
+    _predicate;
+    _commit;
+    _scope;
+    _initialPreviousId;
+    _onActivation;
+    _onDeactivation;
+    _committed;
+    constructor(_token, _partial, _slot, _predicate, _commit, _scope, _initialPreviousId) {
+        this._token = _token;
+        this._partial = _partial;
+        this._slot = _slot;
+        this._predicate = _predicate;
+        this._commit = _commit;
+        this._scope = _scope;
+        this._initialPreviousId = _initialPreviousId;
+        this._doCommit();
+    }
+    _doCommit() {
+        const previousId = this._committed ?? this._initialPreviousId;
+        const binding = {
+            ...this._partial,
+            id: generateBindingId(),
+            token: this._token,
+            slot: this._slot,
+            predicate: this._predicate,
+            onActivation: this._onActivation,
+            onDeactivation: this._onDeactivation,
+        };
+        this._committed = this._commit(binding, previousId);
+    }
+    onActivation(fn) {
+        this._onActivation = fn;
+        this._doCommit();
+        return this;
+    }
+    onDeactivation(fn) {
+        this._onDeactivation = fn;
+        this._doCommit();
+        return this;
+    }
+    id() {
+        return this._committed;
+    }
+}
+// ── ConstantBuilder ───────────────────────────────────────────────────────────
+class ConstantBuilder extends SlotBuilder {
+    _token;
+    _value;
+    _commit;
+    _onActivation;
+    _onDeactivation;
+    constructor(_token, _value, _commit) {
+        super();
+        this._token = _token;
+        this._value = _value;
+        this._commit = _commit;
+        this._doCommit();
+    }
+    _doCommit() {
+        const previousId = this._committed;
+        const binding = {
+            kind: "constant",
+            id: generateBindingId(),
+            token: this._token,
+            slot: this._slot,
+            predicate: this._predicate,
+            value: this._value,
+            scope: "singleton",
+            onActivation: this._onActivation,
+            onDeactivation: this._onDeactivation,
+        };
+        this._committed = this._commit(binding, previousId);
+    }
+    onActivation(fn) {
+        this._onActivation = fn;
+        this._doCommit();
+        return this;
+    }
+    onDeactivation(fn) {
+        this._onDeactivation = fn;
+        this._doCommit();
+        return this;
+    }
+}
+// ── AliasBuilder ──────────────────────────────────────────────────────────────
+class AliasBuilder extends SlotBuilder {
+    _token;
+    _target;
+    _commit;
+    constructor(_token, _target, _commit) {
+        super();
+        this._token = _token;
+        this._target = _target;
+        this._commit = _commit;
+        this._doCommit();
+    }
+    _doCommit() {
+        const previousId = this._committed;
+        const binding = {
+            kind: "alias",
+            id: generateBindingId(),
+            token: this._token,
+            slot: this._slot,
+            predicate: this._predicate,
+            target: this._target,
+        };
+        this._committed = this._commit(binding, previousId);
+    }
+}
+// ── Container static ──────────────────────────────────────────────────────────
+/**
+ * @since 0.3.16-canary.0
+ */
+export const Container = {
+    create() {
+        return new DefaultContainer();
+    },
+    fromModules(...modules) {
+        const container = new DefaultContainer();
+        container.load(...modules);
+        return container;
+    },
+    async fromModulesAsync(...modules) {
+        const container = new DefaultContainer();
+        await container.loadAsync(...modules);
+        return container;
+    },
+};
+//# sourceMappingURL=container.js.map