better-effect 0.10.0 → 0.11.0

package/README.md

@@ -99,6 +99,40 @@ const AppLive = Layer.merge(DatabaseLive, UserRepositoryLive)
 const runtime = await Runtime.make(AppLive)
 ```
 
+Use `Layer.empty` when a composition root intentionally has no providers. It is
+stable and has the exact `Layer<never, never>` type:
+
+```ts
+const EmptyLive = Layer.empty
+const runtime = await Runtime.make(EmptyLive)
+await runtime.run(() => 'no Services required')
+```
+
+For a port/adapter boundary, `Layer.alias` exposes one compatible implementation
+under another Service token without constructing, cloning, or proxying it:
+
+```ts
+class SqlUserRepository extends Service<SqlUserRepository>()('SqlUserRepository') {
+  findById(id: string): string {
+    return `sql:${id}`
+  }
+}
+
+class UserRepository extends Service<UserRepository>()('UserRepository') {
+  declare findById: SqlUserRepository['findById']
+}
+
+const UserRepositoryPort = Layer.alias({
+  from: SqlUserRepository,
+  to: UserRepository
+})
+const ApplicationLive = Layer.merge(Layer.empty, Layer.make(SqlUserRepository), UserRepositoryPort)
+```
+
+The alias lazily resolves `from`, returns the same object under `to`, and checks
+that the source satisfies the target's `Service.Contract`. Its source remains an
+external Layer requirement until the source provider is composed.
+
 And the contract does not disappear after startup.
 
 A Runtime also knows which Services exist in its environment:
@@ -128,11 +162,102 @@ input order. If a Program returns an error or throws, scheduling stops, already-
 started Programs are allowed to settle, and the deterministic primary failure remains selected;
 there is no cancellation or Fiber scheduler.
 
+Use `Program.forEach` when each item needs a lazy Program factory. The callback
+receives the item and its input index, and the returned Program produces a
+readonly collection in input order:
+
+```ts
+const synchronized = Program.forEach(userIds, (userId, index) => synchronizeUser(userId, index), {
+  concurrency: 8
+})
+
+const result = await runtime.run(synchronized)
+```
+
+Use `Program.allResults` when typed validation errors should be retained rather
+than short-circuiting. It returns every exact child `Result` as a successful
+collection element; defects still stop new work and reject the outer Program:
+
+```ts
+const validations = Program.allResults(
+  [validateIdentity, validateAddress, validateDocuments] as const,
+  { concurrency: 3 }
+)
+
+const results = await runtime.run(validations)
+```
+
+Both helpers use the same lazy bounded scheduler as `Program.all`: indexes are
+claimed in order, output order is stable, and already-started work is always
+allowed to settle.
+
+Use `Effect.*` to transform an already-created Result, and `Program.*` to compose
+an `Effect.fn` Program without starting it. `Program.map`, `mapError`, `tap`, and
+`tapError` preserve that laziness; `andThen` and `recover` accept an Effect, a
+Promise of an Effect, or another Program only after their matching Result branch
+is selected. `Program.andThen` unions its source and continuation error and
+Service requirement channels. `Program.recover` handles and removes the source
+`Err` channel, exposes the recovery error channel, and unions the source and
+recovery Service requirements. Taps preserve the original Result object on
+success.
+
 `Runtime.make(AppLive)` and `Runtime.run(AppLive, program)` use the built-in
 `MapLayerBackend`. Pass `{ backend: new ItiLayerBackend() }` when an external
 container is needed; `MemoryLayerBackend` remains its compatibility alias from
 `better-effect/testing`.
 
+### Verify custom adapters
+
+`better-effect/testing` provides runner-neutral conformance scenarios for
+third-party `LayerBackend` and `RuntimeContextStorage` implementations. Each
+scenario has a stable `name` and `run` callback, creates a fresh adapter, and
+runs the optional adapter cleanup after every assertion outcome. Backends must
+synchronously pass the actual readonly pending acquisition Promise collection to
+`disposeAll`'s `onPendingAcquisitions` hook, await the callback, then await the
+acquisitions before clearing state. Declare the backend's acquisition-failure
+policy explicitly: `MapLayerBackend` retries,
+while ITI keeps an asynchronous failure cached until disposal.
+
+Register the scenarios with Bun:
+
+```ts
+import { describe, test } from 'bun:test'
+import { MapLayerBackend } from 'better-effect'
+import { layerBackendContract } from 'better-effect/testing'
+
+describe('My backend', () => {
+  for (const scenario of layerBackendContract({
+    makeBackend: () => new MapLayerBackend(),
+    acquisitionFailure: 'retry'
+  })) {
+    test(scenario.name, scenario.run)
+  }
+})
+```
+
+The same scenarios work with Vitest without adding a runner dependency to the
+published entrypoint:
+
+```ts
+import { describe, it } from 'vitest'
+import { NodeRuntimeContextStorage } from 'better-effect/runtime/node'
+import { runtimeContextStorageContract } from 'better-effect/testing'
+
+describe('My context storage', () => {
+  for (const scenario of runtimeContextStorageContract({
+    makeStorage: () => new NodeRuntimeContextStorage(),
+    concurrency: 'concurrent'
+  })) {
+    it(scenario.name, scenario.run)
+  }
+})
+```
+
+Use `concurrency: 'sequential'` for a storage that rejects overlapping roots
+with `RuntimeContextOverlapError`; pass `makeCompanionStorage` to also verify
+that it does not leak frames into a Node or explicit storage. See the adapter
+guide for the complete `LayerBackend` contract.
+
 Runtimes are async disposables, so request-scoped code can use:
 
 ```ts
