better-effect 0.13.0 → 0.14.0

package/README.md

@@ -11,8 +11,8 @@ bun add better-effect better-result
 ```
 
 The published Runtime entrypoint is officially supported on Node.js and Bun.
-The tested runtime matrix is Node.js 24 and Bun 1.3.14, and the default runtime
-context uses Node/Bun async context propagation. `bun run check` also deletes
+The repository uses the latest Bun release by default and the current Node.js
+LTS for interoperability smoke tests. `bun run check` also deletes
 and rebuilds `dist`, packs the result into a temporary consumer, and runs the
 full Node/Bun `NodeRuntime` child-process suite.
 
@@ -149,6 +149,61 @@ const inspectDatabase = Effect.fn(async function* () {
 await runtime.run(inspectDatabase)
 ```
 
+Integration authors that need to trigger work later can capture the Runtime's
+non-owning executor capability from an execution or Layer acquisition:
+
+```ts
+const captureExecutor = Effect.fn(async function* () {
+  const executor = yield* Runtime.executor<Database>()
+  return Result.ok(executor)
+})
+
+const executor = (await runtime.run(captureExecutor)).unwrap()
+await executor.run(inspectDatabase)
+```
+
+`Runtime.Executor<R>` exposes `run`, `runWith`, and the opt-in
+`runWithManaged` capability. The first two start a child execution and resolve
+after its Scope closes; `runWithManaged` additionally separates readiness from
+completion for boundaries such as `WebEffect.streamWith`, while keeping the
+same request-local Services and Scope active until completion. The executor
+does not expose `dispose`, `warmup`, `inspect`, backend or Scope ownership.
+Applications normally use `runtime.run`; the contextual executor is mainly for
+framework adapters and long-lived components.
+
+For work that must live only as long as the current execution or lifecycle
+Scope, use `Effect.forkScoped`. It returns immediately with a small task handle;
+the task inherits the current Services and resolver, receives its own
+cooperative-cancellation signal, and is interrupted and awaited before the
+parent Scope releases its resources:
+
+```ts
+const pollOutbox = Effect.fn(async function* () {
+  const signal = yield* CurrentAbortSignal
+
+  while (!signal.aborted) {
+    await pollOnce()
+  }
+
+  return Result.ok(undefined)
+})
+
+const OutboxLive = Layer.effectDiscard(
+  Effect.fn(async function* () {
+    const task = yield* Effect.forkScoped(pollOutbox)
+    await task.awaitExit()
+
+    return Result.ok(undefined)
+  })
+)
+```
+
+Use `task.await()` when the child Result should be returned or its defect should
+be thrown. Use `task.awaitExit()` when interruption and defects must be
+inspected without throwing. `Runtime.inspect()` reports active scoped tasks,
+and Runtime observers receive task start/end events linked to their parent
+execution; scoped tasks do not create independent Runtime executions.
+
 Runtime boundaries inspect only nominal `better-result` values: `Result.err`
 becomes a failed execution, while a plain object with `status: 'error'` is
 still a successful value. Intermediate Results do not close the execution
@@ -393,11 +448,12 @@ resolves Services, warms the Runtime, creates Scopes, invokes observers or
 exposes providers, instances, signals, attributes or backend state. Execution
 entries remain present until their execution Scope cleanup settles. Warmup is
 reported as `idle`, `running`, `completed` or `failed`, and `state` reports
-`active`, `disposing` or `disposed`.
+`active`, `quiescing`, `draining`, `aborting`, `releasing` or `disposed`.
 
 `inspect()` is diagnostic information, not a lock, synchronization primitive or
 readiness guarantee. It cannot cancel or force shutdown of any execution; use
 `dispose()` and cooperative `AbortSignal` handling for lifecycle coordination.
+New executions are rejected as soon as quiescing begins.
 
 Missing, circular, and provider-construction failures use the logical Service
 tags in `ServiceNotFoundError`, `CircularDependencyError`, and
