better-effect 0.11.0 → 0.13.0

package/README.md

@@ -12,7 +12,9 @@ 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.
+context uses Node/Bun async context propagation. `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.
 
 ## TypeScript knows what your application needs
 
@@ -156,6 +158,28 @@ Scope.
 Scope. `Effect.fn` captures the generator as a lazy `Program` for Runtime
 boundaries; the callback form remains supported for compatibility.
 
+Name a Program without executing it. The name is private diagnostic metadata,
+so the value remains an ordinary callable function and can be used with `pipe`:
+
+```ts
+const loadUser = pipe(
+  Effect.fn(async function* () {
+    return Result.ok(await userRepository.load(userId))
+  }),
+  Program.named('user.load')
+)
+
+const result = await runtime.run(loadUser, {
+  attributes: { userId, requestId }
+})
+```
+
+`Program.map`, `mapError`, `andThen`, `tap`, `tapError`, and `recover` preserve
+their source name. A later `Program.named` call overrides it. Collection
+Programs do not concatenate child names; give `Program.all`, `Program.forEach`,
+or `Program.allResults` an optional `{ name }` when the collection itself needs
+a diagnostic name.
+
 `Program.all` keeps a collection lazy until the returned Program is run. Pass
 `{ concurrency: n }` for a positive bounded FIFO worker pool; values retain
 input order. If a Program returns an error or throws, scheduling stops, already-
@@ -320,7 +344,60 @@ await runtime.warmup()
 Warmup failures include the Service and resolution path, release resources
 already acquired, dispose the backend and reject the Runtime. Optional
 observers expose Service resolution/acquisition, execution and Layer release
-events without coupling the core to an observability SDK:
+events without coupling the core to an observability SDK. Service events carry
+an optional matching `executionId` only when they occur inside an active
+execution; warmup and Runtime-root activity omit it. Execution events carry one
+matching `executionId`, the optional Program name, copied readonly attributes,
+and a monotonic `durationMs` measured through execution cleanup. An end event
+keeps the primary program `outcome` and adds `cleanupFailure` when execution
+Scope cleanup fails:
+
+```ts
+const runtime = await Runtime.make(AppLive, {
+  observers: [
+    {
+      onExecutionStart: ({ executionId, name, attributes }) =>
+        console.debug('program.start', { executionId, name, attributes }),
+      onExecutionEnd: ({ executionId, outcome, durationMs }) =>
+        metrics.observe('program.duration_ms', durationMs, {
+          executionId,
+          outcome: outcome.status
+        })
+    }
+  ]
+})
+```
+
+The Runtime does not serialize or inspect attribute values. Attributes are
+shallow-copied and exposed as a readonly event view; do not attach secrets,
+large objects, or mutable application state. Keep sensitive values out of
+observer logs and metrics labels.
+
+For coarse, synchronous diagnostics, use `runtime.inspect()`:
+
+```ts
+const inspection = runtime.inspect()
+// {
+//   state: 'active',
+//   warmup: 'idle',
+//   activeExecutions: 0,
+//   executions: [],
+//   services: ['Database', 'UserRepository'],
+//   shutdownSignalAborted: false
+// }
+```
+
+The returned snapshot and its arrays are detached and immutable. It contains
+only public Service tags and execution IDs, names and start timestamps; it never
+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`.
+
+`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.
 
 Missing, circular, and provider-construction failures use the logical Service
 tags in `ServiceNotFoundError`, `CircularDependencyError`, and
@@ -365,6 +442,103 @@ 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.
 
+### Optional OpenTelemetry tracing
+
+Install the OpenTelemetry API only when this subpath is used:
+
+```bash
+bun add better-effect @opentelemetry/api
+```
+
+`better-effect/opentelemetry` accepts either an existing `Tracer` or an existing
+`TracerProvider`. Its supported `@opentelemetry/api` peer range is
+`>=1.9.0 <1.10.0` (tested with 1.9.1). It never installs a global provider, SDK,
+context manager or exporter. The provider form only calls `getTracer`:
+
+```ts
+import { trace } from '@opentelemetry/api'
+import { OpenTelemetryRuntimeObserver } from 'better-effect/opentelemetry'
+
+const observer = OpenTelemetryRuntimeObserver.make({
+  // An existing provider can be passed instead with `provider` and `tracerName`.
+  tracer: trace.getTracer('acme.application'),
+  serviceResolution: 'events',
+  recordFailures: true,
+  executionAttributeAllowlist: ['requestId'],
+  sanitizeFailure: (cause) =>
+    cause instanceof KnownDomainError ? { message: cause.code } : undefined
+})
+
+const runtime = await Runtime.make(AppLive, { observers: [observer] })
+```
+
+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
+execution cleanup succeed use OpenTelemetry `OK`; typed `Result.err` values,
+thrown defects and execution cleanup failures use `ERROR`. The Runtime observer
+keeps cleanup failure separate from the primary program outcome, so the adapter
+can report the final execution status without turning cleanup into a program
+defect or serializing its cause by default.
+Span timing is supplied by OpenTelemetry's start/end clock; `durationMs` is not
+written as a second duration source.
+
+Service telemetry is explicit and defaults to `off`:
+
+- `off` creates no Service telemetry.
+- `events` adds resolution, acquisition and release events to an execution span
+  only when the Runtime event carries an explicit active execution ID. Warmup,
+  Runtime-root cleanup and other events without an owner use standalone spans.
+- `spans` creates child Service spans only for events with an explicit active
+  execution ID. Warmup and Runtime-root cleanup are represented by standalone
+  service spans (or generic event-carrier spans in `events` mode); ambient
+  OpenTelemetry context is never used to guess ownership.
+
+Service identity is always the logical `serviceTag`; constructor names and
+Service instances are never used. `RuntimeObserver.compose` can combine this
+adapter with recorded, graph and application observers, and a tracer failure is
+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`.
+
+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
+Service instances, and it never stringifies unknown values. Add attributes only
+through `executionAttributeAllowlist` or the explicit
+`sanitizeExecutionAttributes` callback; add failure details only through
+`sanitizeFailure` together with `recordFailures: true`. Unsupported values are
+dropped, strings are bounded, and default limits are 256 characters, 32
+attributes and 16 resolution-path tags (caller limits remain capped). Sanitizer
+callbacks should return only intentional scalar OpenTelemetry attributes.
+
+For distributed tracing, establish the caller's OpenTelemetry context before
+calling `runtime.run`; the adapter does not propagate context or instrument
+HTTP/database libraries automatically.
+
+For a startup view of the graph actually observed by a Runtime, compose the
+small graph observer and warm the Layer before accepting work:
+
+```ts
+import { Runtime } from 'better-effect'
+import { RuntimeGraphObserver } from 'better-effect/testing'
+
+const graph = RuntimeGraphObserver.make({ rootLabel: 'Runtime' })
+const runtime = await Runtime.make(AppLive, {
+  warmup: true,
+  observers: [graph]
+})
+
+console.log(graph.toJSON())
+console.log(graph.toMermaid())
+await runtime.dispose()
+```
+
+`RuntimeGraphObserver` uses only public resolution and acquisition events. Its
+snapshot is sorted, detached and immutable; it records Service tags and counts,
+not instances, scopes, causes or execution attributes. Providers that are never
+resolved remain absent, and `clear()` starts a new diagnostic session.
+
 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;