@@ -146,6 +271,42 @@ Or let `Runtime.use` own the lifetime:
 const result = await Runtime.use(AppLive, (runtime) => runtime.run(program))
 ```
 
+For isolated application tests, use the testing facade over that same Layer and
+Runtime. It installs only the controlled Services you pass, records lifecycle
+events, and disposes automatically:
+
+```ts
+import { ClockTest, LoggerTest, TestRuntime } from 'better-effect/testing'
+
+const logger = new LoggerTest()
+const result = await TestRuntime.use(
+  AppLive,
+  {
+    overrides: [DatabaseTest],
+    clock: new ClockTest(Date.UTC(2026, 0, 1)),
+    logger
+  },
+  async (test) => {
+    const value = await test.run(loadDashboard)
+    expect(test.observer.executionEnds).toHaveLength(1)
+    return value
+  }
+)
+
+expect(logger.events).toHaveLength(1)
+```
+
+A long-lived test boundary supports integration-style request Layers as well:
+
+```ts
+await using test = await TestRuntime.make(AppLive, { overrides: [DatabaseTest] })
+const result = await test.runWith(RequestLive, handleRequest)
+```
+
+`TestRuntime.use` preserves program-vs-cleanup failure precedence. The default
+recorder is available as `test.observer`; use `test.runtime` only when an
+advanced test explicitly needs the underlying Runtime.
+
 Layer providers remain lazy unless startup validation is requested. Warm them
 all before accepting work with either form:
 
@@ -176,6 +337,34 @@ const runtime = await Runtime.make(AppLive, {
 })
 ```
 
+For lifecycle assertions, `better-effect/testing` provides a recorder and a
+best-effort composition utility:
+
+```ts
+import { RecordedRuntimeObserver, RuntimeObserver } from 'better-effect/testing'
+
+const recorded = RecordedRuntimeObserver.make()
+const runtime = await Runtime.make(AppTest, {
+  observers: [
+    RuntimeObserver.compose(recorded, {
+      onExecutionEnd: ({ outcome }) => console.debug(outcome.status)
+    })
+  ]
+})
+
+await runtime.run(program)
+const snapshot = recorded.snapshot()
+expect(snapshot.executionEnds).toHaveLength(1)
+expect(snapshot.timeline).toContain(snapshot.executionEnds[0])
+
+await runtime.dispose()
+```
+
+`RecordedRuntimeObserver` preserves event identity in immutable category views
+and its ordered `timeline`; call `clear()` to reuse it. Composition invokes
+observers in declaration order and isolates thrown or rejected observer
+failures from the Runtime result.
+
 Cancellation is cooperative and uses `AbortSignal`; no scheduler or fibers are
 created. Pass a signal to one execution and read it from the program when an
 I/O operation supports cancellation. Runtime disposal waits for active work;
