katagami 3.0.2 → 4.0.0

package/dist/index.cjs

@@ -24,85 +24,311 @@ __export(index_exports, {
   ContainerError: () => ContainerError,
   Scope: () => Scope,
   createContainer: () => createContainer,
-  createScope: () => createScope
+  createMetadataKey: () => createMetadataKey,
+  createScope: () => createScope,
+  entrypoint: () => entrypoint
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/entrypoint/index.ts
+var ENTRYPOINT = /* @__PURE__ */ Symbol.for("katagami.entrypoint.v1");
+function entrypoint(factory) {
+  return Object.assign((resolver) => factory(resolver), { [ENTRYPOINT]: true });
+}
+function isEntrypoint(factory) {
+  return typeof factory === "function" && ENTRYPOINT in factory && factory[ENTRYPOINT] === true;
+}
+
+// src/error/index.ts
+var ContainerError = class extends Error {
+  /**
+   * @param message Error message
+   */
+  constructor(message) {
+    super(message);
+    this.name = "ContainerError";
+  }
+};
+
 // src/internal.ts
-var INTERNALS = /* @__PURE__ */ Symbol.for("katagami.internals.v3");
+var INTERNALS = /* @__PURE__ */ Symbol.for("katagami.internals.v4");
+var CREATIONS = /* @__PURE__ */ Symbol.for("katagami.creations.v4");
+var shared = globalThis;
+if (!shared[CREATIONS]) {
+  Object.defineProperty(shared, CREATIONS, { value: /* @__PURE__ */ new WeakMap() });
+}
+var creations = shared[CREATIONS];
+function settle(creation) {
+  return creation.then(
+    (value) => ({ failed: false, value }),
+    (error) => ({ error, failed: true })
+  );
+}
+var CONSTRUCTING = /* @__PURE__ */ Symbol.for("katagami.constructing.v4");
+var running = globalThis;
+if (!running[CONSTRUCTING]) {
+  Object.defineProperty(running, CONSTRUCTING, { value: [] });
+}
+var constructing = running[CONSTRUCTING];
+
+// src/metadata/index.ts
+var KEY = /* @__PURE__ */ Symbol.for("katagami.metadata-key.v1");
+var ENTRY = /* @__PURE__ */ Symbol.for("katagami.metadata-entry.v1");
+function createMetadataKey() {
+  return (name) => {
+    const key = (value) => Object.freeze({ key, value, [ENTRY]: true });
+    Object.defineProperties(key, { name: { value: name }, [KEY]: { value: true } });
+    return key;
+  };
+}
+function readMetadata(entries, required) {
+  const values = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry?.[ENTRY] !== true || entry.key?.[KEY] !== true) {
+      throw new ContainerError("Invalid metadata entry.");
+    }
+    if (names.has(entry.key.name)) {
+      throw new ContainerError("Duplicate metadata key.");
+    }
+    names.add(entry.key.name);
+    values.set(entry.key, entry.value);
+  }
+  for (const key of required) {
+    if (!values.has(key)) {
+      throw new ContainerError("Required metadata is missing.");
+    }
+  }
+  return Object.freeze({
+    pairs: Object.freeze([...values].map((pair) => Object.freeze(pair))),
+    reader: Object.freeze({
+      get: (key) => values.get(key),
+      has: (key) => values.has(key),
+      require: (key) => {
+        if (!values.has(key)) {
+          throw new ContainerError("Required metadata is missing.");
+        }
+        return values.get(key);
+      }
+    })
+  });
+}
+function validateMetadataKeys(keys) {
+  const names = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    if (key?.[KEY] !== true) {
+      throw new ContainerError("Invalid metadata key.");
+    }
+    if (names.has(key.name)) {
+      throw new ContainerError("Duplicate required metadata key.");
+    }
+    names.add(key.name);
+  }
+}
+
+// src/container/policy.ts
+var POLICIES = /* @__PURE__ */ Symbol.for("katagami.policy-state.4.0.0.v1");
+var shared2 = globalThis;
+if (!shared2[POLICIES]) {
+  Object.defineProperty(shared2, POLICIES, { value: /* @__PURE__ */ new WeakMap() });
+}
+var policies = shared2[POLICIES];
+function dataProperty(source, key) {
+  let current = source;
+  while (current !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+    if (descriptor) {
+      if (!("value" in descriptor)) {
+        throw new ContainerError("Policy settings must be data properties.");
+      }
+      return descriptor.value;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+}
+function bindPolicy(definition) {
+  if (definition === void 0) {
+    return void 0;
+  }
+  if (definition === null || typeof definition !== "object") {
+    throw new ContainerError("Policy must be an object.");
+  }
+  const name = dataProperty(definition, "name");
+  const required = dataProperty(definition, "requiredMetadata");
+  const beforeReturn = dataProperty(definition, "beforeReturn");
+  if (name !== void 0 && typeof name !== "string") {
+    throw new ContainerError("Policy name must be a string.");
+  }
+  if (required !== void 0 && !Array.isArray(required)) {
+    throw new ContainerError("Required metadata must be an array.");
+  }
+  if (beforeReturn !== void 0 && typeof beforeReturn !== "function") {
+    throw new ContainerError("beforeReturn must be a function.");
+  }
+  const keys = [];
+  if (required !== void 0) {
+    for (let index = 0; index < required.length; index++) {
+      keys.push(dataProperty(required, index));
+    }
+  }
+  validateMetadataKeys(keys);
+  const previous = policies.get(definition);
+  if (previous) {
+    if (previous.name !== name || previous.beforeReturn !== beforeReturn || previous.requiredMetadata.length !== keys.length || previous.requiredMetadata.some((key, index) => key !== keys[index])) {
+      throw new ContainerError("Policy has changed since its first use.");
+    }
+    return previous;
+  }
+  const state = Object.freeze({
+    beforeReturn,
+    definition,
+    name,
+    origins: /* @__PURE__ */ new WeakMap(),
+    requiredMetadata: Object.freeze(keys)
+  });
+  policies.set(definition, state);
+  return state;
+}
+function observe(policy, registration, token, value) {
+  if (!policy || value === null || typeof value !== "object" && typeof value !== "function") {
+    return;
+  }
+  let origins = policy.origins.get(value);
+  if (!origins) {
+    origins = [];
+    policy.origins.set(value, origins);
+  }
+  if (origins.some((origin) => sameOrigin(origin, registration, token))) {
+    return;
+  }
+  origins.push(
+    Object.freeze({
+      description: Object.freeze({
+        entrypoint: registration.entrypoint,
+        lifetime: registration.lifetime,
+        metadata: registration.metadata,
+        token
+      }),
+      pairs: registration.metadataPairs
+    })
+  );
+}
+function sameOrigin(origin, registration, token) {
+  const { description } = origin;
+  return Object.is(description.token, token) && description.lifetime === registration.lifetime && description.entrypoint === registration.entrypoint && (description.metadata === registration.metadata || samePairs(origin.pairs, registration.metadataPairs));
+}
+function samePairs(left, right) {
+  return left !== void 0 && right !== void 0 && left.length === right.length && left.every(([key, value]) => right.some(([other, candidate]) => other === key && Object.is(candidate, value)));
+}
+function checkReturn(policy, value) {
+  if (!policy?.beforeReturn) {
+    return;
+  }
+  let origins = [];
+  if (value !== null && (typeof value === "object" || typeof value === "function")) {
+    origins = policy.origins.get(value) ?? [];
+  }
+  const event = Object.freeze({
+    registrations: Object.freeze(origins.map((origin) => origin.description))
+  });
+  const result = policy.beforeReturn(event);
+  if (result !== void 0) {
+    void Promise.resolve(result).catch(() => void 0);
+    throw new ContainerError("beforeReturn must return undefined synchronously.");
+  }
+}
 
 // src/container/index.ts
-function createContainer() {
-  return new Container();
+function createContainer(options) {
+  return new Container(options);
 }
 var Container = class {
-  registrations;
-  singletonCache;
+  registrations = /* @__PURE__ */ new Map();
+  singletonCache = /* @__PURE__ */ new Map();
+  requiredMetadata;
+  policy;
   disposed = false;
-  /**
-   * Internal state accessor for extension modules (scope, disposable).
-   *
-   * @internal
-   */
   [INTERNALS];
-  constructor() {
-    this.registrations = /* @__PURE__ */ new Map();
-    this.singletonCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    if (options && "requiredMetadata" in options) {
+      throw new ContainerError("requiredMetadata must be declared in policy.");
+    }
+    this.policy = bindPolicy(options?.policy);
+    this.requiredMetadata = this.policy?.requiredMetadata ?? [];
     this[INTERNALS] = {
+      beforeResolve: [],
       isDisposed: () => this.disposed,
+      kind: "container",
       markDisposed: () => {
         this.disposed = true;
       },
       ownCache: this.singletonCache,
+      policy: this.policy,
       registrations: this.registrations,
       singletonCache: this.singletonCache
     };
   }
-  registerSingleton(token, factory) {
-    return this.addRegistration(token, factory, "singleton");
+  registerSingleton(token, factory, ...options) {
+    return this.addRegistration(token, factory, "singleton", options[0]?.metadata ?? []);
+  }
+  registerTransient(token, factory, ...options) {
+    return this.addRegistration(token, factory, "transient", options[0]?.metadata ?? []);
   }
-  registerTransient(token, factory) {
-    return this.addRegistration(token, factory, "transient");
+  registerScoped(token, factory, ...options) {
+    return this.addRegistration(token, factory, "scoped", options[0]?.metadata ?? []);
   }
-  registerScoped(token, factory) {
-    return this.addRegistration(token, factory, "scoped");
+  getMetadata(token) {
+    const entries = this.registrations.get(token);
+    if (!entries?.length) {
+      throw new ContainerError("Token is not registered.");
+    }
+    return entries[entries.length - 1].metadata;
   }
   use(source) {
+    if (this.disposed) {
+      throw new ContainerError("Cannot register on a disposed container.");
+    }
+    const sourcePolicy = source[INTERNALS].policy;
+    if (sourcePolicy && sourcePolicy !== this.policy) {
+      throw new ContainerError("Cannot compose containers with different policies.");
+    }
+    for (const registrations of source[INTERNALS].registrations.values()) {
+      for (const registration of registrations) {
+        for (const key of this.requiredMetadata) {
+          if (!registration.metadata.has(key)) {
+            throw new ContainerError("Required metadata is missing.");
+          }
+        }
+      }
+    }
     for (const [token, registrations] of source[INTERNALS].registrations) {
       this.registrations.set(token, [...registrations]);
     }
     return this;
   }
-  /**
-   * Add a registration entry. Accumulates registrations for the same token.
-   *
-   * @param token Token
-   * @param factory Factory function
-   * @param lifetime Lifetime of the registration
-   * @returns The container for method chaining
-   */
-  addRegistration(token, factory, lifetime) {
+  addRegistration(token, factory, lifetime, entries) {
+    if (this.disposed) {
+      throw new ContainerError("Cannot register on a disposed container.");
+    }
+    const metadata = readMetadata(entries, this.requiredMetadata);
+    const registration = Object.freeze({
+      entrypoint: isEntrypoint(factory),
+      factory,
+      lifetime,
+      metadata: metadata.reader,
+      metadataPairs: metadata.pairs
+    });
     const existing = this.registrations.get(token);
-    if (existing !== void 0) {
-      existing.push({ factory, lifetime });
+    if (existing) {
+      existing.push(registration);
     } else {
-      this.registrations.set(token, [{ factory, lifetime }]);
+      this.registrations.set(token, [registration]);
     }
     return this;
   }
 };
 
-// src/error/index.ts
-var ContainerError = class extends Error {
-  /**
-   * @param message Error message
-   */
-  constructor(message) {
-    super(message);
-    this.name = "ContainerError";
-  }
-};
-
 // src/resolver/index.ts
 function tokenToString(token) {
   if (typeof token === "function") {
@@ -128,171 +354,347 @@ function buildCircularPath(resolvingTokens, token) {
   return path.join(" -> ");
 }
 
+// src/disposable/index.ts
+function disposable(container) {
+  const asyncDispose = async () => {
+    const internals = container[INTERNALS];
+    if (internals.isDisposed()) {
+      return;
+    }
+    internals.markDisposed();
+    const instances = [...internals.ownCache.values()].reverse();
+    const errors = [];
+    for (const instance of instances) {
+      let resolved = instance;
+      if (instance instanceof Promise) {
+        const creation = await (creations.get(instance) ?? settle(instance));
+        if (creation.failed) {
+          continue;
+        }
+        resolved = creation.value;
+      }
+      try {
+        if (resolved != null && typeof resolved === "object") {
+          if (Symbol.asyncDispose in resolved) {
+            await resolved[Symbol.asyncDispose]();
+          } else if (Symbol.dispose in resolved) {
+            resolved[Symbol.dispose]();
+          }
+        }
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    internals.ownCache.clear();
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "One or more errors occurred during disposal.");
+    }
+  };
+  Object.defineProperty(container, Symbol.asyncDispose, {
+    configurable: true,
+    value: asyncDispose
+  });
+  return container;
+}
+
+// src/scope/operations.ts
+function operations(source) {
+  const internals = source[INTERNALS];
+  const scope = disposable(source);
+  let closed = false;
+  let disposal;
+  const pending = /* @__PURE__ */ new Set();
+  const assertOpen = () => {
+    if (closed || internals.isDisposed()) {
+      throw new ContainerError("Cannot invoke from a disposed scope.");
+    }
+  };
+  const assertEntrypoint = (token) => {
+    const registrations = internals.registrations.get(token);
+    const registration = registrations?.[registrations.length - 1];
+    if (!registration) {
+      throw new ContainerError("Token is not registered.");
+    }
+    if (!registration.entrypoint) {
+      throw new ContainerError("Token is not an entrypoint.");
+    }
+  };
+  const execute = (token, args) => {
+    try {
+      assertOpen();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const body = Promise.resolve().then(async () => {
+      assertEntrypoint(token);
+      const callable = await internals.resolveInternal(token);
+      if (typeof callable !== "function") {
+        throw new ContainerError("Entrypoint factory must return a callable.");
+      }
+      const result = await callable(...args);
+      checkReturn(internals.policy, result);
+      return result;
+    });
+    const operation = body.then((result) => result);
+    const running2 = body.then(
+      () => {
+        pending.delete(running2);
+      },
+      () => {
+        pending.delete(running2);
+      }
+    );
+    pending.add(running2);
+    return operation;
+  };
+  return Object.freeze({
+    get: (token) => {
+      assertOpen();
+      assertEntrypoint(token);
+      return (...args) => execute(token, args);
+    },
+    [Symbol.asyncDispose]: () => {
+      if (!disposal) {
+        closed = true;
+        disposal = (async () => {
+          await Promise.all(pending);
+          await scope[Symbol.asyncDispose]();
+        })();
+      }
+      return disposal;
+    }
+  });
+}
+
 // src/scope/index.ts
-function createScope(source) {
+var EXPOSED = Object.freeze({ exposed: true, path: Object.freeze([]), singleton: false });
+function createScope(source, options) {
+  const access = options?.access;
+  if (access !== void 0 && access !== "operations") {
+    throw new ContainerError("Unknown scope access. Omit access or use 'operations'.");
+  }
   const internals = source[INTERNALS];
   if (internals.isDisposed()) {
     throw new ContainerError("Cannot create a scope from a disposed container.");
   }
-  return new Scope(internals.registrations, internals.singletonCache);
+  const hooks = [...internals.beforeResolve];
+  if (options?.beforeResolve) {
+    hooks.push(options.beforeResolve);
+  }
+  const scope = new Scope(internals.registrations, internals.singletonCache, hooks, internals.policy);
+  if (access === "operations") {
+    return operations(scope);
+  }
+  return scope;
 }
 var Scope = class {
   registrations;
   singletonCache;
   scopedCache;
-  resolvingTokens;
-  singletonDepth = 0;
+  beforeResolve;
+  policy;
   disposed = false;
-  /**
-   * Internal state accessor for extension modules (scope, disposable).
-   *
-   * @internal
-   */
   [INTERNALS];
-  constructor(registrations, singletonCache) {
+  constructor(registrations, singletonCache, beforeResolve = [], policy) {
     this.registrations = registrations;
     this.singletonCache = singletonCache;
     this.scopedCache = /* @__PURE__ */ new Map();
-    this.resolvingTokens = /* @__PURE__ */ new Set();
+    this.beforeResolve = beforeResolve;
+    this.policy = policy;
     this[INTERNALS] = {
+      beforeResolve: this.beforeResolve,
       isDisposed: () => this.disposed,
+      kind: "scope",
       markDisposed: () => {
         this.disposed = true;
       },
       ownCache: this.scopedCache,
+      policy: this.policy,
       registrations: this.registrations,
+      resolveInternal: (token) => this.resolveToken(token, true),
       singletonCache: this.singletonCache
     };
   }
   resolve(token) {
-    return this.resolveToken(token, true);
+    return this.resolveToken(token, true, this.entry());
   }
   tryResolve(token) {
-    return this.resolveToken(token, false);
+    return this.resolveToken(token, false, this.entry());
   }
   resolveAll(token) {
-    return this.resolveAllTokens(token, true);
+    return this.resolveAllTokens(token, true, this.entry());
   }
   tryResolveAll(token) {
-    return this.resolveAllTokens(token, false);
+    return this.resolveAllTokens(token, false, this.entry());
   }
-  /**
-   * Internal resolution logic shared by resolve and tryResolve.
-   * Resolves the last registered factory for the token.
-   *
-   * @param token Token to resolve
-   * @param required If true, throws when the token is not registered. If false, returns undefined.
-   * @returns The resolved instance, or undefined if not registered and required is false
-   */
-  resolveToken(token, required) {
+  /** The context of a call through a public method: the running factory's, or the outside of this scope. */
+  entry() {
+    const running2 = constructing.at(-1);
+    if (running2?.scope === this) {
+      return running2.context;
+    }
+    return EXPOSED;
+  }
+  describe(token, registration) {
+    return Object.freeze({
+      entrypoint: registration.entrypoint,
+      lifetime: registration.lifetime,
+      metadata: registration.metadata,
+      token
+    });
+  }
+  check(token, registration, context) {
+    if (this.beforeResolve.length === 0) {
+      return;
+    }
+    const event = Object.freeze({
+      ...this.describe(token, registration),
+      path: Object.freeze([...context.path, token]),
+      requester: context.requester
+    });
+    for (const hook of this.beforeResolve) {
+      const result = hook(event);
+      if (result !== void 0) {
+        void Promise.resolve(result).catch(() => void 0);
+        throw new ContainerError("beforeResolve must return undefined synchronously.");
+      }
+    }
+  }
+  lookup(token, required) {
     if (this.disposed) {
       throw new ContainerError("Cannot resolve from a disposed scope.");
     }
     const registrations = this.registrations.get(token);
-    if (registrations === void 0 || registrations.length === 0) {
+    if (!registrations?.length) {
       if (required) {
         throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
       }
       return void 0;
     }
+    return registrations;
+  }
+  /** Create a value that may leave this scope; a synchronous value passes the policy's return check here. */
+  create(token, registration, context) {
+    const instance = this.instantiate(token, registration, context);
+    if (context.exposed && !(instance instanceof Promise)) {
+      checkReturn(this.policy, instance);
+    }
+    return instance;
+  }
+  /**
+   * Shape a created value for the caller.
+   *
+   * The return check runs on every resolution, so under a policy with a return check, an asynchronous
+   * creation leaving the scope is handed out as a per-call Promise that checks the resolved value. No
+   * listener is attached to a Promise already handed out. The per-call Promise is built only after every
+   * synchronous failure is ruled out, so no Promise is left without a receiver.
+   */
+  handOut(value, context) {
+    if (!context.exposed || !this.policy?.beforeReturn || !(value instanceof Promise)) {
+      return value;
+    }
+    return value.then((resolved) => {
+      checkReturn(this.policy, resolved);
+      return resolved;
+    });
+  }
+  resolveToken(token, required, context = { path: [], singleton: false }) {
+    const registrations = this.lookup(token, required);
+    if (!registrations) {
+      return void 0;
+    }
     const registration = registrations[registrations.length - 1];
-    const singletonCached = this.singletonCache.get(registration);
-    if (singletonCached !== void 0) {
-      return singletonCached;
+    this.check(token, registration, context);
+    return this.handOut(this.create(token, registration, context), context);
+  }
+  resolveAllTokens(token, required, context = { path: [], singleton: false }) {
+    const registrations = this.lookup(token, required);
+    if (!registrations) {
+      return void 0;
+    }
+    for (const registration of registrations) {
+      this.check(token, registration, context);
     }
-    if (registration.lifetime === "scoped" && this.singletonDepth > 0) {
+    const created = registrations.map((registration) => this.create(token, registration, context));
+    return created.map((value) => this.handOut(value, context));
+  }
+  instantiate(token, registration, context) {
+    if (registration.lifetime === "scoped" && context.singleton) {
       throw new ContainerError(
         `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
       );
     }
-    const scopedCached = this.scopedCache.get(registration);
-    if (scopedCached !== void 0) {
-      return scopedCached;
+    const construction = context.construction ?? [];
+    let waiting = construction.length;
+    while (waiting > 0 && construction[waiting - 1]?.active) {
+      waiting--;
     }
-    if (this.resolvingTokens.has(token)) {
-      throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
+    if (construction.slice(waiting).some((frame2) => frame2.token === token)) {
+      const chain = new Set(construction.slice(waiting).map((frame2) => frame2.token));
+      throw new ContainerError(`Circular dependency detected: ${buildCircularPath(chain, token)}`);
     }
-    this.resolvingTokens.add(token);
+    let cache = this.scopedCache;
     if (registration.lifetime === "singleton") {
-      this.singletonDepth++;
-    }
-    try {
-      const instance = registration.factory(
-        this
-      );
-      if (registration.lifetime === "singleton") {
-        this.singletonCache.set(registration, instance);
-      } else if (registration.lifetime === "scoped") {
-        this.scopedCache.set(registration, instance);
-      }
-      return instance;
-    } finally {
-      if (registration.lifetime === "singleton") {
-        this.singletonDepth--;
-      }
-      this.resolvingTokens.delete(token);
+      cache = this.singletonCache;
     }
-  }
-  /**
-   * Internal resolution logic shared by resolveAll and tryResolveAll.
-   * Resolves all registered factories for the token.
-   *
-   * @param token Token to resolve
-   * @param required If true, throws when the token is not registered. If false, returns undefined.
-   * @returns An array of resolved instances, or undefined if not registered and required is false
-   */
-  resolveAllTokens(token, required) {
-    if (this.disposed) {
-      throw new ContainerError("Cannot resolve from a disposed scope.");
-    }
-    const registrations = this.registrations.get(token);
-    if (registrations === void 0 || registrations.length === 0) {
-      if (required) {
-        throw new ContainerError(`Token "${tokenToString(token)}" is not registered.`);
+    if (registration.lifetime !== "transient" && cache.get(registration) !== void 0) {
+      const cached = cache.get(registration);
+      if (!(cached instanceof Promise)) {
+        observe(this.policy, registration, token, cached);
       }
-      return void 0;
+      return cached;
     }
-    if (this.resolvingTokens.has(token)) {
-      throw new ContainerError(`Circular dependency detected: ${buildCircularPath(this.resolvingTokens, token)}`);
+    const shares = (entry) => entry.scope === this || registration.lifetime === "singleton" && entry.registration === registration && entry.singletons === this.singletonCache;
+    if (constructing.some((entry) => entry.token === token && shares(entry))) {
+      const chain = new Set(constructing.filter(shares).map((entry) => entry.token));
+      throw new ContainerError(`Circular dependency detected: ${buildCircularPath(chain, token)}`);
     }
-    this.resolvingTokens.add(token);
+    const frame = { active: true, token };
+    const childContext = {
+      construction: [...construction, frame],
+      path: [...context.path, token],
+      requester: this.describe(token, registration),
+      singleton: context.singleton || registration.lifetime === "singleton"
+    };
+    const resolver = Object.freeze({
+      resolve: (target) => this.resolveToken(target, true, childContext),
+      resolveAll: (target) => this.resolveAllTokens(target, true, childContext),
+      tryResolve: (target) => this.resolveToken(target, false, childContext),
+      tryResolveAll: (target) => this.resolveAllTokens(target, false, childContext)
+    });
+    let pending = false;
+    constructing.push({ context: childContext, registration, scope: this, singletons: this.singletonCache, token });
     try {
-      return registrations.map((registration) => {
-        const reg = registration;
-        const singletonCached = this.singletonCache.get(registration);
-        if (singletonCached !== void 0) {
-          return singletonCached;
-        }
-        if (reg.lifetime === "scoped" && this.singletonDepth > 0) {
-          throw new ContainerError(
-            `Captive dependency detected: scoped token "${tokenToString(token)}" cannot be resolved inside a singleton factory. Scoped instances must not be captured by singletons.`
-          );
-        }
-        const scopedCached = this.scopedCache.get(registration);
-        if (scopedCached !== void 0) {
-          return scopedCached;
-        }
-        if (reg.lifetime === "singleton") {
-          this.singletonDepth++;
-        }
-        try {
-          const instance = reg.factory(
-            this
-          );
-          if (reg.lifetime === "singleton") {
-            this.singletonCache.set(registration, instance);
-          } else if (reg.lifetime === "scoped") {
-            this.scopedCache.set(registration, instance);
-          }
-          return instance;
-        } finally {
-          if (reg.lifetime === "singleton") {
-            this.singletonDepth--;
+      const instance = registration.factory(resolver);
+      if (instance instanceof Promise) {
+        pending = true;
+        const tracked = instance.then(
+          (value) => {
+            observe(this.policy, registration, token, value);
+            frame.active = false;
+            return value;
+          },
+          (error) => {
+            frame.active = false;
+            throw error;
           }
+        );
+        if (registration.lifetime !== "transient") {
+          creations.set(tracked, settle(instance));
+          cache.set(registration, tracked);
         }
-      });
+        return tracked;
+      }
+      observe(this.policy, registration, token, instance);
+      if (registration.lifetime !== "transient") {
+        cache.set(registration, instance);
+      }
+      return instance;
     } finally {
-      this.resolvingTokens.delete(token);
+      constructing.pop();
+      if (!pending) {
+        frame.active = false;
+      }
     }
   }
 };