@@ -379,6 +553,38 @@ 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:
+
+```ts
+import { NodeRuntime } from 'better-effect/node'
+
+const main = Effect.fn(async function* () {
+  const signal = yield* CurrentAbortSignal
+  return Result.ok(await runCommand({ signal }))
+})
+
+await NodeRuntime.runMain(AppLive, main, {
+  onFailure: (error) => {
+    console.error(error)
+    return 1
+  },
+  onSuccess: () => 0
+})
+```
+
+`Result.err` uses `onFailure` (or exit code `1` by default), while thrown defects
+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.
+
 For request-local context or overrides, add a Layer only to that execution:
 
 ```ts
@@ -390,12 +596,254 @@ with the execution Scope and never change the shared Runtime environment. Its
 external requirements must be provided by the Runtime, and the Hono failure
 handler/request-Layer types are checked at the adapter boundary.
 
+### Framework-neutral Web request boundaries
+
+The `better-effect/web` entrypoint provides a small Request-to-Response
+boundary without depending on Hono or another framework. Use it anywhere a
+framework gives you standard Web `Request` and `Response` values:
+
+```ts
+import { Result } from 'better-result'
+import { CurrentAbortSignal, Effect } from 'better-effect'
+import { CurrentRequest } from 'better-effect/standard-services'
+import { WebEffect } from 'better-effect/web'
+
+const handleRequest = (request: Request) =>
+  WebEffect.handle(
+    runtime,
+    request,
+    Effect.fn(async function* () {
+      const currentRequest = yield* CurrentRequest
+      const signal = yield* CurrentAbortSignal
+      const user = yield* UserService
+      const result = yield* Result.await(user.find())
+
+      return Result.ok({
+        result,
+        url: (currentRequest.request as Request).url,
+        aborted: signal.aborted
+      })
+    })
+  )
+```
+
+`WebEffect.handle` 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
+intentionally override a compatible request tag.
+
+The default success policy passes through a Web `Response`, maps top-level
+`undefined` to 204, and wraps supported values as `{ data: value }` JSON. A
+non-`undefined`, non-`Response` value must be an acyclic graph of `null`,
+booleans, strings, finite numbers, dense arrays, and plain object records.
+Arrays must have only the own string properties `length` and one property for
+each index from `0` through `length - 1`; each index must be an enumerable data
+property. Symbol keys, extra own properties (including non-enumerable ones),
+sparse holes, and accessor elements are rejected. Object records must have
+`Object.prototype` or `null` as their prototype, and every own string-keyed
+property must be an enumerable data property. Own symbol keys,
+non-enumerable properties, accessors, custom prototypes, and other non-plain
+objects are rejected. Shared references in separate branches are serialized as
+repeated values. Nested `undefined`, `bigint`, functions, symbols, and
+non-finite numbers (`NaN` and infinities) are rejected with
+`WebEffectSerializationError` (a `TypeError`) instead of being silently dropped
+or coerced. Use an explicit `onSuccess` policy for other representations. The
+default failure policy passes through a standards-compatible `Response`
+failure and redacts every other typed failure to `{ error: 'Internal Server Error' }`
+with status 500. Custom
+`onSuccess`/`onFailure` policies may be asynchronous but must return a
+standards-compatible `Response`. The boundary checks that protocol structurally:
+`status` is an integer in `0` or `200` through `599`, `ok` matches the 2xx
+status range, `redirected` and `bodyUsed` are booleans, `statusText` and `url`
+are strings, `type` is a standard Response type, and
+`arrayBuffer()`, `blob()`, `bytes()`, `clone()`, `formData()`, `json()`, and
+`text()` are callable. `headers` must provide callable `append()`, `delete()`,
+`get()`, `getSetCookie()`, `has()`, `set()`, and `forEach()` operations. `body`
+must be `null` (including legitimate null-body Responses such as `204`) or a
+ReadableStream-compatible object with a boolean `locked` property and callable
+`cancel()`, `getReader()`, `pipeThrough()`, `pipeTo()`, and `tee()` methods.
+Native cross-realm Responses and other values satisfying this protocol are
+accepted without `instanceof Response`; missing capabilities and forged
+`Response.prototype` values fail with `TypeError`. Thrown defects remain
+rejected. The Program's Service and failure channels, request-Layer
+requirements, and override compatibility are checked at the TypeScript
+boundary.
+
+### Next.js App Router request boundaries
+
+The optional `better-effect/next` entrypoint adapts an application-owned
+Runtime to native Next.js App Router Route Handlers without importing Next.js
+from the core or main entrypoint:
+
+```ts
+import { Result } from 'better-result'
+import { Effect, Layer, Runtime, Service } from 'better-effect'
+import { NextEffect } from 'better-effect/next'
+
+class UserService extends Service<UserService>()('UserService') {
+  find(id: string) {
+    return { id, name: 'Ada' }
+  }
+}
+
+const runtime = await Runtime.make(Layer.make(UserService))
+const http = NextEffect.make(runtime)
+
+export const GET = http.gen(async function* (_request, context: RouteContext<'/api/users/[id]'>) {
+  const { id } = await context.params
+  const users = yield* UserService
+
+  return Result.ok(users.find(id))
+})
+```
+
+`NextEffect.gen` and `NextEffect.handler` 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:
+
+```ts
+// app/runtime.ts
+export const appRuntime = await Runtime.make(AppLive)
+
+// Call this from the actual host/server shutdown hook.
+export const disposeAppRuntime = (): Promise<void> => appRuntime.dispose()
+```
+
+Route modules import that Runtime and bind it to the adapter:
+
+```ts
+// app/api/users/[id]/route.ts
+import { appRuntime } from '@/app/runtime'
+
+const http = NextEffect.make(appRuntime)
+```
+
+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:
+
+```ts
+export const GET = (request, context) =>
+  Runtime.use(AppLive, (runtime) =>
+    NextEffect.make(runtime).handler(() => getUser(context))(request, context)
+  )
+```
+
+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
+`AbortSignal` is linked into the execution signal, and concurrent requests keep
+request Layers and context isolated.
+
+The default success policy passes through a returned `Response`; other values
+are encoded as `{ data: value }` JSON using the same strict serialization rules
+as `better-effect/web`. A route may select at most one success policy:
+`respond` handles a complete Response, `serialize` transforms a JSON-safe
+value, and route-level `onSuccess` replaces the shared success policy. Shared
+`onSuccess` and `onFailure` policies receive the native Request and route
+context. Typed
+`Result.err` failures use `onFailure` (or the redacted 500 default), while
+thrown defects remain rejected. Policies must return a standards-compatible
+`Response` and may be asynchronous. This adapter does not add Edge-runtime
+support; use it only in hosts supported by the configured better-effect
+Runtime.
+
+Install Next.js only when this subpath is used:
+
+```bash
+bun add better-effect better-result next
+```
+
+`next` is an optional peer dependency, and `better-effect/next` uses only the
+public native Route Handler shape, so the core and other entrypoints remain
+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:
+
+```ts
+import { Result } from 'better-result'
+import { CurrentAbortSignal, Effect, Layer, Runtime, Service } from 'better-effect'
+import { CurrentRequest } from 'better-effect/standard-services'
+import { BunEffect } from 'better-effect/bun'
+
+class AppService extends Service<AppService>()('AppService') {
+  handle(url: string) {
+    return url
+  }
+}
+
+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
+      })
+    })
+  )
+})
+```
+
+`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`.
+
+The application owns both long-lived resources and must shut them down
+explicitly. Stop accepting requests before releasing root Services, then
+release the Runtime:
+
+```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
 
