better-effect 0.12.0 → 0.13.0

package/README.md

@@ -344,9 +344,13 @@ 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. Execution events
-carry one matching `executionId`, the optional Program name, copied readonly
-attributes, and a monotonic `durationMs` measured through execution cleanup:
+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, {
@@ -438,6 +442,80 @@ 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:
 
@@ -518,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'

package/dist/adapters/iti.d.mts

@@ -1,6 +1,6 @@
-import { N as AnyServiceToken } from "../index-heuaRmXR.mjs";
-import { S as LayerRegistration, b as LayerBackendDisposeOptions, y as LayerBackend } from "../outcome-CB43bnFW.mjs";
-import "../index-BMdU_Z72.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/bun.d.mts

@@ -0,0 +1,43 @@
+import { M as AnyService } from "./index-AiKM71-u.mjs";
+import { y as LayerInput } from "./outcome-DI8LPIQ4.mjs";
+import { l as Runtime } from "./index-BodMy6rO.mjs";
+import { a as WebEffectOptions, n as CompleteWebProgram, o as WebEffectProgram, r as DefaultRequestLayer, s as WebEffectSuccess, t as AnyProgram, u as WebRequestLayerChecks } from "./types-oihI-ESv.mjs";
+//#region src/bun/types.d.ts
+/** A Bun server passed to a Bun.serve fetch handler. */
+type BunServer<WebSocketData = undefined> = Bun.Server<WebSocketData>;
+/** The Promise<Response> handler shape accepted by Bun.serve. */
+type BunFetchHandler<WebSocketData = undefined> = (request: Request, server: BunServer<WebSocketData>) => Promise<Response>;
+/** A lazy Result-valued Program accepted by the Bun adapter. */
+type BunEffectProgram<A = unknown, E = unknown, R extends AnyService = never> = WebEffectProgram<A, E, R>;
+/** Options for adapting a WebEffect boundary to Bun's fetch callback. */
+type BunEffectOptions<Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer> = Omit<WebEffectOptions<Failure, RequestLayer>, 'onFailure' | 'onSuccess'> & {
+  /** Convert a successful Program value into a Response. */
+  readonly onSuccess?: (result: WebEffectSuccess, request: Request) => ResponseLike;
+  /** Convert a typed Program failure into a Response. */
+  readonly onFailure?: (error: Failure, request: Request) => ResponseLike;
+};
+/** A standard Web response or an asynchronous response. */
+type ResponseLike = Response | PromiseLike<Response>;
+/** @internal */
+type BunAnyProgram = AnyProgram;
+/** @internal */
+type BunHandlerProgram<Provided extends AnyService, RequestLayer extends LayerInput, Program extends AnyProgram, Failure> = CompleteWebProgram<Provided, RequestLayer, Program, Failure>;
+/** @internal */
+type BunRequestLayerChecks<Provided extends AnyService, RequestLayer extends LayerInput> = WebRequestLayerChecks<Provided, RequestLayer>;
+//#endregion
+//#region src/bun/index.d.ts
+type BunHandlerFactory<Provided extends AnyService, RequestLayer extends LayerInput, Failure, WebSocketData, ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram> = ProgramFactory & ([ReturnType<ProgramFactory>] extends [BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>] ? unknown : (request: Request, server: Bun.Server<WebSocketData>) => BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>);
+/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */
+declare class BunEffect<Provided extends AnyService = never, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer> {
+  readonly runtime: Runtime<Provided>;
+  private readonly onSuccess;
+  private readonly onFailure;
+  private readonly requestLayer;
+  private constructor();
+  static make<Provided extends AnyService, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer>(runtime: Runtime<Provided>, options?: BunEffectOptions<Failure, RequestLayer> & BunRequestLayerChecks<Provided, RequestLayer>): BunEffect<Provided, Failure, RequestLayer>;
+  handler<WebSocketData = undefined, const ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram>(makeProgram: BunHandlerFactory<Provided, RequestLayer, Failure, WebSocketData, ProgramFactory>): BunFetchHandler<WebSocketData>;
+  private makeWebOptions;
+}
+//#endregion
+export { BunEffect, type BunEffectOptions, type BunEffectProgram, type BunFetchHandler, type BunServer, type ResponseLike };
+//# sourceMappingURL=bun.d.mts.map

package/dist/bun.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.mts","names":[],"sources":["../src/bun/types.ts","../src/bun/index.ts"],"mappings":";;;;;;KAaY,UAAU,6BAA6B,IAAI,OAAO;;KAGlD,gBAAgB,8BAC1B,SAAS,SACT,QAAQ,UAAU,mBACf,QAAQ;;KAGD,iBACV,aACA,aACA,UAAU,sBACR,iBAAiB,GAAG,GAAG;;KAGf,iBACV,mBACA,qBAAqB,aAAa,uBAChC,KAAK,iBAAiB,SAAS;;WAExB,aAAa,QAAQ,kBAAkB,SAAS,YAAY;;WAE5D,aAAa,OAAO,SAAS,SAAS,YAAY;;;KAIjD,eAAe,WAAW,YAAY;;KAGtC,gBAAgB;;KAGhB,kBACV,iBAAiB,YACjB,qBAAqB,YACrB,gBAAgB,YAChB,WACE,mBAAmB,UAAU,cAAc,SAAS;;KAG5C,sBACV,iBAAiB,YACjB,qBAAqB,cACnB,sBAAsB,UAAU;;;KCjC/B,kBACH,iBAAiB,YACjB,qBAAqB,YACrB,SACA,eACA,wBAAwB,SAAS,SAAS,QAAQ,IAAI,OAAO,mBAAmB,iBAC9E,mBACA,WAAW,0BACX,kBAAkB,UAAU,cAAc,WAAW,iBAAiB,uBAIlE,SAAS,SACT,QAAQ,IAAI,OAAO,mBAChB,kBAAkB,UAAU,cAAc,WAAW,iBAAiB;;cAGpE,UACX,iBAAiB,oBACjB,mBACA,qBAAqB,aAAa;WAEzB,SAAS,QAAQ;mBAET;mBAEA;mBAEA;UAEV;SAUA,KACL,iBAAiB,YACjB,mBACA,qBAAqB,aAAa,qBAElC,SAAS,QAAQ,WACjB,UAAU,iBAAiB,SAAS,gBAClC,sBAAsB,UAAU,gBACjC,UAAU,UAAU,SAAS;EAIhC,QACE,iCACM,wBACJ,SAAS,SACT,QAAQ,IAAI,OAAO,mBAChB,iBAAiB,SAAS,SAAS,QAAQ,IAAI,OAAO,mBAAmB,eAE9E,aAAa,kBAAkB,UAAU,cAAc,SAAS,eAAe,kBAC9E,gBAAgB;UASX"}

package/dist/bun.mjs

@@ -0,0 +1,40 @@
+import { t as Layer } from "./layer-D16GKxuX.mjs";
+import { t as WebEffect } from "./web-Bq3MfMrj.mjs";
+//#region src/bun/index.ts
+const runWebEffect = (runtime, request, program, options) => {
+	return WebEffect.handle(runtime, request, program, options);
+};
+/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */
+var BunEffect = class BunEffect {
+	runtime;
+	onSuccess;
+	onFailure;
+	requestLayer;
+	constructor(runtime, options) {
+		this.runtime = runtime;
+		this.onSuccess = options.onSuccess;
+		this.onFailure = options.onFailure;
+		this.requestLayer = options.requestLayer;
+	}
+	static make(runtime, options) {
+		return new BunEffect(runtime, options ?? {});
+	}
+	handler(makeProgram) {
+		return async (request, server) => {
+			const program = (() => makeProgram(request, server)());
+			return runWebEffect(this.runtime, request, program, this.makeWebOptions(request));
+		};
+	}
+	makeWebOptions(request) {
+		const options = { requestLayer: this.requestLayer ?? (() => Layer.empty) };
+		const onSuccess = this.onSuccess;
+		if (onSuccess !== void 0) options.onSuccess = (result) => onSuccess(result, request);
+		const onFailure = this.onFailure;
+		if (onFailure !== void 0) options.onFailure = (error) => onFailure(error, request);
+		return options;
+	}
+};
+//#endregion
+export { BunEffect };
+
+//# sourceMappingURL=bun.mjs.map

package/dist/bun.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.mjs","names":[],"sources":["../src/bun/index.ts"],"sourcesContent":["import { Layer } from '../layer'\nimport { WebEffect } from '../web'\nimport type { AnyService } from '../service'\nimport type { LayerInput } from '../layer/inference'\nimport type { Runtime } from '../runtime'\nimport type {\n  BunAnyProgram,\n  BunEffectOptions,\n  BunFetchHandler,\n  BunHandlerProgram,\n  BunRequestLayerChecks\n} from './types'\nimport type { DefaultRequestLayer, WebEffectOptions } from '../web/types'\n\nconst runWebEffect = <Provided extends AnyService>(\n  runtime: Runtime<Provided>,\n  request: Request,\n  program: BunAnyProgram,\n  options: WebEffectOptions<unknown, LayerInput, unknown>\n): Promise<Response> => {\n  // SAFETY: BunHandlerFactory validates the Program; WebEffect owns this erased request boundary.\n  return WebEffect.handle(runtime, request, program, options as never)\n}\n\ntype BunHandlerFactory<\n  Provided extends AnyService,\n  RequestLayer extends LayerInput,\n  Failure,\n  WebSocketData,\n  ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n> = ProgramFactory &\n  ([ReturnType<ProgramFactory>] extends [\n    BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>\n  ]\n    ? unknown\n    : (\n        request: Request,\n        server: Bun.Server<WebSocketData>\n      ) => BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>)\n\n/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */\nexport class BunEffect<\n  Provided extends AnyService = never,\n  Failure = unknown,\n  RequestLayer extends LayerInput = DefaultRequestLayer\n> {\n  readonly runtime: Runtime<Provided>\n\n  private readonly onSuccess: BunEffectOptions<Failure, RequestLayer>['onSuccess']\n\n  private readonly onFailure: BunEffectOptions<Failure, RequestLayer>['onFailure']\n\n  private readonly requestLayer: BunEffectOptions<Failure, RequestLayer>['requestLayer']\n\n  private constructor(\n    runtime: Runtime<Provided>,\n    options: BunEffectOptions<Failure, RequestLayer>\n  ) {\n    this.runtime = runtime\n    this.onSuccess = options.onSuccess\n    this.onFailure = options.onFailure\n    this.requestLayer = options.requestLayer\n  }\n\n  static make<\n    Provided extends AnyService,\n    Failure = unknown,\n    RequestLayer extends LayerInput = DefaultRequestLayer\n  >(\n    runtime: Runtime<Provided>,\n    options?: BunEffectOptions<Failure, RequestLayer> &\n      BunRequestLayerChecks<Provided, RequestLayer>\n  ): BunEffect<Provided, Failure, RequestLayer> {\n    return new BunEffect(runtime, options ?? {})\n  }\n\n  handler<\n    WebSocketData = undefined,\n    const ProgramFactory extends (\n      request: Request,\n      server: Bun.Server<WebSocketData>\n    ) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n  >(\n    makeProgram: BunHandlerFactory<Provided, RequestLayer, Failure, WebSocketData, ProgramFactory>\n  ): BunFetchHandler<WebSocketData> {\n    return async (request, server) => {\n      // SAFETY: the public factory check validates the returned Program before this erased wrapper.\n      const program = (() => makeProgram(request, server)()) as BunAnyProgram\n\n      return runWebEffect(this.runtime, request, program, this.makeWebOptions(request))\n    }\n  }\n\n  private makeWebOptions(request: Request): WebEffectOptions<unknown, LayerInput, unknown> & {\n    readonly requestLayer: (request: Request) => LayerInput\n  } {\n    type MutableWebOptions = {\n      -readonly [Key in keyof WebEffectOptions<unknown, LayerInput, unknown>]?: WebEffectOptions<\n        unknown,\n        LayerInput,\n        unknown\n      >[Key]\n    }\n    const options: MutableWebOptions & {\n      requestLayer: (request: Request) => LayerInput\n    } = {\n      requestLayer: this.requestLayer ?? (() => Layer.empty)\n    }\n\n    const onSuccess = this.onSuccess\n\n    if (onSuccess !== undefined) {\n      options.onSuccess = (result) => onSuccess(result, request)\n    }\n\n    const onFailure = this.onFailure\n\n    if (onFailure !== undefined) {\n      // SAFETY: the public handler check ties this wrapper to the configured Failure channel.\n      options.onFailure = (error) => onFailure(error as Failure, request)\n    }\n\n    return options\n  }\n}\n\nexport type {\n  BunEffectOptions,\n  BunEffectProgram,\n  BunFetchHandler,\n  BunServer,\n  ResponseLike\n} from './types'\n"],"mappings":";;;AAcA,MAAM,gBACJ,SACA,SACA,SACA,YACsB;CAEtB,OAAO,UAAU,OAAO,SAAS,SAAS,SAAS,OAAgB;AACrE;;AAmBA,IAAa,YAAb,MAAa,UAIX;CACA;CAEA;CAEA;CAEA;CAEA,YACE,SACA,SACA;EACA,KAAK,UAAU;EACf,KAAK,YAAY,QAAQ;EACzB,KAAK,YAAY,QAAQ;EACzB,KAAK,eAAe,QAAQ;CAC9B;CAEA,OAAO,KAKL,SACA,SAE4C;EAC5C,OAAO,IAAI,UAAU,SAAS,WAAW,CAAC,CAAC;CAC7C;CAEA,QAOE,aACgC;EAChC,OAAO,OAAO,SAAS,WAAW;GAEhC,MAAM,iBAAiB,YAAY,SAAS,MAAM,CAAC,CAAC;GAEpD,OAAO,aAAa,KAAK,SAAS,SAAS,SAAS,KAAK,eAAe,OAAO,CAAC;EAClF;CACF;CAEA,eAAuB,SAErB;EAQA,MAAM,UAEF,EACF,cAAc,KAAK,uBAAuB,MAAM,OAClD;EAEA,MAAM,YAAY,KAAK;EAEvB,IAAI,cAAc,KAAA,GAChB,QAAQ,aAAa,WAAW,UAAU,QAAQ,OAAO;EAG3D,MAAM,YAAY,KAAK;EAEvB,IAAI,cAAc,KAAA,GAEhB,QAAQ,aAAa,UAAU,UAAU,OAAkB,OAAO;EAGpE,OAAO;CACT;AACF"}

package/dist/{context-BUEf1qjL.mjs → context-BphfFUMO.mjs}

@@ -39,11 +39,13 @@ const setRuntimeContextLineage = (context) => {
 const hasPathPrefix = (parent, child) => child.length >= parent.length && parent.every((token, index) => child[index] === token);
 /** Recognize contexts created by a nested Service, Scope, or Layer operation. */
 const isDerivedRuntimeContext = (parent, child) => parent.resolver !== void 0 && child.resolver === parent.resolver && parent.resolutionPath.length > 0 && hasPathPrefix(parent.resolutionPath, child.resolutionPath) && (child.resolutionPath.length > parent.resolutionPath.length || child.scope !== parent.scope);
-function makeRuntimeContext(resolver, scope, resolutionPath, signal, parent) {
+function makeRuntimeContext(resolver, scope, resolutionPath, signal, parent, executionId) {
 	const context = { resolutionPath };
+	const ownerExecutionId = executionId ?? parent?.executionId;
 	if (resolver !== void 0) Object.assign(context, { resolver });
 	if (scope !== void 0) Object.assign(context, { scope });
 	if (signal !== void 0) Object.assign(context, { signal });
+	if (ownerExecutionId !== void 0) Object.assign(context, { executionId: ownerExecutionId });
 	if (parent !== void 0) inheritRuntimeContextLineage(context, parent);
 	return context;
 }
@@ -149,4 +151,4 @@ const runRuntimeContext = (storage, context, program) => {
 //#endregion
 export { getRuntimeContextLineage as a, isRuntimeContextFrameCarrierInstalled as c, setDefaultRuntimeContextStorage as d, setRuntimeContextFrameCarrier as f, RuntimeContextOverlapError as g, RuntimeContextNotConfiguredError as h, getRuntimeContext as i, makeRuntimeContext as l, withActiveRuntimeContextStorage as m, currentRuntimeContext as n, inheritRuntimeContextLineage as o, setRuntimeContextLineage as p, currentRuntimeContextFrame as r, isDerivedRuntimeContext as s, activeRuntimeContextStorage as t, runRuntimeContext as u };
 
-//# sourceMappingURL=context-BUEf1qjL.mjs.map
+//# sourceMappingURL=context-BphfFUMO.mjs.map

package/dist/context-BphfFUMO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-BphfFUMO.mjs","names":[],"sources":["../src/runtime/errors.ts","../src/runtime/context.ts"],"sourcesContent":["/** Thrown when no RuntimeContext is active in the selected storage. */\nexport class RuntimeContextNotConfiguredError extends Error {\n  constructor() {\n    super('No RuntimeContext is available in the current execution context')\n\n    this.name = 'RuntimeContextNotConfiguredError'\n  }\n}\n\n/** Thrown when ExplicitRuntimeContextStorage cannot safely overlap lineages. */\nexport class RuntimeContextOverlapError extends Error {\n  constructor() {\n    super(\n      'ExplicitRuntimeContextStorage does not support overlapping root or derived context runs; use NodeRuntimeContextStorage for concurrent async branches'\n    )\n\n    this.name = 'RuntimeContextOverlapError'\n  }\n}\n","import { RuntimeContextNotConfiguredError } from './errors'\n\nimport type { Scope } from '../scope/scope'\nimport type { AnyServiceToken, ServiceResolver } from '../service'\nimport { isPromiseLike } from '../utils/runtime'\n\n/** Contextual state shared by Service, Scope and Layer resolution. */\nexport interface RuntimeContext {\n  readonly resolver?: ServiceResolver\n  readonly scope?: Scope\n  readonly signal?: AbortSignal\n  readonly resolutionPath: readonly AnyServiceToken[]\n  /** Runtime execution owner, omitted for warmup and Runtime-root activity. */\n  readonly executionId?: string\n}\n\n/** A context with both channels required by a Runtime execution. */\nexport type CompleteRuntimeContext = RuntimeContext & {\n  readonly resolver: ServiceResolver\n  readonly scope: Scope\n}\n\n/** Host-specific storage for the current RuntimeContext. */\nexport interface RuntimeContextStorage {\n  run<A>(context: RuntimeContext, program: () => A): A\n  current(): RuntimeContext\n}\n\nconst unconfiguredRuntimeContextStorage: RuntimeContextStorage = {\n  run: (_context, program) => program(),\n  current: () => {\n    throw new RuntimeContextNotConfiguredError()\n  }\n}\n\nconst contextLineages = new WeakMap<object, RuntimeContext>()\n\n/** Associate a derived context with the root context of its execution lineage. */\nexport const inheritRuntimeContextLineage = (\n  context: RuntimeContext,\n  parent: RuntimeContext\n): RuntimeContext => {\n  const lineage = contextLineages.get(parent) ?? parent\n  contextLineages.set(context, lineage)\n  return context\n}\n\n/** Return the root context associated with a contextual value, when known. */\nexport const getRuntimeContextLineage = (context: RuntimeContext): RuntimeContext | undefined =>\n  contextLineages.get(context)\n\n/** Associate a newly-entered root context with itself. */\nexport const setRuntimeContextLineage = (context: RuntimeContext): RuntimeContext => {\n  contextLineages.set(context, context)\n  return context\n}\n\nconst hasPathPrefix = (\n  parent: readonly AnyServiceToken[],\n  child: readonly AnyServiceToken[]\n): boolean =>\n  child.length >= parent.length && parent.every((token, index) => child[index] === token)\n\n/** Recognize contexts created by a nested Service, Scope, or Layer operation. */\nexport const isDerivedRuntimeContext = (parent: RuntimeContext, child: RuntimeContext): boolean =>\n  parent.resolver !== undefined &&\n  child.resolver === parent.resolver &&\n  parent.resolutionPath.length > 0 &&\n  hasPathPrefix(parent.resolutionPath, child.resolutionPath) &&\n  (child.resolutionPath.length > parent.resolutionPath.length || child.scope !== parent.scope)\n\n/** Build a context while retaining only channels that are actually available. */\nexport function makeRuntimeContext(\n  resolver: ServiceResolver,\n  scope: Scope,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string\n): CompleteRuntimeContext\nexport function makeRuntimeContext(\n  resolver: ServiceResolver | undefined,\n  scope: Scope | undefined,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string\n): RuntimeContext\nexport function makeRuntimeContext(\n  resolver: ServiceResolver | undefined,\n  scope: Scope | undefined,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string\n): RuntimeContext {\n  const context: RuntimeContext = { resolutionPath }\n  const ownerExecutionId = executionId ?? parent?.executionId\n\n  if (resolver !== undefined) {\n    Object.assign(context, { resolver })\n  }\n\n  if (scope !== undefined) {\n    Object.assign(context, { scope })\n  }\n\n  if (signal !== undefined) {\n    Object.assign(context, { signal })\n  }\n\n  if (ownerExecutionId !== undefined) {\n    Object.assign(context, { executionId: ownerExecutionId })\n  }\n\n  if (parent !== undefined) {\n    inheritRuntimeContextLineage(context, parent)\n  }\n\n  return context\n}\n\n/** A context frame selected for one logical Runtime execution branch. */\nexport type ActiveRuntimeContextFrame = {\n  readonly storage: RuntimeContextStorage\n  readonly context: RuntimeContext\n  readonly parent?: ActiveRuntimeContextFrame\n}\n\n/** Host-provided propagation for Runtime context frames. */\nexport interface RuntimeContextFrameCarrier {\n  run<A>(frame: ActiveRuntimeContextFrame, program: () => A): A\n  current(): ActiveRuntimeContextFrame | undefined\n}\n\nlet defaultStorage = unconfiguredRuntimeContextStorage\nlet fallbackFrame: ActiveRuntimeContextFrame | undefined\nconst fallbackFrames = new Set<ActiveRuntimeContextFrame>()\n\nconst settleWithRuntimeStorage = <A>(value: A, restore: () => void): A => {\n  let promiseLike: boolean\n\n  try {\n    promiseLike = isPromiseLike(value)\n  } catch (cause) {\n    restore()\n    throw cause\n  }\n\n  if (!promiseLike) {\n    restore()\n    return value\n  }\n\n  try {\n    // SAFETY: PromiseLike values are normalized only to restore the storage after settlement; the public generic retains the callback's awaited shape.\n    return Promise.resolve(value).then(\n      (resolved) => {\n        restore()\n        return resolved\n      },\n      (cause) => {\n        restore()\n        throw cause\n      }\n    ) as A\n  } catch (cause) {\n    restore()\n    throw cause\n  }\n}\n\nconst restoreFallbackFrame = (frame: ActiveRuntimeContextFrame): void => {\n  fallbackFrames.delete(frame)\n\n  if (fallbackFrame !== frame) {\n    return\n  }\n\n  let parent = frame.parent\n\n  while (parent !== undefined && !fallbackFrames.has(parent)) {\n    parent = parent.parent\n  }\n\n  fallbackFrame = parent\n}\n\nconst fallbackRuntimeContextFrameCarrier: RuntimeContextFrameCarrier = {\n  run<A>(frame: ActiveRuntimeContextFrame, program: () => A): A {\n    fallbackFrames.add(frame)\n    fallbackFrame = frame\n    const restore = (): void => restoreFallbackFrame(frame)\n\n    try {\n      return settleWithRuntimeStorage(program(), restore)\n    } catch (cause) {\n      restore()\n      throw cause\n    }\n  },\n\n  current: () => fallbackFrame\n}\n\nlet runtimeContextFrameCarrier: RuntimeContextFrameCarrier = fallbackRuntimeContextFrameCarrier\n\n/** Install host async-context propagation for Runtime context frames. */\nexport const setRuntimeContextFrameCarrier = (carrier: RuntimeContextFrameCarrier): void => {\n  runtimeContextFrameCarrier = carrier\n}\n\n/** Return whether a host async-context carrier has been installed. */\nexport const isRuntimeContextFrameCarrierInstalled = (): boolean =>\n  runtimeContextFrameCarrier !== fallbackRuntimeContextFrameCarrier\n\n/** Return the frame associated with the executing callback. */\nexport const currentRuntimeContextFrame = (): ActiveRuntimeContextFrame | undefined =>\n  runtimeContextFrameCarrier.current()\n\n/** Install the host default used by the main Runtime entrypoint. */\nexport const setDefaultRuntimeContextStorage = (storage: RuntimeContextStorage): void => {\n  defaultStorage = storage\n}\n\n/** Return the storage currently associated with the executing callback. */\nexport const activeRuntimeContextStorage = (): RuntimeContextStorage =>\n  currentRuntimeContextFrame()?.storage ?? defaultStorage\n\n/** Return the active context, or undefined when the storage has not been entered. */\nexport const getRuntimeContext = (\n  storage: RuntimeContextStorage = activeRuntimeContextStorage()\n): RuntimeContext | undefined => {\n  const frame = currentRuntimeContextFrame()\n\n  if (frame?.storage === storage) {\n    return frame.context\n  }\n\n  try {\n    return storage.current()\n  } catch (cause) {\n    if (cause instanceof RuntimeContextNotConfiguredError) {\n      return undefined\n    }\n\n    throw cause\n  }\n}\n\n/** Return the active context or throw the storage's standard missing-context error. */\nexport const currentRuntimeContext = (): RuntimeContext => {\n  const frame = currentRuntimeContextFrame()\n\n  return frame?.context ?? defaultStorage.current()\n}\n\n/** Keep a storage discoverable to Service and Scope compatibility bridges. */\nexport const withActiveRuntimeContextStorage = <A>(\n  storage: RuntimeContextStorage,\n  context: RuntimeContext,\n  program: () => A\n): A => {\n  const current = currentRuntimeContextFrame()\n\n  if (current?.storage === storage && current.context === context) {\n    return program()\n  }\n\n  const frame: ActiveRuntimeContextFrame =\n    current === undefined ? { storage, context } : { storage, context, parent: current }\n\n  return runtimeContextFrameCarrier.run(frame, program)\n}\n\n/** Run a callback in a context while keeping the selected storage discoverable to bridges. */\nexport const runRuntimeContext = <A>(\n  storage: RuntimeContextStorage,\n  context: RuntimeContext,\n  program: () => A\n): A => {\n  const current = getRuntimeContext(storage)\n  const contextual =\n    current !== undefined && isDerivedRuntimeContext(current, context)\n      ? inheritRuntimeContextLineage(context, current)\n      : context\n\n  return storage.run(contextual, () =>\n    withActiveRuntimeContextStorage(storage, contextual, program)\n  )\n}\n"],"mappings":";;;AACA,IAAa,mCAAb,cAAsD,MAAM;CAC1D,cAAc;EACZ,MAAM,iEAAiE;EAEvE,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,6BAAb,cAAgD,MAAM;CACpD,cAAc;EACZ,MACE,sJACF;EAEA,KAAK,OAAO;CACd;AACF;;;ACUA,MAAM,oCAA2D;CAC/D,MAAM,UAAU,YAAY,QAAQ;CACpC,eAAe;EACb,MAAM,IAAI,iCAAiC;CAC7C;AACF;AAEA,MAAM,kCAAkB,IAAI,QAAgC;;AAG5D,MAAa,gCACX,SACA,WACmB;CACnB,MAAM,UAAU,gBAAgB,IAAI,MAAM,KAAK;CAC/C,gBAAgB,IAAI,SAAS,OAAO;CACpC,OAAO;AACT;;AAGA,MAAa,4BAA4B,YACvC,gBAAgB,IAAI,OAAO;;AAG7B,MAAa,4BAA4B,YAA4C;CACnF,gBAAgB,IAAI,SAAS,OAAO;CACpC,OAAO;AACT;AAEA,MAAM,iBACJ,QACA,UAEA,MAAM,UAAU,OAAO,UAAU,OAAO,OAAO,OAAO,UAAU,MAAM,WAAW,KAAK;;AAGxF,MAAa,2BAA2B,QAAwB,UAC9D,OAAO,aAAa,KAAA,KACpB,MAAM,aAAa,OAAO,YAC1B,OAAO,eAAe,SAAS,KAC/B,cAAc,OAAO,gBAAgB,MAAM,cAAc,MACxD,MAAM,eAAe,SAAS,OAAO,eAAe,UAAU,MAAM,UAAU,OAAO;AAmBxF,SAAgB,mBACd,UACA,OACA,gBACA,QACA,QACA,aACgB;CAChB,MAAM,UAA0B,EAAE,eAAe;CACjD,MAAM,mBAAmB,eAAe,QAAQ;CAEhD,IAAI,aAAa,KAAA,GACf,OAAO,OAAO,SAAS,EAAE,SAAS,CAAC;CAGrC,IAAI,UAAU,KAAA,GACZ,OAAO,OAAO,SAAS,EAAE,MAAM,CAAC;CAGlC,IAAI,WAAW,KAAA,GACb,OAAO,OAAO,SAAS,EAAE,OAAO,CAAC;CAGnC,IAAI,qBAAqB,KAAA,GACvB,OAAO,OAAO,SAAS,EAAE,aAAa,iBAAiB,CAAC;CAG1D,IAAI,WAAW,KAAA,GACb,6BAA6B,SAAS,MAAM;CAG9C,OAAO;AACT;AAeA,IAAI,iBAAiB;AACrB,IAAI;AACJ,MAAM,iCAAiB,IAAI,IAA+B;AAE1D,MAAM,4BAA+B,OAAU,YAA2B;CACxE,IAAI;CAEJ,IAAI;EACF,cAAc,cAAc,KAAK;CACnC,SAAS,OAAO;EACd,QAAQ;EACR,MAAM;CACR;CAEA,IAAI,CAAC,aAAa;EAChB,QAAQ;EACR,OAAO;CACT;CAEA,IAAI;EAEF,OAAO,QAAQ,QAAQ,KAAK,CAAC,CAAC,MAC3B,aAAa;GACZ,QAAQ;GACR,OAAO;EACT,IACC,UAAU;GACT,QAAQ;GACR,MAAM;EACR,CACF;CACF,SAAS,OAAO;EACd,QAAQ;EACR,MAAM;CACR;AACF;AAEA,MAAM,wBAAwB,UAA2C;CACvE,eAAe,OAAO,KAAK;CAE3B,IAAI,kBAAkB,OACpB;CAGF,IAAI,SAAS,MAAM;CAEnB,OAAO,WAAW,KAAA,KAAa,CAAC,eAAe,IAAI,MAAM,GACvD,SAAS,OAAO;CAGlB,gBAAgB;AAClB;AAEA,MAAM,qCAAiE;CACrE,IAAO,OAAkC,SAAqB;EAC5D,eAAe,IAAI,KAAK;EACxB,gBAAgB;EAChB,MAAM,gBAAsB,qBAAqB,KAAK;EAEtD,IAAI;GACF,OAAO,yBAAyB,QAAQ,GAAG,OAAO;EACpD,SAAS,OAAO;GACd,QAAQ;GACR,MAAM;EACR;CACF;CAEA,eAAe;AACjB;AAEA,IAAI,6BAAyD;;AAG7D,MAAa,iCAAiC,YAA8C;CAC1F,6BAA6B;AAC/B;;AAGA,MAAa,8CACX,+BAA+B;;AAGjC,MAAa,mCACX,2BAA2B,QAAQ;;AAGrC,MAAa,mCAAmC,YAAyC;CACvF,iBAAiB;AACnB;;AAGA,MAAa,oCACX,2BAA2B,CAAC,EAAE,WAAW;;AAG3C,MAAa,qBACX,UAAiC,4BAA4B,MAC9B;CAC/B,MAAM,QAAQ,2BAA2B;CAEzC,IAAI,OAAO,YAAY,SACrB,OAAO,MAAM;CAGf,IAAI;EACF,OAAO,QAAQ,QAAQ;CACzB,SAAS,OAAO;EACd,IAAI,iBAAiB,kCACnB;EAGF,MAAM;CACR;AACF;;AAGA,MAAa,8BAA8C;CAGzD,OAFc,2BAEH,CAAC,EAAE,WAAW,eAAe,QAAQ;AAClD;;AAGA,MAAa,mCACX,SACA,SACA,YACM;CACN,MAAM,UAAU,2BAA2B;CAE3C,IAAI,SAAS,YAAY,WAAW,QAAQ,YAAY,SACtD,OAAO,QAAQ;CAGjB,MAAM,QACJ,YAAY,KAAA,IAAY;EAAE;EAAS;CAAQ,IAAI;EAAE;EAAS;EAAS,QAAQ;CAAQ;CAErF,OAAO,2BAA2B,IAAI,OAAO,OAAO;AACtD;;AAGA,MAAa,qBACX,SACA,SACA,YACM;CACN,MAAM,UAAU,kBAAkB,OAAO;CACzC,MAAM,aACJ,YAAY,KAAA,KAAa,wBAAwB,SAAS,OAAO,IAC7D,6BAA6B,SAAS,OAAO,IAC7C;CAEN,OAAO,QAAQ,IAAI,kBACjB,gCAAgC,SAAS,YAAY,OAAO,CAC9D;AACF"}

package/dist/current-request-CIU7AHhF.d.mts

@@ -0,0 +1,22 @@
+import { H as ServiceToken, I as ServiceIdentity, b as Service, j as ServiceRequirement } from "./index-AiKM71-u.mjs";
+import { A as ProviderEntry, x as LayerResult } from "./outcome-DI8LPIQ4.mjs";
+import "./index-BodMy6rO.mjs";
+//#region src/standard-services/current-request.d.ts
+declare const CurrentRequest_base: (abstract new () => ServiceIdentity<"CurrentRequest">) & {
+  readonly name: string;
+  readonly serviceTag: "CurrentRequest";
+} & {
+  readonly of: Service.FactoryOf<CurrentRequest, "CurrentRequest">;
+  readonly [Symbol.asyncIterator]: (this: ServiceToken<"CurrentRequest", CurrentRequest & ServiceIdentity<"CurrentRequest">>) => AsyncGenerator<ServiceRequirement<CurrentRequest>, CurrentRequest, unknown>;
+};
+/** Execution-local request value carried by a normal Service provider. */
+declare class CurrentRequest extends CurrentRequest_base {
+  readonly value: unknown;
+  readonly request: unknown;
+  constructor(value: unknown);
+  static layer(value: unknown): LayerResult<ProviderEntry<CurrentRequest, never>>;
+}
+declare const CurrentRequestLayer: (value: unknown) => LayerResult<ProviderEntry<CurrentRequest, never>>;
+//#endregion
+export { CurrentRequestLayer as n, CurrentRequest as t };
+//# sourceMappingURL=current-request-CIU7AHhF.d.mts.map

package/dist/current-request-CIU7AHhF.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-request-CIU7AHhF.d.mts","names":[],"sources":["../src/standard-services/current-request.ts"],"mappings":";;;;;;;;;;;;cAIa,uBAAuB;WAIb;WAHZ;EAGY,YAAA;SAMd,MAAM,iBAAc,YAAA,cAAA;;cAMhB,sBAAuB,mBAAc,YAAA,cAAA"}

package/dist/current-request-DDKNyymv.mjs

@@ -0,0 +1,20 @@
+import { n as Service, t as Layer } from "./layer-D16GKxuX.mjs";
+//#region src/standard-services/current-request.ts
+/** Execution-local request value carried by a normal Service provider. */
+var CurrentRequest = class CurrentRequest extends Service()("CurrentRequest") {
+	value;
+	request;
+	constructor(value) {
+		super();
+		this.value = value;
+		this.request = value;
+	}
+	static layer(value) {
+		return Layer.succeed(CurrentRequest, new CurrentRequest(value));
+	}
+};
+const CurrentRequestLayer = (value) => CurrentRequest.layer(value);
+//#endregion
+export { CurrentRequestLayer as n, CurrentRequest as t };
+
+//# sourceMappingURL=current-request-DDKNyymv.mjs.map

package/dist/current-request-DDKNyymv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-request-DDKNyymv.mjs","names":[],"sources":["../src/standard-services/current-request.ts"],"sourcesContent":["import { Layer } from '../layer'\nimport { Service } from '../service'\n\n/** Execution-local request value carried by a normal Service provider. */\nexport class CurrentRequest extends Service<CurrentRequest>()('CurrentRequest') {\n  readonly request: unknown\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  constructor(readonly value: unknown) {\n    super()\n    this.request = value\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  static layer(value: unknown) {\n    return Layer.succeed(CurrentRequest, new CurrentRequest(value))\n  }\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters\nexport const CurrentRequestLayer = (value: unknown) => CurrentRequest.layer(value)\n"],"mappings":";;;AAIA,IAAa,iBAAb,MAAa,uBAAuB,QAAwB,CAAC,CAAC,gBAAgB,CAAC,CAAC;CAIzD;CAHrB;CAGA,YAAY,OAAyB;EACnC,MAAM;EADa,KAAA,QAAA;EAEnB,KAAK,UAAU;CACjB;CAGA,OAAO,MAAM,OAAgB;EAC3B,OAAO,MAAM,QAAQ,gBAAgB,IAAI,eAAe,KAAK,CAAC;CAChE;AACF;AAGA,MAAa,uBAAuB,UAAmB,eAAe,MAAM,KAAK"}

package/dist/{signal-D2UTcaaG.mjs → disposable-CP-Q2H3l.mjs}

@@ -1,5 +1,5 @@
-import { d as setDefaultRuntimeContextStorage, n as currentRuntimeContext } from "./context-BUEf1qjL.mjs";
-import { n as nodeRuntimeContextStorage } from "./node-context-lggRF4bR.mjs";
+import { d as setDefaultRuntimeContextStorage } from "./context-BphfFUMO.mjs";
+import { n as nodeRuntimeContextStorage } from "./node-context-Ca18oNSg.mjs";
 //#region src/runtime/default.ts
 /** The Node/Bun storage used by the main Runtime entrypoint. */
 const defaultRuntimeContextStorage = nodeRuntimeContextStorage;
@@ -52,54 +52,6 @@ const disposeResource = (resource) => {
 	return getDisposeFinalizer(resource)?.(SCOPE_SUCCESS);
 };
 //#endregion
-//#region src/runtime/signal.ts
-const neverAbortedSignal = new AbortController().signal;
-/** Link caller, Runtime and shutdown signals without owning the caller's controller. */
-const linkAbortSignals = (...signals) => {
-	const active = signals.filter((signal) => signal !== void 0);
-	if (active.length === 0) return {
-		signal: neverAbortedSignal,
-		dispose: () => {}
-	};
-	if (active.length === 1) return {
-		signal: active[0],
-		dispose: () => {}
-	};
-	const controller = new AbortController();
-	const listeners = [];
-	let disposed = false;
-	const dispose = () => {
-		if (disposed) return;
-		disposed = true;
-		for (const [source, listener] of listeners) source.removeEventListener("abort", listener);
-		listeners.length = 0;
-	};
-	const abortFrom = (source) => {
-		if (controller.signal.aborted) return;
-		controller.abort(source.reason);
-		dispose();
-	};
-	for (const source of active) {
-		if (source.aborted) {
-			abortFrom(source);
-			break;
-		}
-		const listener = () => abortFrom(source);
-		listeners.push([source, listener]);
-		source.addEventListener("abort", listener, { once: true });
-	}
-	return {
-		signal: controller.signal,
-		dispose
-	};
-};
-/** Return the current cooperative-cancellation signal. */
-const currentAbortSignal = () => currentRuntimeContext().signal ?? neverAbortedSignal;
-/** Yieldable access to the signal of the current Runtime execution. */
-const CurrentAbortSignal = { *[Symbol.iterator]() {
-	return currentAbortSignal();
-} };
-//#endregion
-export { ResourceNotDisposableError as a, ScopeRuntimeNotConfiguredError as c, getDisposeFinalizer as i, defaultRuntimeContextStorage as l, linkAbortSignals as n, ScopeCloseError as o, disposeResource as r, ScopeClosedError as s, CurrentAbortSignal as t };
+export { ScopeClosedError as a, ScopeCloseError as i, getDisposeFinalizer as n, ScopeRuntimeNotConfiguredError as o, ResourceNotDisposableError as r, defaultRuntimeContextStorage as s, disposeResource as t };
 
-//# sourceMappingURL=signal-D2UTcaaG.mjs.map
+//# sourceMappingURL=disposable-CP-Q2H3l.mjs.map