@@ -463,6 +519,8 @@ const observer = OpenTelemetryRuntimeObserver.make({
   // An existing provider can be passed instead with `provider` and `tracerName`.
   tracer: trace.getTracer('acme.application'),
   serviceResolution: 'events',
+  lifecycle: 'events',
+  shutdown: 'events',
   recordFailures: true,
   executionAttributeAllowlist: ['requestId'],
   sanitizeFailure: (cause) =>
@@ -472,6 +530,11 @@ const observer = OpenTelemetryRuntimeObserver.make({
 const runtime = await Runtime.make(AppLive, { observers: [observer] })
 ```
 
+The same observer can be passed to `NodeRuntime.runMain` or
+`NodeRuntime.launch`. Executions started through `runtime.executor.run` and
+`runtime.executor.runWith` use the same execution pipeline and produce one
+execution span each; capturing an executor never creates a separate span.
+
 The adapter starts one span for each execution, keyed only by the Runtime's
 `executionId`. The Program name is the span name, with
 `better-effect.execution` as the stable fallback. Executions whose program and
@@ -501,6 +564,27 @@ isolated from every Runtime result. Call `observer.dispose()` when an observer
 may outlive its Runtime to end state left by malformed or missing end events;
 normal execution spans are ended exactly once by their matching `executionId`.
 
+Lifecycle and shutdown telemetry are also explicit and default to `off`:
+
+- `lifecycle: 'events'` records activation and release on one
+  `better-effect.lifecycle` span; `lifecycle: 'spans'` creates phase spans
+  named `better-effect.lifecycle.activate` and
+  `better-effect.lifecycle.release`.
+- The public Runtime observer currently exposes lifecycle activation and
+  release, but not a per-entry quiesce callback. The adapter does not invent a
+  quiesce event; Runtime shutdown quiesce phases remain available through
+  `onShutdown`.
+- `shutdown: 'events'` records the public shutdown phases as events on one
+  root `better-effect.shutdown` span. `shutdown: 'spans'` keeps that root span
+  and adds bounded phase spans for quiesce, drain, abort and release.
+- Shutdown spans use an explicit root parent, never an arbitrary active
+  execution span. Shutdown failure marks the root span as `ERROR`; failure
+  details are recorded only when `recordFailures: true` and `sanitizeFailure`
+  returns them.
+
+All lifecycle and shutdown metadata is bounded and excludes resource
+instances, server handles, configuration, payloads and raw causes.
+
 Telemetry is privacy-preserving by default. The adapter records only bounded
 library, execution ID, Program/outcome, Service-tag and resolution-path data.
 It does not record causes, stacks, requests, arbitrary execution attributes or
@@ -554,9 +638,9 @@ const cancellableProgram = Effect.fn(async function* () {
 ```
 
 For a Node.js or Bun CLI, use the host-specific `better-effect/node` entrypoint.
-`NodeRuntime.runMain` validates its signal and callback options before installing
-`SIGINT`/`SIGTERM` listeners, links the first signal to `CurrentAbortSignal`,
-and disposes the Runtime exactly once:
+`NodeRuntime.runMain` validates its signal, callback and shutdown options before
+installing `SIGINT`/`SIGTERM` listeners, links the first signal to
+`CurrentAbortSignal`, and disposes the Runtime exactly once:
 
 ```ts
 import { NodeRuntime } from 'better-effect/node'
@@ -571,7 +655,11 @@ await NodeRuntime.runMain(AppLive, main, {
     console.error(error)
     return 1
   },
-  onSuccess: () => 0
+  onSuccess: () => 0,
+  shutdown: {
+    gracePeriod: 10_000,
+    abortAfterGracePeriod: true
+  }
 })
 ```
 
@@ -579,11 +667,21 @@ await NodeRuntime.runMain(AppLive, main, {
 remain rejected and may be reported with `onDefect`. Cleanup-only failures use
 `onCleanupFailure`, remain observable, and still set a non-zero
 `process.exitCode` after successful work. The first `SIGINT` or `SIGTERM`
-immediately aborts `CurrentAbortSignal`; Runtime disposal then waits
-cooperatively for the main execution. Listeners are removed in `finally`,
-repeated signals are ignored, and the helper never calls `process.exit()`.
-The Node boundary intentionally does not expose a second grace-period policy;
-use `Runtime.dispose` directly when a managed Runtime needs one.
+immediately aborts `CurrentAbortSignal`; Runtime disposal then quiesces root
+resources and applies the configured drain policy. Listeners are removed in
+`finally`, repeated signals are ignored, and the helper never calls
+`process.exit()`.
+
+For long-lived applications whose startup and shutdown are completely
+represented by a Layer graph, `NodeRuntime.launch` owns the Runtime and waits
+for a process signal or caller `AbortSignal`:
+
+```ts
+await NodeRuntime.launch(AppLive, {
+  warmup: true,
+  shutdown: { gracePeriod: 10_000, abortAfterGracePeriod: true }
+})
+```
 
 For request-local context or overrides, add a Layer only to that execution:
 
@@ -609,8 +707,8 @@ import { CurrentRequest } from 'better-effect/standard-services'
 import { WebEffect } from 'better-effect/web'
 
 const handleRequest = (request: Request) =>
-  WebEffect.handle(
-    runtime,
+  WebEffect.handleWith(
+    runtime.executor,
     request,
     Effect.fn(async function* () {
       const currentRequest = yield* CurrentRequest
@@ -627,7 +725,7 @@ const handleRequest = (request: Request) =>
   )
 ```
 
-`WebEffect.handle` supplies `CurrentRequest`, forwards `request.signal`, and
+`WebEffect.handleWith` supplies `CurrentRequest`, forwards `request.signal`, and
 runs one lazy Program in a child Scope. Request-local resources are released
 before the returned Promise resolves; Runtime-root resources remain owned by
 the Runtime. A `requestLayer` option can add per-request providers or
@@ -670,6 +768,35 @@ rejected. The Program's Service and failure channels, request-Layer
 requirements, and override compatibility are checked at the TypeScript
 boundary.
 
+For a response whose body is still produced by request-scoped work, opt in to
+the managed streaming boundary with an explicit descriptor. The descriptor's
+metadata is committed immediately, while its lazy producer is pulled with
+backpressure in the same execution context:
+
+```ts
+const response = await WebEffect.streamWith(
+  runtime.executor,
+  request,
+  Effect.fn(async function* () {
+    const file = yield* FileService
+
+    return Result.ok<WebEffect.Stream>({
+      status: 200,
+      headers: { 'content-type': 'application/octet-stream' },
+      producer: async function* ({ signal }) {
+        yield* file.bytes({ signal })
+      }
+    })
+  }),
+  { unconsumedTimeoutMs: 30_000 }
+)
+```
+
+`WebEffect.streamWith` retains the request execution until EOF, downstream
+cancel/error, request abort, timeout, or Runtime shutdown. It accepts only the
+explicit descriptor—not an arbitrary `Response`—and never maps failures to a
+new status after headers have been committed.
+
 ### Next.js App Router request boundaries
 
 The optional `better-effect/next` entrypoint adapts an application-owned
@@ -678,7 +805,7 @@ from the core or main entrypoint:
 
 ```ts
 import { Result } from 'better-result'
-import { Effect, Layer, Runtime, Service } from 'better-effect'
+import { Effect, Layer, Service } from 'better-effect'
 import { NextEffect } from 'better-effect/next'
 
 class UserService extends Service<UserService>()('UserService') {
@@ -687,8 +814,7 @@ class UserService extends Service<UserService>()('UserService') {
   }
 }
 
-const runtime = await Runtime.make(Layer.make(UserService))
-const http = NextEffect.make(runtime)
+const http = NextEffect.managed(Layer.make(UserService))
 
 export const GET = http.gen(async function* (_request, context: RouteContext<'/api/users/[id]'>) {
   const { id } = await context.params
@@ -698,46 +824,67 @@ export const GET = http.gen(async function* (_request, context: RouteContext<'/a
 })
 ```
 
-`NextEffect.gen` and `NextEffect.handler` return the native
+Managed builders' `gen` and `handler` methods return the native
 `(request, context) => Promise<Response>` shape expected by App Router route
 files. The context is typed with Next's asynchronous `params`; `handler` is
 useful when the complete `Effect.fn` Program already exists.
 
-For a long-lived App Router application, keep the Runtime in an
-application-owned module and expose explicit disposal for the host lifecycle:
+`managed` is lazy and host-owned: each manager creates at most one Runtime,
+shares concurrent first-request initialization, and keeps root Layer resources
+until explicit disposal. It never installs process signal handlers or creates a
+Runtime per request:
 
 ```ts
 // app/runtime.ts
-export const appRuntime = await Runtime.make(AppLive)
+export const appNext = NextEffect.managed(AppLive, {
+  runtime: { warmup: true }
+})
 
 // Call this from the actual host/server shutdown hook.
-export const disposeAppRuntime = (): Promise<void> => appRuntime.dispose()
+export const initializeApp = (): Promise<void> => appNext.initialize()
+export const disposeApp = (): Promise<void> => appNext.dispose()
 ```
 
-Route modules import that Runtime and bind it to the adapter:
+Route modules import the manager directly:
 
 ```ts
 // app/api/users/[id]/route.ts
-import { appRuntime } from '@/app/runtime'
+import { appNext } from '@/app/runtime'
 
-const http = NextEffect.make(appRuntime)
+export const GET = appNext.gen(async function* (
+  _request,
+  context: RouteContext<'/api/users/[id]'>
+) {
+  const { id } = await context.params
+  const users = yield* UserService
+
+  return Result.ok(users.find(id))
+})
 ```
 
-Do not put this long-lived Runtime in an `await using` scope that ends during
-module initialization; that would dispose it before exported handlers serve
-requests. `NextEffect.make` stores only the Runtime supplied by the caller: it
-does not create a process-global singleton or mutate hidden adapter state.
-Sharing `appRuntime` is an application ownership choice. If a deployment
-requires per-invocation ownership instead, use the existing `Runtime.use`
-helper explicitly; the adapter never creates a Runtime per request by default:
+For code already being built inside a better-effect Runtime, use the inert
+`fromCurrent` builder. Its `handler` and `gen` operations are yieldable, so
+route requirements become requirements of the surrounding Program:
 
 ```ts
-export const GET = (request, context) =>
-  Runtime.use(AppLive, (runtime) =>
-    NextEffect.make(runtime).handler(() => getUser(context))(request, context)
-  )
+const next = NextEffect.fromCurrent()
+
+const makeRoutes = Effect.fn(async function* () {
+  const GET = yield* next.gen(async function* (_request, context) {
+    const { id } = await context.params
+    const users = yield* UserService
+    return Result.ok(users.find(id))
+  })
+
+  return Result.ok(GET)
+})
 ```
 
+`fromCurrent` does not create or own a Runtime and fails explicitly outside an
+active Runtime execution. `managed` is the App Router/module-scope mode. The
+adapter does not promise automatic HMR cleanup, Edge-runtime compatibility, or
+ownership of workers and other ingress resources in the supplied Layer.
+
 Each request creates one WebEffect execution and child Scope, installs
 `CurrentRequest` and `CurrentAbortSignal`, and releases request-local Layers
 before the handler Promise resolves. The request's
@@ -769,14 +916,18 @@ usable without Next.js.
 
 ### Bun.serve fetch adapter
 
-The optional `better-effect/bun` entrypoint is a small Bun-only adapter over
-`WebEffect`. It does not create a Runtime, own a Bun server, install a router,
-or make the Bun server an implicit Service. The route factory receives Bun's
-`Request` and `Bun.Server` values explicitly:
+For Bun applications, `better-effect/bun` is Layer-first. `BunEffect.handler`
+is a yieldable operation: it captures the active `Runtime.Executor` while its
+enclosing Layer is acquired, then uses that executor for each request.
+
+`BunEffect.server` owns one native `Bun.serve` instance in its `.layer`. The
+server is quiesced during Runtime shutdown, active executions are drained, and
+the same server stop Promise is awaited during release. There is no parallel
+Runtime or import-time server startup:
 
 ```ts
 import { Result } from 'better-result'
-import { CurrentAbortSignal, Effect, Layer, Runtime, Service } from 'better-effect'
+import { CurrentAbortSignal, Effect, Layer, Runtime, Service, ServiceRuntime } from 'better-effect'
 import { CurrentRequest } from 'better-effect/standard-services'
 import { BunEffect } from 'better-effect/bun'
 
@@ -786,50 +937,54 @@ class AppService extends Service<AppService>()('AppService') {
   }
 }
 
-const AppLive = Layer.make(AppService)
-const runtime = await Runtime.make(AppLive)
-const http = BunEffect.make(runtime, {
-  onFailure: (_error, request) =>
-    Response.json({ error: 'Request failed', url: request.url }, { status: 500 })
-})
-
-const server = Bun.serve({
-  port: 3000,
-  fetch: http.handler((request, server) =>
-    Effect.fn(async function* () {
-      const app = yield* AppService
-      const currentRequest = yield* CurrentRequest
-      const signal = yield* CurrentAbortSignal
-
-      return Result.ok({
-        value: app.handle(request.url),
-        currentUrl: (currentRequest.request as Request).url,
-        port: server.port,
-        aborted: signal.aborted
+const ApiServer = BunEffect.server('@app/ApiServer', async function* () {
+  const fetch = yield* BunEffect.handler(
+    {
+      onFailure: (_error, request) =>
+        Response.json({ error: 'Request failed', url: request.url }, { status: 500 })
+    },
+    (request, server) =>
+      Effect.fn(async function* () {
+        const app = yield* AppService
+        const currentRequest = yield* CurrentRequest
+        const signal = yield* CurrentAbortSignal
+
+        return Result.ok({
+          value: app.handle(request.url),
+          currentUrl: (currentRequest.request as Request).url,
+          port: server.port,
+          aborted: signal.aborted
+        })
       })
-    })
   )
+
+  return { port: 3000, fetch }
 })
+
+const runtime = await Runtime.make(Layer.merge(Layer.make(AppService), ApiServer.layer))
+const server = await runtime.run(() => ServiceRuntime.resolve(ApiServer))
 ```
 
-`BunEffect.handler` invokes exactly one `WebEffect` request boundary. That
-boundary supplies `CurrentRequest`, forwards the request signal, composes
-request-local Layers, applies the configured failure/response policies, keeps
-thrown defects rejected, and releases request resources before the handler
-Promise resolves. Runtime-root resources remain shared and owned by `runtime`.
+`BunEffect.handler` invokes exactly one `WebEffect` request boundary. It
+supplies `CurrentRequest`, forwards the request signal to
+`CurrentAbortSignal`, composes request-local Layers, applies success/failure
+policies, keeps thrown defects rejected, and releases request resources before
+the handler Promise resolves.
 
-The application owns both long-lived resources and must shut them down
-explicitly. Stop accepting requests before releasing root Services, then
-release the Runtime:
+For an application-chosen server Service, use `BunEffect.layer(service,
+factory)`. Its factory returns `{ options, map }`; the adapter maps the one
+native server into your Service while retaining the same Runtime lifecycle.
+`BunEffect.server` is the convenience form whose Service is the raw
+`Bun.Server<Data>`.
+
+Dispose the Runtime once during application shutdown. It stops accepting new
+connections, drains active requests, then releases the server and root Layers;
+repeated disposal calls share one Promise:
 
 ```ts
-await server.stop()
 await runtime.dispose()
 ```
 
-`server.stop()` is the Bun server lifecycle boundary; `BunEffect` does not
-provide a `serve` helper or dispose either resource for you. Keep a single
-application-owned shutdown Promise if shutdown can be requested more than once.
 This Bun-specific entrypoint makes no Node compatibility claim.
 
 ### Hono request boundaries
@@ -842,28 +997,63 @@ request Scope cleanup to that shared boundary. You only need to configure one
 Hono middleware boundary per request; the adapter prevents duplicate
 registrations from opening another execution.
 
-Handlers can yield Services directly; the adapter provides `CurrentRequest`,
-forwards `Request.signal`, and converts Results to Responses in one policy:
+`HonoEffect.app` creates a yieldable application Service and its `.layer`. The
+factory is acquired once when the application Layer is resolved, so the host
+owns Runtime composition and shutdown. Handlers can yield Services directly;
+the adapter provides `CurrentRequest`, forwards `Request.signal`, and converts
+Results to Responses in one policy:
 
 ```ts
 import { Hono } from 'hono'
+import { Effect, Layer, Runtime } from 'better-effect'
 import { Result } from 'better-result'
 import { HonoEffect } from 'better-effect/hono'
 
-const http = HonoEffect.make(runtime, {
-  onFailure: (_error, c) => c.json({ error: 'Request failed' }, 400)
-})
-const app = new Hono()
+const App = HonoEffect.app(
+  '@app/HonoApp',
+  {
+    onFailure: (_error, c) => c.json({ error: 'Request failed' }, 400)
+  },
+  async function* (http) {
+    const app = new Hono()
+
+    app.use('*', yield* http.middleware())
+    app.get(
+      '/work-orders',
+      yield* http.gen(async function* () {
+        const workOrders = yield* WorkOrderService
+        const items = yield* Result.await(workOrders.list())
+        return Result.ok(items)
+      })
+    )
 
-app.use('*', http.middleware())
-app.get(
-  '/work-orders',
-  http.gen(async function* () {
-    const workOrders = yield* WorkOrderService
-    const items = yield* Result.await(workOrders.list())
-    return Result.ok(items)
+    return app
+  }
+)
+
+const runtime = await Runtime.make(Layer.merge(AppLive, App.layer))
+const appResult = await runtime.run(
+  Effect.fn(async function* () {
+    return Result.ok(yield* App)
   })
 )
+if (Result.isError(appResult)) throw new Error(String(appResult.error))
+const app = appResult.value
+```
+
+Route examples below belong inside the `HonoEffect.app` factory. For an
+existing application Service, use `HonoEffect.layer(ServiceToken, options,
+factory)` and compose the returned Layer with the Runtime's other Layers.
+
+Use `HonoEffect.layer` when the application should be provided through an
+existing Service token instead of a generated one:
+
+```ts
+const AppLive = HonoEffect.layer(MyApplication, {}, async function* (http) {
+  const app = new Hono()
+  app.use('*', yield* http.middleware())
+  return MyApplication.of({ app })
+})
 ```
 
 One or more Hono validators can precede the generator or handler callback, in
@@ -984,6 +1174,47 @@ low-level provider metadata names.
 `Layer.complete(layer)` is a runtime identity that checks a composition root
 immediately, so missing Services are reported where the Layer is assembled.
 
+### Lifecycle-only Layers
+
+Use `Layer.scopedDiscard` for application components that need startup and
+shutdown ownership but are not themselves a Service:
+
+```ts
+const PollerLive = Layer.scopedDiscard(
+  () => startPoller(),
+  (poller, outcome) => poller.stop(outcome)
+)
+
+const ServerLive = Layer.scopedDiscard(() => startServer(), {
+  quiesce: (server) => server.stopAccepting(),
+  release: (server, outcome) => server.close(outcome)
+})
+
+const AppLive = Layer.complete(Layer.merge(ConfigLive, PollerLive))
+```
+
+The acquisition runs once when `Runtime.make` activates the Layer, after
+provider registration and optional warmup. The release belongs to the Runtime
+root Scope, runs in reverse activation order, and receives the final
+`ScopeOutcome`. A contextual acquisition can use `yield*` with
+`Layer.scopedDiscard` (or the explicit `Layer.scopedDiscardGen`) and retains
+those Service requirements even though the Layer provides `never`:
+
+```ts
+const PollerLive = Layer.scopedDiscard(
+  async function* () {
+    const config = yield* Config
+    return startPoller(config)
+  },
+  (poller, outcome) => poller.stop(outcome)
+)
+```
+
+For startup programs, `Layer.effectDiscard` accepts only
+`Effect.Program<void, never, R>`-compatible programs. A typed failure must be
+handled by the program before it is made a lifecycle entry; it is not silently
+converted into a Runtime defect.
+
 ---
 
 ## Why better-effect?
@@ -1230,6 +1461,24 @@ Use `Config.schema(schema)` with `Config.layer(source)` or
 `Config.layerFromEnv(options)` when several descriptors should share an
 explicitly replaceable provider.
 
+When configuration should be consumed through a Service token, bind the schema
+to that token so `get` only accepts keys from the decoded schema output:
+
+```ts
+const AppConfig = Config.withSchema(EnvSchema)
+const AppConfigLive = AppConfig.layerFromEnv({ dotEnvPath: '.env' })
+
+const program = Effect.fn(async function* () {
+  const config = yield* AppConfig
+  return Result.ok(config.get('DATABASE_URL'))
+  //             ^ autocomplete is restricted to EnvSchema output keys
+})
+```
+
+`config.get(...)` reads the validated schema output, with the value type inferred
+from the selected key. Use `Config.schema(schema)` or
+`Config.fromEnv({ schema })` when the complete transformed output is needed.
+
 ---
 
 ## How it compares

package/dist/adapters/iti.d.mts

@@ -1,6 +1,5 @@
-import { N as AnyServiceToken } from "../index-AiKM71-u.mjs";
-import { d as LayerBackend, f as LayerBackendDisposeOptions, m as LayerRegistration } from "../outcome-DI8LPIQ4.mjs";
-import "../index-DAKn0qHk.mjs";
+import { G as LayerRegistration, H as LayerBackendDisposeOptions, Rt as AnyServiceToken, V as LayerBackend } from "../layer-C2OaqTmB.mjs";
+import "../index-Cy1VsU-u.mjs";
 //#region src/adapters/iti.d.ts
 /**
  * ITI-backed Layer backend.

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

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

package/dist/adapters/iti.mjs

@@ -1,6 +1,6 @@
-import { f as captureServiceTag, n as normalizeLayerRegistration, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag, u as ServiceNotFoundError } from "../registration-drnZk0SY.mjs";
+import { f as captureServiceTag, n as normalizeLayerRegistration, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag, u as ServiceNotFoundError } from "../registration-Bwe2GbVu.mjs";
 import { t as isPromiseLike } from "../runtime-CDcCF5cb.mjs";
-import { t as assertServiceCompatibility } from "../internal-identity-CbXoZIfw.mjs";
+import { t as assertServiceCompatibility } from "../internal-identity-BuHBtP0k.mjs";
 import { createContainer } from "iti";
 //#region src/adapters/iti.ts
 /**