-The optional `better-effect/hono` entrypoint runs one Runtime execution and
-Scope around each request. Handlers can yield Services directly; the adapter
-provides `CurrentRequest`, forwards `Request.signal`, and converts Results to
-Responses in one policy:
+The optional `better-effect/hono` entrypoint supplies Hono's middleware,
+validator, and Context integration around the same Web request boundary used
+by `better-effect/web`. It adapts Hono's Context to a standard Web `Request`,
+then delegates the single `Runtime` execution, Result/defect handling, and
+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:
 
 ```ts
 import { Hono } from 'hono'
@@ -671,10 +1119,96 @@ const now = await runtime.run(async () => ServiceRuntime.resolve(Clock))
 await runtime.dispose()
 ```
 
-The entrypoint also provides `Random`/`RandomSeeded`, `Logger`/`LoggerTest`,
-`Config`, `CurrentRequest`, and the compatible `CurrentAbortSignal` bridge. None
-is installed implicitly; compose a normal Layer or use the provided test
-helpers.
+`IdGenerator` uses the host's cryptographic `crypto.randomUUID()` and is also
+opt-in. Use `IdGeneratorTest` to make entity creation deterministic without
+introducing a domain-specific ID type:
+
+```ts
+import { Result } from 'better-result'
+import { Effect, Layer, Service } from 'better-effect'
+import { IdGenerator } from 'better-effect/standard-services'
+import { IdGeneratorTest, TestRuntime } from 'better-effect/testing'
+
+class User extends Service<User>()('User') {
+  constructor(readonly id: string) {
+    super()
+  }
+}
+
+const createUser = Effect.fn(async function* () {
+  const ids = yield* IdGenerator
+  return Result.ok(new User(ids.next()))
+})
+
+const result = await TestRuntime.use(
+  Layer.merge(),
+  { idGenerator: new IdGeneratorTest(['user-1']) },
+  (test) => test.run(createUser)
+)
+// Result.ok(User { id: 'user-1' })
+```
+
+`IdGeneratorTest.from((index) => ...)` provides an unbounded deterministic
+sequence; its first factory index is zero and increases monotonically. The
+entrypoint also provides `Random`/`RandomSeeded`, `Logger`/`LoggerTest`, `Config`,
+`CurrentRequest`, and the compatible `CurrentAbortSignal` bridge. None is
+installed implicitly; compose a normal Layer or use the provided test helpers.
+
+`Clock.sleep` keeps the original `clock.sleep(milliseconds)` form and accepts
+an optional `AbortSignal`. Invalid delays still throw synchronously. Aborted
+sleeps clear their timer and listener; a supplied `signal.reason` is rejected
+unchanged, otherwise the rejection is an `AbortError`-named `DOMException`.
+
+Use the same signal in polling, retry delays and expiration checks:
+
+```ts
+const poll = async (clock: Clock, signal: AbortSignal) => {
+  while (true) {
+    const status = await readStatus()
+    if (status.ready) return status
+    await clock.sleep(1_000, { signal })
+  }
+}
+
+const retry = async <A>(operation: () => Promise<A>, clock: Clock, signal: AbortSignal) => {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await operation()
+    } catch (error) {
+      if (attempt === 2) throw error
+      await clock.sleep(100 * 2 ** attempt, { signal })
+    }
+  }
+}
+
+const waitUntilExpired = async (clock: Clock, expiresAt: number, signal: AbortSignal) => {
+  while (clock.now().getTime() < expiresAt) {
+    await clock.sleep(Math.min(expiresAt - clock.now().getTime(), 1_000), { signal })
+  }
+}
+```
+
+`ClockTest` orders sleeps by absolute deadline and FIFO for equal deadlines.
+`pendingSleeps` is a readonly count. `advanceToNext()` returns `false` when
+there is no pending sleep; `runAll({ maxSteps })` advances repeatedly and
+awaits one microtask checkpoint between deadlines so resumed code can schedule
+its next wait:
+
+```ts
+const clock = new ClockTest(0)
+const task = (async () => {
+  await clock.sleep(100)
+  await clock.sleep(50)
+})()
+
+await clock.runAll({ maxSteps: 10 })
+await task
+// clock.now().getTime() === 150
+```
+
+`setTime` may move backward. Pending sleeps keep their absolute deadlines and
+resolve only when reached. `ClockTest` does not virtualize `Date`, global
+`setTimeout` or the JavaScript microtask queue.
 
 For typed environment configuration, bind a Standard Schema directly to a
 reusable descriptor:

package/dist/adapters/iti.d.mts

@@ -1,5 +1,6 @@
-import { N as AnyServiceToken } from "../index-heuaRmXR.mjs";
-import { v as LayerBackend, x as LayerRegistration, y as LayerBackendDisposeOptions } from "../index-rQhZk3Nt.mjs";
+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";
 //#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":";;;;;;;;;cAuBa,2BAA2B;UAC9B;mBAES;mBAEA;;;;;;mBAOA;UAET;;EAgBR,SAAS,cAAc;;EAuBvB,QAAQ,UAAU,iBAAiB,OAAO,IAAI,aAAa,KAAK,YAAY,aAAa;;EAiCnF,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 { a as ServiceTagCollisionError, c as ServiceNotFoundError, t as DuplicateServiceError } from "../errors-Dnjhzbt0.mjs";
+import { f as captureServiceTag, n as normalizeLayerRegistration, r as DuplicateServiceError, s as ServiceTagCollisionError, t as captureLayerRegistrationTag, u as ServiceNotFoundError } from "../registration-drnZk0SY.mjs";
 import { t as isPromiseLike } from "../runtime-CDcCF5cb.mjs";
-import { t as assertServiceCompatibility } from "../internal-identity-DmUpBeeL.mjs";
+import { t as assertServiceCompatibility } from "../internal-identity-CbXoZIfw.mjs";
 import { createContainer } from "iti";
 //#region src/adapters/iti.ts
 /**
@@ -19,8 +19,7 @@ var ItiLayerBackend = class {
 	* retry boundary for that sticky failure behavior.
 	*/
 	pending = /* @__PURE__ */ new Map();