@@ -229,9 +418,9 @@ app.get(
 )
 ```
 
-Hono validators can precede the generator or handler callback. Their validated
-`c.req.valid(...)` inputs are combined and inferred without a manual `Input`
-helper:
+One or more Hono validators can precede the generator or handler callback, in
+the order they should run. Their validated `c.req.valid(...)` inputs are
+combined and inferred without a manual `Input` helper:
 
 ```ts
 import { sValidator } from '@hono/standard-validator'
@@ -408,7 +597,9 @@ Some dependencies are values.
 
 Others own connections, sessions, files or other resources.
 
-`Layer.scoped`, `Layer.scopedGen`, `Effect.acquireRelease`, `Effect.add` and `Scope` make their lifetime explicit.
+`Layer.scoped`, `Layer.scopedGen`, `Layer.scopedDisposable`, `Effect.acquireRelease`,
+`Effect.acquireReleaseResult`, `Effect.acquireDisposable`, `Effect.add` and `Scope` make their
+lifetime explicit.
 
 ```ts
 const DatabaseLive = Layer.scoped(
@@ -422,6 +613,35 @@ Runtime owns the application lifetime and safely releases scoped resources when
 
 Resources acquired during an individual execution belong to that execution instead.
 
+When an existing API already returns a `Result`, keep its typed failure channel while
+registering only successful acquisitions:
+
+```ts
+const connection =
+  yield *
+  Effect.acquireReleaseResult(
+    () => pool.connect(),
+    (connection, outcome) => connection.close(outcome)
+  )
+```
+
+An `Err` is returned unchanged and is never released. Thrown or rejected acquisition
+defects use the normal `UnhandledException` channel; release failures remain Scope
+cleanup failures rather than widening the acquisition error type.
+
+For values that implement JavaScript disposal, use the disposable helpers instead of
+repeating a release callback. Async disposal is preferred when both protocols exist:
+
+```ts
+const file = yield * Effect.acquireDisposable(() => openFile(path))
+
+const DatabaseLive = Layer.scopedDisposable(Database, () => Database.connect())
+```
+
+`Effect.acquireDisposable` belongs to the current execution Scope. `Layer.scopedDisposable`
+keeps the client alive across executions and disposes it with the Runtime root; the DI
+backend never owns that release.
+
 ### Keep your runtime choices
 
 `better-effect` is not a replacement implementation of Effect.
@@ -572,7 +792,26 @@ still rejects it when its Layer does not provide every required Service.
 
 Observation helpers such as `Effect.tap`, `Effect.tapError`, and `Effect.tapBoth`
 run only the active branch and return the original Result, so logging or metrics
-do not change the pipeline's value or requirement channel.
+do not change the pipeline's value or requirement channel. The async variants
+`Effect.tapAsync`, `Effect.tapErrorAsync`, and `Effect.tapBothAsync` accept
+`PromiseLike<void>` observers, always return a Promise, and preserve the source
+requirements. They delegate branch selection and defect handling to
+`better-result`; only the active observer runs, and a successful observation
+returns the exact original Result. They do not create a Scope or resolve
+Services inside the callback.
+
+```ts
+const audited = pipe(
+  loadUser(userId),
+  Effect.tapAsync((user) => metrics.recordUserLoaded(user.id)),
+  Effect.tapErrorAsync((error) => metrics.recordUserFailure(error))
+)
+```
+
+`Effect.matchError` exhaustively maps a tagged `Err` union, while
+`Effect.matchErrorPartial` maps selected tags and retains unhandled variants in
+the resulting error union. Both delegate to `better-result`'s tagged-error
+matchers and preserve the source success and requirement channels.
 
 Use `Effect.recover` or `Effect.recoverAsync` for an explicit fallback Result;
 the fallback is evaluated only when the input is an `Err`, and its Service

package/dist/adapters/iti.d.mts

@@ -1,6 +1,5 @@
-import { N as AnyServiceToken } from "../index-CULgSzUw.mjs";
-import "../index-C7KX5rAP.mjs";
-import { a as LayerRegistration, n as LayerBackend } from "../map-layer-backend-rNwfH0Bz.mjs";
+import { N as AnyServiceToken } from "../index-heuaRmXR.mjs";
+import { v as LayerBackend, x as LayerRegistration, y as LayerBackendDisposeOptions } from "../index-rQhZk3Nt.mjs";
 //#region src/adapters/iti.d.ts
 /**
  * ITI-backed Layer backend.
@@ -24,7 +23,7 @@ declare class ItiLayerBackend implements LayerBackend {
   /** Resolve a registered Service through the ITI container. */
   resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>>;
   /** Reset container-owned ITI state; Scope owns Layer provider releases. */
-  disposeAll(): Promise<void>;
+  disposeAll(options?: LayerBackendDisposeOptions): Promise<void>;
 }
 //#endregion
 export { ItiLayerBackend };

package/dist/adapters/iti.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;;;;;;;;;cAsBa,2BAA2B;UAC9B;mBAES;mBAEA;;;;;;mBAOA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAiCnF,cAAc"}
+{"version":3,"file":"iti.d.mts","names":[],"sources":["../../src/adapters/iti.ts"],"mappings":";;;;;;;;;cAuBa,2BAA2B;UAC9B;mBAES;mBAEA;;;;;;mBAOA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAiCnF,WAAW,UAAU,6BAA6B"}

package/dist/adapters/iti.mjs

@@ -18,7 +18,7 @@ var ItiLayerBackend = class {
 	* ITI caches rejected acquisitions; replacing the container is the explicit
 	* retry boundary for that sticky failure behavior.
 	*/
-	pending = /* @__PURE__ */ new Set();
+	pending = /* @__PURE__ */ new Map();
 	keyFor(token) {
 		const tag = token.serviceTag;
 		const existing = this.keys.get(tag);
@@ -50,17 +50,22 @@ var ItiLayerBackend = class {
 		};
 		if (isPromiseLike(resolved)) {
 			const pending = Promise.resolve(resolved).then(validate);
-			this.pending.add(pending);
+			this.pending.set(pending, registered);
 			pending.then(() => this.pending.delete(pending), () => this.pending.delete(pending));
 			return pending;
 		}
 		return validate(resolved);
 	}
 	/** Reset container-owned ITI state; Scope owns Layer provider releases. */
-	async disposeAll() {
+	async disposeAll(options) {
 		const container = this.container;
+		const acquisitions = [...this.pending.keys()];
 		try {
-			await Promise.allSettled(this.pending);
+			if (acquisitions.length > 0) {
+				const observePending = options?.onPendingAcquisitions;
+				if (observePending) await observePending(acquisitions);
+				await Promise.allSettled(acquisitions);
+			}
 			await container.disposeAll();
 		} finally {
 			this.container = createContainer();

package/dist/adapters/iti.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\nimport { isPromiseLike } from '../utils/runtime'\n\ntype LayerAcquiredValue = Awaited<ReturnType<LayerRegistration['acquire']>>\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  /**\n   * Track async gets so disposal cannot reset ITI while a provider is acquiring.\n   * ITI caches rejected acquisitions; replacing the container is the explicit\n   * retry boundary for that sticky failure behavior.\n   */\n  private readonly pending = new Set<Promise<unknown>>()\n\n  private keyFor(token: AnyServiceToken): string {\n    const tag = token.serviceTag\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const token = registration.service\n    const tag = token.serviceTag\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: registration.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    const registered = this.registered.get(token.serviceTag)\n\n    if (registered === undefined) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n    const resolved = this.container.get(key)\n\n    const validate = (instance: LayerAcquiredValue): InstanceType<T> => {\n      assertServiceCompatibility(token, registered, instance)\n\n      // SAFETY: The registered tag and compatibility check establish the constructor-to-instance relationship after ITI erases it.\n      return instance as InstanceType<T>\n    }\n\n    if (isPromiseLike(resolved)) {\n      const pending = Promise.resolve(resolved).then(validate)\n\n      this.pending.add(pending)\n      void pending.then(\n        () => this.pending.delete(pending),\n        () => this.pending.delete(pending)\n      )\n\n      return pending\n    }\n\n    return validate(resolved)\n  }\n\n  /** Reset container-owned ITI state; Scope owns Layer provider releases. */\n  async disposeAll(): Promise<void> {\n    const container = this.container\n\n    try {\n      await Promise.allSettled(this.pending)\n      await container.disposeAll()\n    } finally {\n      this.container = createContainer()\n      this.registered.clear()\n      this.keys.clear()\n      this.pending.clear()\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAsBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;;;;;;CAO/D,0BAA2B,IAAI,IAAsB;CAErD,OAAe,OAAgC;EAC7C,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,QAAQ,aAAa;EAC3B,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,aAAa,QACtB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,MAAM,aAAa,KAAK,WAAW,IAAI,MAAM,UAAU;EAEvD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAC7B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAkD;GAClE,2BAA2B,OAAO,YAAY,QAAQ;GAGtD,OAAO;EACT;EAEA,IAAI,cAAc,QAAQ,GAAG;GAC3B,MAAM,UAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;GAEvD,KAAK,QAAQ,IAAI,OAAO;GACxB,QAAa,WACL,KAAK,QAAQ,OAAO,OAAO,SAC3B,KAAK,QAAQ,OAAO,OAAO,CACnC;GAEA,OAAO;EACT;EAEA,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,aAA4B;EAChC,MAAM,YAAY,KAAK;EAEvB,IAAI;GACF,MAAM,QAAQ,WAAW,KAAK,OAAO;GACrC,MAAM,UAAU,WAAW;EAC7B,UAAU;GACR,KAAK,YAAY,gBAAgB;GACjC,KAAK,WAAW,MAAM;GACtB,KAAK,KAAK,MAAM;GAChB,KAAK,QAAQ,MAAM;EACrB;CACF;AACF"}
+{"version":3,"file":"iti.mjs","names":[],"sources":["../../src/adapters/iti.ts"],"sourcesContent":["import { createContainer } from 'iti'\n\nimport {\n  DuplicateServiceError,\n  ServiceTagCollisionError,\n  type LayerBackend,\n  type LayerBackendDisposeOptions,\n  type LayerRegistration\n} from '../layer'\n\nimport { ServiceNotFoundError, type AnyServiceToken } from '../service'\n\nimport { assertServiceCompatibility } from '../layer/internal-identity'\nimport { isPromiseLike } from '../utils/runtime'\n\ntype LayerAcquiredValue = Awaited<ReturnType<LayerRegistration['acquire']>>\n\n/**\n * ITI-backed Layer backend.\n *\n * Install `iti` as the optional peer dependency and pass an instance to\n * `Runtime.make` when using ITI's container implementation.\n */\nexport class ItiLayerBackend implements LayerBackend {\n  private container: any = createContainer()\n\n  private readonly keys = new Map<string, string>()\n\n  private readonly registered = new Map<string, AnyServiceToken>()\n\n  /**\n   * Track async gets so disposal cannot reset ITI while a provider is acquiring.\n   * ITI caches rejected acquisitions; replacing the container is the explicit\n   * retry boundary for that sticky failure behavior.\n   */\n  private readonly pending = new Map<Promise<unknown>, AnyServiceToken>()\n\n  private keyFor(token: AnyServiceToken): string {\n    const tag = token.serviceTag\n    const existing = this.keys.get(tag)\n\n    if (existing) {\n      return existing\n    }\n\n    const key = `better-effect:${tag}`\n\n    this.keys.set(tag, key)\n\n    return key\n  }\n\n  /** Register a Layer provider under its deterministic Service-tag key. */\n  register(registration: LayerRegistration): void {\n    const token = registration.service\n    const tag = token.serviceTag\n    const existing = this.registered.get(tag)\n\n    if (existing === token) {\n      throw new DuplicateServiceError(token)\n    }\n\n    if (existing) {\n      throw new ServiceTagCollisionError(existing, token)\n    }\n\n    const key = this.keyFor(token)\n\n    this.container = this.container.add({\n      [key]: registration.acquire\n    })\n\n    this.registered.set(tag, token)\n  }\n\n  /** Resolve a registered Service through the ITI container. */\n  resolve<T extends AnyServiceToken>(token: T): InstanceType<T> | PromiseLike<InstanceType<T>> {\n    const registered = this.registered.get(token.serviceTag)\n\n    if (registered === undefined) {\n      throw new ServiceNotFoundError(token)\n    }\n\n    const key = this.keyFor(token)\n    const resolved = this.container.get(key)\n\n    const validate = (instance: LayerAcquiredValue): InstanceType<T> => {\n      assertServiceCompatibility(token, registered, instance)\n\n      // SAFETY: The registered tag and compatibility check establish the constructor-to-instance relationship after ITI erases it.\n      return instance as InstanceType<T>\n    }\n\n    if (isPromiseLike(resolved)) {\n      const pending = Promise.resolve(resolved).then(validate)\n\n      this.pending.set(pending, registered)\n      void pending.then(\n        () => this.pending.delete(pending),\n        () => this.pending.delete(pending)\n      )\n\n      return pending\n    }\n\n    return validate(resolved)\n  }\n\n  /** Reset container-owned ITI state; Scope owns Layer provider releases. */\n  async disposeAll(options?: LayerBackendDisposeOptions): Promise<void> {\n    const container = this.container\n    const acquisitions = [...this.pending.keys()]\n\n    try {\n      if (acquisitions.length > 0) {\n        const observePending = options?.onPendingAcquisitions\n\n        if (observePending) {\n          await observePending(acquisitions)\n        }\n\n        await Promise.allSettled(acquisitions)\n      }\n      await container.disposeAll()\n    } finally {\n      this.container = createContainer()\n      this.registered.clear()\n      this.keys.clear()\n      this.pending.clear()\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAuBA,IAAa,kBAAb,MAAqD;CACnD,YAAyB,gBAAgB;CAEzC,uBAAwB,IAAI,IAAoB;CAEhD,6BAA8B,IAAI,IAA6B;;;;;;CAO/D,0BAA2B,IAAI,IAAuC;CAEtE,OAAe,OAAgC;EAC7C,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,KAAK,IAAI,GAAG;EAElC,IAAI,UACF,OAAO;EAGT,MAAM,MAAM,iBAAiB;EAE7B,KAAK,KAAK,IAAI,KAAK,GAAG;EAEtB,OAAO;CACT;;CAGA,SAAS,cAAuC;EAC9C,MAAM,QAAQ,aAAa;EAC3B,MAAM,MAAM,MAAM;EAClB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG;EAExC,IAAI,aAAa,OACf,MAAM,IAAI,sBAAsB,KAAK;EAGvC,IAAI,UACF,MAAM,IAAI,yBAAyB,UAAU,KAAK;EAGpD,MAAM,MAAM,KAAK,OAAO,KAAK;EAE7B,KAAK,YAAY,KAAK,UAAU,IAAI,GACjC,MAAM,aAAa,QACtB,CAAC;EAED,KAAK,WAAW,IAAI,KAAK,KAAK;CAChC;;CAGA,QAAmC,OAA0D;EAC3F,MAAM,aAAa,KAAK,WAAW,IAAI,MAAM,UAAU;EAEvD,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,qBAAqB,KAAK;EAGtC,MAAM,MAAM,KAAK,OAAO,KAAK;EAC7B,MAAM,WAAW,KAAK,UAAU,IAAI,GAAG;EAEvC,MAAM,YAAY,aAAkD;GAClE,2BAA2B,OAAO,YAAY,QAAQ;GAGtD,OAAO;EACT;EAEA,IAAI,cAAc,QAAQ,GAAG;GAC3B,MAAM,UAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KAAK,QAAQ;GAEvD,KAAK,QAAQ,IAAI,SAAS,UAAU;GACpC,QAAa,WACL,KAAK,QAAQ,OAAO,OAAO,SAC3B,KAAK,QAAQ,OAAO,OAAO,CACnC;GAEA,OAAO;EACT;EAEA,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAM,WAAW,SAAqD;EACpE,MAAM,YAAY,KAAK;EACvB,MAAM,eAAe,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC;EAE5C,IAAI;GACF,IAAI,aAAa,SAAS,GAAG;IAC3B,MAAM,iBAAiB,SAAS;IAEhC,IAAI,gBACF,MAAM,eAAe,YAAY;IAGnC,MAAM,QAAQ,WAAW,YAAY;GACvC;GACA,MAAM,UAAU,WAAW;EAC7B,UAAU;GACR,KAAK,YAAY,gBAAgB;GACjC,KAAK,WAAW,MAAM;GACtB,KAAK,KAAK,MAAM;GAChB,KAAK,QAAQ,MAAM;EACrB;CACF;AACF"}