-	keyFor(token) {
-		const tag = token.serviceTag;
+	keyFor(tag) {
 		const existing = this.keys.get(tag);
 		if (existing) return existing;
 		const key = `better-effect:${tag}`;
@@ -29,20 +28,22 @@ var ItiLayerBackend = class {
 	}
 	/** Register a Layer provider under its deterministic Service-tag key. */
 	register(registration) {
-		const token = registration.service;
-		const tag = token.serviceTag;
+		const normalized = normalizeLayerRegistration(registration);
+		const token = normalized.service;
+		const tag = captureLayerRegistrationTag(normalized);
 		const existing = this.registered.get(tag);
 		if (existing === token) throw new DuplicateServiceError(token);
 		if (existing) throw new ServiceTagCollisionError(existing, token);
-		const key = this.keyFor(token);
-		this.container = this.container.add({ [key]: registration.acquire });
+		const key = this.keyFor(tag);
+		this.container = this.container.add({ [key]: normalized.acquire });
 		this.registered.set(tag, token);
 	}
 	/** Resolve a registered Service through the ITI container. */
 	resolve(token) {
-		const registered = this.registered.get(token.serviceTag);
+		const tag = captureServiceTag(token);
+		const registered = this.registered.get(tag);
 		if (registered === void 0) throw new ServiceNotFoundError(token);
-		const key = this.keyFor(token);
+		const key = this.keyFor(tag);
 		const resolved = this.container.get(key);
 		const validate = (instance) => {
 			assertServiceCompatibility(token, registered, instance);