apps 0.0.1-beta.0

package/js/chunk-OWD2YICM.js

@@ -0,0 +1,2486 @@
+import {
+  FetchHttpClient_exports
+} from "./chunk-VFUZI3NY.js";
+import {
+  HttpBody_exports,
+  HttpClient,
+  HttpClientError_exports,
+  HttpClientRequest_exports,
+  HttpClient_exports,
+  HttpServerResponse_exports,
+  HttpTraceContext_exports,
+  TracerPropagationEnabled,
+  filterStatusOk,
+  isHttpClientError,
+  jsonUnsafe,
+  post,
+  retryTransient,
+  setBody,
+  transformResponse,
+  uint8Array
+} from "./chunk-W7Q5EOTS.js";
+import {
+  Array as Array2,
+  Boolean2 as Boolean,
+  Clock,
+  Clock_exports,
+  Context_exports,
+  CurrentLogAnnotations,
+  CurrentLogSpans,
+  Effect_exports,
+  Exit_exports,
+  FiberSet_exports,
+  Headers_exports,
+  Int2 as Int,
+  Layer_exports,
+  Literals2 as Literals,
+  Logger_exports,
+  Metric_exports,
+  Option_exports,
+  Record2 as Record,
+  Redacted_exports,
+  Schema_exports,
+  Scope,
+  Semaphore_exports,
+  Service,
+  Stream_exports,
+  String as String2,
+  String2 as String3,
+  StringFromUriComponent,
+  Tracer,
+  Tracer_exports,
+  URL as URL2,
+  UndefinedOr,
+  addDelay,
+  addFinalizer,
+  all,
+  allocate,
+  andThen,
+  annotateLogs,
+  asVoid,
+  awaitEmpty,
+  await_,
+  catchCause,
+  context,
+  effect,
+  effectDiscard,
+  ensure,
+  firstSomeOf,
+  flatMap,
+  flatMap2,
+  flow,
+  fnUntraced,
+  forEach,
+  forever,
+  forever2,
+  forkIn,
+  format,
+  fromInput2 as fromInput,
+  fromInputUnsafe,
+  fromRecordUnsafe,
+  fromUndefinedOr,
+  gen,
+  get,
+  getOrUndefined,
+  hasInterruptsOnly,
+  identity,
+  ignore,
+  interruptible,
+  isSome,
+  layer,
+  logDebug,
+  make2 as make,
+  make7 as make2,
+  make8 as make3,
+  map,
+  map3 as map2,
+  map5 as map3,
+  max,
+  merge3 as merge,
+  millis,
+  option,
+  orDie,
+  orElse,
+  parse,
+  passthrough,
+  pretty,
+  prettyErrors,
+  provideMerge,
+  provideService,
+  randomHex,
+  run2 as run,
+  runtime,
+  schema,
+  seconds,
+  sleep,
+  snapshotUnsafe,
+  succeed3 as succeed,
+  succeed4 as succeed2,
+  suspend,
+  sync,
+  sync2,
+  timeoutOption,
+  unwrap,
+  void_2 as void_,
+  withDefault2 as withDefault,
+  withTracerEnabled,
+  zero
+} from "./chunk-2OTCEKL2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../telemetry/src/context.ts
+var captureTelemetry = Effect_exports.gen(function* () {
+  let context2 = Context_exports.make(Tracer_exports.Tracer, yield* Tracer_exports.Tracer).pipe(
+    Context_exports.add(Logger_exports.CurrentLoggers, yield* Logger_exports.CurrentLoggers),
+    Context_exports.add(Metric_exports.MetricRegistry, yield* Metric_exports.MetricRegistry)
+  );
+  const span = yield* Effect_exports.currentSpan.pipe(Effect_exports.option);
+  if (Option_exports.isSome(span)) context2 = Context_exports.add(context2, Tracer_exports.ParentSpan, span.value);
+  return { context: context2 };
+});
+var traceHeaders = Effect_exports.currentSpan.pipe(
+  Effect_exports.map(HttpTraceContext_exports.toHeaders),
+  Effect_exports.orElseSucceed(() => ({}))
+);
+var withRemoteSpan = (request, name) => (effect2) => effect2.pipe(
+  Effect_exports.withSpan(name, {
+    kind: "server",
+    parent: Option_exports.getOrUndefined(
+      HttpTraceContext_exports.fromHeaders(
+        Headers_exports.fromInput({ traceparent: request.headers.get("traceparent") ?? void 0 })
+      )
+    )
+  })
+);
+var invocationFetch = (signal) => Effect_exports.gen(function* () {
+  const { context: context2 } = yield* captureTelemetry;
+  return (input, init) => Effect_exports.runPromiseWith(context2)(
+    Effect_exports.gen(function* () {
+      const request = yield* Effect_exports.try(() => new Request(input, init));
+      const client = yield* HttpClient_exports.HttpClient;
+      const response = yield* client.execute(HttpClientRequest_exports.fromWeb(request)).pipe(
+        Effect_exports.withSpan("provider.http.request", {
+          attributes: { "http.request.method": request.method }
+        }),
+        Effect_exports.provideService(FetchHttpClient_exports.RequestInit, {
+          cache: request.cache,
+          credentials: request.credentials,
+          integrity: request.integrity,
+          keepalive: request.keepalive,
+          mode: request.mode,
+          redirect: request.redirect,
+          referrer: request.referrer,
+          referrerPolicy: request.referrerPolicy
+        }),
+        Effect_exports.provideService(
+          FetchHttpClient_exports.Fetch,
+          (url, options) => globalThis.fetch(url, {
+            ...options,
+            signal: AbortSignal.any([
+              signal,
+              request.signal,
+              ...options?.signal ? [options.signal] : []
+            ])
+          })
+        )
+      );
+      const streamed = HttpServerResponse_exports.fromClientResponse(response);
+      const body = streamed.body;
+      const traced = body instanceof HttpBody_exports.Stream ? HttpServerResponse_exports.setBody(
+        streamed,
+        HttpBody_exports.stream(
+          body.stream.pipe(
+            Stream_exports.withSpan("provider.http.response.read", {
+              attributes: { "http.response.status_code": response.status }
+            })
+          ),
+          body.contentType,
+          body.contentLength
+        )
+      ) : streamed;
+      return HttpServerResponse_exports.toWeb(traced, {
+        withoutBody: request.method === "HEAD",
+        context: context2
+      });
+    }).pipe(Effect_exports.provide(FetchHttpClient_exports.layer)),
+    { signal }
+  );
+});
+
+// ../telemetry/src/config.ts
+var Endpoint = Schema_exports.String.check(
+  Schema_exports.makeFilter(
+    (value) => {
+      const url = URL.parse(value);
+      return url !== null && ["http:", "https:"].includes(url.protocol) && url.username === "" && url.password === "";
+    },
+    { message: "Expected an HTTP telemetry endpoint without URL credentials" }
+  )
+);
+var TelemetryTarget = Schema_exports.Struct({
+  url: Endpoint,
+  headers: Schema_exports.optional(Schema_exports.RedactedFromValue(Schema_exports.Record(Schema_exports.String, Schema_exports.String)))
+});
+var TelemetryConfig = Schema_exports.Struct({
+  service: Schema_exports.NonEmptyString,
+  version: Schema_exports.NonEmptyString,
+  environment: Schema_exports.NonEmptyString,
+  clock: Schema_exports.optional(Schema_exports.Literals(["system", "cloudflare-io"])),
+  traces: Schema_exports.optional(TelemetryTarget),
+  logs: Schema_exports.optional(TelemetryTarget),
+  metrics: Schema_exports.optional(TelemetryTarget),
+  metricsProtocol: Schema_exports.optional(Schema_exports.Literals(["http/json", "http/protobuf"]))
+});
+var CurrentTelemetryConfig = Context_exports.Reference(
+  "executor/TelemetryConfig",
+  { defaultValue: () => void 0 }
+);
+
+// ../../node_modules/.bun/@bufbuild+protobuf@2.11.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
+function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  lowBits |= (middleByte & 15) << 28;
+  highBits = (middleByte & 112) >> 4;
+  if ((middleByte & 128) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 127) << shift;
+    if ((b & 128) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+var TWO_PWR_32_DBL = 4294967296;
+function int64FromString(dec) {
+  const minus = dec[0] === "-";
+  if (minus) {
+    dec = dec.slice(1);
+  }
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+function int64ToString(lo, hi) {
+  let bits = newBits(lo, hi);
+  const negative = bits.hi & 2147483648;
+  if (negative) {
+    bits = negate(bits.lo, bits.hi);
+  }
+  const result = uInt64ToString(bits.lo, bits.hi);
+  return negative ? "-" + result : result;
+}
+function uInt64ToString(lo, hi) {
+  ({ lo, hi } = toUnsigned(lo, hi));
+  if (hi <= 2097151) {
+    return String(TWO_PWR_32_DBL * hi + lo);
+  }
+  const low = lo & 16777215;
+  const mid = (lo >>> 24 | hi << 8) & 16777215;
+  const high = hi >> 16 & 65535;
+  let digitA = low + mid * 6777216 + high * 6710656;
+  let digitB = mid + high * 8147497;
+  let digitC = high * 2;
+  const base = 1e7;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    digitC += Math.floor(digitB / base);
+    digitB %= base;
+  }
+  return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+  return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+  return { lo: lo | 0, hi: hi | 0 };
+}
+function negate(lowBits, highBits) {
+  highBits = ~highBits;
+  if (lowBits) {
+    lowBits = ~lowBits + 1;
+  } else {
+    highBits += 1;
+  }
+  return newBits(lowBits, highBits);
+}
+var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+  const partial = String(digit1e7);
+  return "0000000".slice(partial.length) + partial;
+};
+function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 127;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 7;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 14;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 127) << 21;
+  if ((b & 128) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 15) << 28;
+  for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 128) != 0)
+    throw new Error("invalid varint");
+  this.assertBounds();
+  return result >>> 0;
+}
+
+// ../../node_modules/.bun/@bufbuild+protobuf@2.11.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
+var protoInt64 = /* @__PURE__ */ makeInt64Support();
+function makeInt64Support() {
+  const dv = new DataView(new ArrayBuffer(8));
+  const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
+  if (ok) {
+    const MIN = BigInt("-9223372036854775808");
+    const MAX = BigInt("9223372036854775807");
+    const UMIN = BigInt("0");
+    const UMAX = BigInt("18446744073709551615");
+    return {
+      zero: BigInt(0),
+      supported: true,
+      parse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > MAX || bi < MIN) {
+          throw new Error(`invalid int64: ${value}`);
+        }
+        return bi;
+      },
+      uParse(value) {
+        const bi = typeof value == "bigint" ? value : BigInt(value);
+        if (bi > UMAX || bi < UMIN) {
+          throw new Error(`invalid uint64: ${value}`);
+        }
+        return bi;
+      },
+      enc(value) {
+        dv.setBigInt64(0, this.parse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      uEnc(value) {
+        dv.setBigInt64(0, this.uParse(value), true);
+        return {
+          lo: dv.getInt32(0, true),
+          hi: dv.getInt32(4, true)
+        };
+      },
+      dec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigInt64(0, true);
+      },
+      uDec(lo, hi) {
+        dv.setInt32(0, lo, true);
+        dv.setInt32(4, hi, true);
+        return dv.getBigUint64(0, true);
+      }
+    };
+  }
+  return {
+    zero: "0",
+    supported: false,
+    parse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return value;
+    },
+    uParse(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return value;
+    },
+    enc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertInt64String(value);
+      return int64FromString(value);
+    },
+    uEnc(value) {
+      if (typeof value != "string") {
+        value = value.toString();
+      }
+      assertUInt64String(value);
+      return int64FromString(value);
+    },
+    dec(lo, hi) {
+      return int64ToString(lo, hi);
+    },
+    uDec(lo, hi) {
+      return uInt64ToString(lo, hi);
+    }
+  };
+}
+function assertInt64String(value) {
+  if (!/^-?[0-9]+$/.test(value)) {
+    throw new Error("invalid int64: " + value);
+  }
+}
+function assertUInt64String(value) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new Error("invalid uint64: " + value);
+  }
+}
+
+// ../../node_modules/.bun/@bufbuild+protobuf@2.11.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
+var symbol = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
+function getTextEncoding() {
+  if (globalThis[symbol] == void 0) {
+    const te = new globalThis.TextEncoder();
+    const td = new globalThis.TextDecoder();
+    globalThis[symbol] = {
+      encodeUtf8(text) {
+        return te.encode(text);
+      },
+      decodeUtf8(bytes) {
+        return td.decode(bytes);
+      },
+      checkUtf8(text) {
+        try {
+          encodeURIComponent(text);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      }
+    };
+  }
+  return globalThis[symbol];
+}
+
+// ../../node_modules/.bun/@bufbuild+protobuf@2.11.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
+var WireType;
+(function(WireType3) {
+  WireType3[WireType3["Varint"] = 0] = "Varint";
+  WireType3[WireType3["Bit64"] = 1] = "Bit64";
+  WireType3[WireType3["LengthDelimited"] = 2] = "LengthDelimited";
+  WireType3[WireType3["StartGroup"] = 3] = "StartGroup";
+  WireType3[WireType3["EndGroup"] = 4] = "EndGroup";
+  WireType3[WireType3["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+var BinaryReader = class {
+  constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
+    this.decodeUtf8 = decodeUtf8;
+    this.varint64 = varint64read;
+    this.uint32 = varint32read;
+    this.buf = buf;
+    this.len = buf.length;
+    this.pos = 0;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  /**
+   * Reads a tag - field number and wire type.
+   */
+  tag() {
+    let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+    if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+      throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+    return [fieldNo, wireType];
+  }
+  /**
+   * Skip one element and return the skipped data.
+   *
+   * When skipping StartGroup, provide the tags field number to check for
+   * matching field number in the EndGroup tag.
+   */
+  skip(wireType, fieldNo) {
+    let start = this.pos;
+    switch (wireType) {
+      case WireType.Varint:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
+      case WireType.Bit64:
+        this.pos += 4;
+      case WireType.Bit32:
+        this.pos += 4;
+        break;
+      case WireType.LengthDelimited:
+        let len = this.uint32();
+        this.pos += len;
+        break;
+      case WireType.StartGroup:
+        for (; ; ) {
+          const [fn, wt] = this.tag();
+          if (wt === WireType.EndGroup) {
+            if (fieldNo !== void 0 && fn !== fieldNo) {
+              throw new Error("invalid end group tag");
+            }
+            break;
+          }
+          this.skip(wt, fn);
+        }
+        break;
+      default:
+        throw new Error("cant skip wire type " + wireType);
+    }
+    this.assertBounds();
+    return this.buf.subarray(start, this.pos);
+  }
+  /**
+   * Throws error if position in byte array is out of range.
+   */
+  assertBounds() {
+    if (this.pos > this.len)
+      throw new RangeError("premature EOF");
+  }
+  /**
+   * Read a `int32` field, a signed 32 bit varint.
+   */
+  int32() {
+    return this.uint32() | 0;
+  }
+  /**
+   * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+   */
+  sint32() {
+    let zze = this.uint32();
+    return zze >>> 1 ^ -(zze & 1);
+  }
+  /**
+   * Read a `int64` field, a signed 64-bit varint.
+   */
+  int64() {
+    return protoInt64.dec(...this.varint64());
+  }
+  /**
+   * Read a `uint64` field, an unsigned 64-bit varint.
+   */
+  uint64() {
+    return protoInt64.uDec(...this.varint64());
+  }
+  /**
+   * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+   */
+  sint64() {
+    let [lo, hi] = this.varint64();
+    let s = -(lo & 1);
+    lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
+    hi = hi >>> 1 ^ s;
+    return protoInt64.dec(lo, hi);
+  }
+  /**
+   * Read a `bool` field, a variant.
+   */
+  bool() {
+    let [lo, hi] = this.varint64();
+    return lo !== 0 || hi !== 0;
+  }
+  /**
+   * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+   */
+  fixed32() {
+    return this.view.getUint32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+   */
+  sfixed32() {
+    return this.view.getInt32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+   */
+  fixed64() {
+    return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+   */
+  sfixed64() {
+    return protoInt64.dec(this.sfixed32(), this.sfixed32());
+  }
+  /**
+   * Read a `float` field, 32-bit floating point number.
+   */
+  float() {
+    return this.view.getFloat32((this.pos += 4) - 4, true);
+  }
+  /**
+   * Read a `double` field, a 64-bit floating point number.
+   */
+  double() {
+    return this.view.getFloat64((this.pos += 8) - 8, true);
+  }
+  /**
+   * Read a `bytes` field, length-delimited arbitrary data.
+   */
+  bytes() {
+    let len = this.uint32(), start = this.pos;
+    this.pos += len;
+    this.assertBounds();
+    return this.buf.subarray(start, start + len);
+  }
+  /**
+   * Read a `string` field, length-delimited data converted to UTF-8 text.
+   */
+  string() {
+    return this.decodeUtf8(this.bytes());
+  }
+};
+
+// ../telemetry/src/measurements.ts
+var boundaries = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4, 3e4];
+var responseReady = Metric_exports.histogram("executor.http.response_ready_ms", {
+  boundaries,
+  attributes: { unit: "ms" },
+  description: "Handler entry to response headers in milliseconds; excludes streamed body lifetime."
+});
+var requests = Metric_exports.counter("executor.http.requests", { incremental: true });
+var exportFailures = Metric_exports.counter("executor.telemetry.export_failures", { incremental: true });
+var rejectedRecords = Metric_exports.counter("executor.telemetry.rejected_records", {
+  incremental: true
+});
+var workerCpu = Metric_exports.histogram("executor.worker.cpu_ms", {
+  boundaries,
+  attributes: { unit: "ms" },
+  description: "Native Worker CPU time in milliseconds."
+});
+var workerWall = Metric_exports.histogram("executor.worker.wall_ms", {
+  boundaries,
+  attributes: { unit: "ms" },
+  description: "Native Worker invocation wall time, including stream and cleanup lifetime, in milliseconds."
+});
+var recordExportFailure = (path, reason = "transport", records = 0) => {
+  const signal = path.endsWith("/traces") ? "traces" : path.endsWith("/logs") ? "logs" : path.endsWith("/metrics") ? "metrics" : "other";
+  return Metric_exports.update(Metric_exports.withAttributes(exportFailures, { signal, reason }), 1).pipe(
+    Effect_exports.andThen(
+      Metric_exports.update(Metric_exports.withAttributes(rejectedRecords, { signal, reason }), records)
+    ),
+    Effect_exports.andThen(
+      Effect_exports.logWarning("Telemetry export failed").pipe(
+        Effect_exports.annotateLogs({
+          "executor.telemetry.signal": signal,
+          "executor.telemetry.failure": reason,
+          "executor.telemetry.rejected_records": records
+        })
+      )
+    )
+  );
+};
+
+// ../telemetry/src/transport.ts
+var CurrentTelemetryClient = Context_exports.Reference(
+  "executor/TelemetryClient",
+  { defaultValue: () => void 0 }
+);
+var selectedClient = Layer_exports.unwrap(
+  CurrentTelemetryClient.pipe(
+    Effect_exports.map(
+      (client) => client === void 0 ? FetchHttpClient_exports.layer : Layer_exports.succeed(HttpClient_exports.HttpClient, client)
+    )
+  )
+);
+var Count = Schema_exports.Union([Schema_exports.Number, Schema_exports.NumberFromString]).check(
+  Schema_exports.isInt(),
+  Schema_exports.isGreaterThanOrEqualTo(0),
+  Schema_exports.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+var Acknowledgement = Schema_exports.Struct({
+  partialSuccess: Schema_exports.optional(
+    Schema_exports.Struct({
+      rejectedSpans: Schema_exports.optional(Count),
+      rejectedLogRecords: Schema_exports.optional(Count),
+      rejectedDataPoints: Schema_exports.optional(Count),
+      errorMessage: Schema_exports.optional(Schema_exports.String)
+    })
+  )
+});
+var protobufAcknowledgement = (bytes) => {
+  const reader = new BinaryReader(bytes);
+  let rejected = "0";
+  let message = "";
+  while (reader.pos < reader.len) {
+    const [field, wire] = reader.tag();
+    if (field !== 1 || wire !== WireType.LengthDelimited) {
+      reader.skip(wire, field);
+      continue;
+    }
+    const partial = new BinaryReader(reader.bytes());
+    while (partial.pos < partial.len) {
+      const [field2, wire2] = partial.tag();
+      if (field2 === 1 && wire2 === WireType.Varint) rejected = String(partial.int64());
+      else if (field2 === 2 && wire2 === WireType.LengthDelimited) message = partial.string();
+      else partial.skip(wire2, field2);
+    }
+  }
+  return { partialSuccess: { rejectedDataPoints: rejected, errorMessage: message } };
+};
+var acknowledge = (response) => Effect_exports.gen(function* () {
+  const bytes = new Uint8Array(yield* response.arrayBuffer);
+  const decoded = yield* Effect_exports.try({
+    try: () => {
+      if (bytes.byteLength === 0) return {};
+      if (response.headers["content-type"]?.includes("application/x-protobuf")) {
+        return protobufAcknowledgement(bytes);
+      }
+      return JSON.parse(new TextDecoder().decode(bytes));
+    },
+    catch: () => new HttpClientError_exports.HttpClientError({
+      reason: new HttpClientError_exports.DecodeError({
+        request: response.request,
+        response,
+        description: "Invalid OTLP acknowledgement"
+      })
+    })
+  });
+  const acknowledgement = yield* Schema_exports.decodeUnknownEffect(Acknowledgement)(decoded).pipe(
+    Effect_exports.mapError(
+      () => new HttpClientError_exports.HttpClientError({
+        reason: new HttpClientError_exports.DecodeError({
+          request: response.request,
+          response,
+          description: "Invalid OTLP acknowledgement"
+        })
+      })
+    )
+  );
+  const partial = acknowledgement.partialSuccess;
+  if (partial === void 0) return;
+  const rejected = (partial.rejectedSpans ?? 0) + (partial.rejectedLogRecords ?? 0) + (partial.rejectedDataPoints ?? 0);
+  if (rejected > 0 || partial.errorMessage)
+    yield* recordExportFailure(
+      new URL(response.request.url).pathname,
+      "partial-success",
+      rejected
+    );
+});
+var telemetryHttpClient = Layer_exports.effect(
+  HttpClient_exports.HttpClient,
+  HttpClient_exports.HttpClient.pipe(
+    Effect_exports.map(
+      (client) => client.pipe(
+        HttpClient_exports.filterStatusOk,
+        HttpClient_exports.transform(
+          (response, request) => response.pipe(
+            Effect_exports.tap(acknowledge),
+            Effect_exports.tapError(
+              (error) => recordExportFailure(
+                new URL(request.url).pathname,
+                HttpClientError_exports.isHttpClientError(error) && error.reason instanceof HttpClientError_exports.DecodeError ? "acknowledgement" : "transport"
+              )
+            ),
+            Effect_exports.onInterrupt(
+              () => recordExportFailure(new URL(request.url).pathname, "interrupted")
+            )
+          )
+        ),
+        HttpClient_exports.withScope,
+        HttpClient_exports.transformResponse(Effect_exports.scoped)
+      )
+    )
+  )
+).pipe(Layer_exports.provide(selectedClient));
+
+// ../telemetry/src/span-attributes.ts
+var LogicalOperationFailed = class extends Schema_exports.TaggedError()(
+  "LogicalOperationFailed",
+  {}
+) {
+};
+var httpNamespaces = ["http.", "url.", "server.", "client.", "user_agent."];
+var httpSpanAttributeAllowlist = /* @__PURE__ */ new Set([
+  "http.request.method",
+  "http.response.status_code",
+  "server.address",
+  "url.scheme",
+  // Path only. `url.full` and `url.query` carry the query string, so neither is listed.
+  "url.path",
+  "http.request.header.content-type",
+  "http.request.header.content-length",
+  "http.request.header.user-agent",
+  "http.response.header.content-type",
+  "http.response.header.content-length",
+  // The server tracer records the user agent a second time under its own name.
+  "user_agent.original"
+]);
+var spanAttributeAllowed = (key) => {
+  const name = key.toLowerCase();
+  return !httpNamespaces.some((namespace) => name.startsWith(namespace)) || httpSpanAttributeAllowlist.has(name);
+};
+var allowedEntries = (attributes) => Object.fromEntries(Object.entries(attributes).filter(([key]) => spanAttributeAllowed(key)));
+var allowlistedSpan = (span) => ({
+  _tag: "Span",
+  get name() {
+    return span.name;
+  },
+  get spanId() {
+    return span.spanId;
+  },
+  get traceId() {
+    return span.traceId;
+  },
+  get parent() {
+    return span.parent;
+  },
+  get annotations() {
+    return span.annotations;
+  },
+  get status() {
+    return span.status;
+  },
+  get attributes() {
+    return span.attributes;
+  },
+  get links() {
+    return span.links;
+  },
+  get sampled() {
+    return span.sampled;
+  },
+  get kind() {
+    return span.kind;
+  },
+  // A successful transport can carry a failed domain operation. The producer
+  // explicitly marks that outcome; arbitrary result payloads are never inspected.
+  end: (endTime, exit) => span.end(
+    endTime,
+    Exit_exports.isSuccess(exit) && span.attributes.get("executor.outcome") === "failed" ? Exit_exports.fail(new LogicalOperationFailed()) : exit
+  ),
+  attribute: (key, value) => {
+    if (spanAttributeAllowed(key)) span.attribute(key, value);
+  },
+  event: (name, startTime, attributes) => span.event(name, startTime, attributes === void 0 ? void 0 : allowedEntries(attributes)),
+  addLinks: (links) => span.addLinks(links)
+});
+var spanAttributes = (clock, recordAll = false) => Layer_exports.effect(Tracer_exports.Tracer)(
+  Tracer_exports.Tracer.pipe(
+    Effect_exports.map((tracer) => ({
+      ...tracer,
+      span: (options) => {
+        const span = allowlistedSpan(
+          tracer.span(recordAll ? { ...options, sampled: true } : options)
+        );
+        if (recordAll && Option_exports.isSome(options.parent) && options.parent.value._tag === "ExternalSpan")
+          span.attribute("executor.trace.parent_sampled", options.parent.value.sampled);
+        if (clock !== void 0) span.attribute("executor.clock.type", clock);
+        return span;
+      }
+    }))
+  )
+);
+var allowlistedSpans = spanAttributes();
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpLogger.js
+var OtlpLogger_exports = {};
+__export(OtlpLogger_exports, {
+  layer: () => layer2,
+  layerFromConfig: () => layerFromConfig,
+  make: () => make6
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/internal/otlpEnv.js
+var exporterList = (path) => Array2(String2, path).pipe(map3((_) => _.map((_2) => _2.toLowerCase().trim()).filter((_2) => _2 !== "")));
+var headersRecord = (path) => Record(String2, StringFromUriComponent, path);
+var headers = (signal) => headersRecord(`OTEL_EXPORTER_OTLP_${signal}_HEADERS`).pipe(orElse(() => headersRecord("OTEL_EXPORTER_OTLP_HEADERS")), withDefault(void 0));
+var endpoint = (signal) => URL2(`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`).pipe(orElse(() => URL2("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(map3((url) => {
+  const slash = url.pathname.endsWith("/") ? "" : "/";
+  url.pathname += `${slash}v1/${signal.toLowerCase()}`;
+  return url;
+}))), withDefault(void 0));
+var exporters = (signal) => exporterList(`OTEL_${signal}_EXPORTER`).pipe(withDefault([]));
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpExporter.js
+var OtlpExporter_exports = {};
+__export(OtlpExporter_exports, {
+  Flusher: () => Flusher,
+  layerFlusher: () => layerFlusher,
+  make: () => make4
+});
+var retryAfterDelay = (value) => {
+  const seconds2 = fromUndefinedOr(value).pipe(flatMap(parse));
+  if (isSome(seconds2)) {
+    return succeed2(seconds(seconds2.value));
+  }
+  if (value === void 0) {
+    return succeed2(seconds(5));
+  }
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) {
+    return succeed2(seconds(5));
+  }
+  return map2(Clock, (clock) => millis(Math.max(timestamp - clock.currentTimeMillisUnsafe(), 1)));
+};
+var policy = /* @__PURE__ */ forever.pipe(passthrough, /* @__PURE__ */ addDelay(({
+  output: error
+}) => {
+  if (isHttpClientError(error) && error.reason._tag === "StatusCodeError" && error.reason.response.status === 429) {
+    return retryAfterDelay(error.reason.response.headers["retry-after"]);
+  }
+  return succeed2(seconds(1));
+}));
+var Flusher = class extends (/* @__PURE__ */ Service()("effect/observability/OtlpExporter/Flusher")) {
+};
+var layerFlusher = /* @__PURE__ */ sync(Flusher, () => {
+  const registry = /* @__PURE__ */ new Set();
+  return {
+    flush: suspend(() => {
+      if (registry.size === 0) {
+        return void_;
+      }
+      return forEach(registry, identity, {
+        concurrency: "unbounded",
+        discard: true
+      });
+    }),
+    register: (run2) => flatMap2(Scope, (scope) => {
+      registry.add(run2);
+      return addFinalizer(scope, sync2(() => registry.delete(run2)));
+    })
+  };
+});
+var make4 = /* @__PURE__ */ fnUntraced(function* (options) {
+  const services = yield* context();
+  const clock = get(services, Clock);
+  const scope = get(services, Scope);
+  const exportInterval = max(fromInputUnsafe(options.exportInterval), zero);
+  let disabledUntil = void 0;
+  const client = filterStatusOk(get(services, HttpClient)).pipe(transformResponse(provideService(TracerPropagationEnabled, false)), retryTransient({
+    schedule: policy,
+    times: 3
+  }));
+  let headers2 = fromRecordUnsafe({
+    "user-agent": `effect-opentelemetry-${options.label}/0.0.0`
+  });
+  if (options.headers) {
+    headers2 = merge(fromInput(options.headers), headers2);
+  }
+  const request = post(options.url, {
+    headers: headers2
+  });
+  let buffer = [];
+  const runExport = suspend(() => {
+    if (disabledUntil !== void 0 && clock.currentTimeMillisUnsafe() < disabledUntil) {
+      return void_;
+    } else if (disabledUntil !== void 0) {
+      disabledUntil = void 0;
+    }
+    if (buffer.length === 0 && (options.maxBatchSize !== "disabled" || options.exportEmpty !== true)) {
+      return void_;
+    }
+    const items = buffer;
+    buffer = [];
+    const [body, onSuccess] = options.body(items);
+    return client.execute(setBody(request, body)).pipe(andThen(onSuccess), asVoid, withTracerEnabled(false));
+  }).pipe(catchCause((cause) => {
+    if (disabledUntil !== void 0) return void_;
+    disabledUntil = clock.currentTimeMillisUnsafe() + 6e4;
+    buffer = [];
+    return logDebug("Disabling exporter for 60 seconds", cause);
+  }), annotateLogs({
+    package: "@effect/opentelemetry",
+    module: options.label
+  }));
+  const exportFibers = yield* make2();
+  const runExportFork = yield* runtime(exportFibers)();
+  const flusher = yield* Flusher;
+  yield* flusher.register(runExport);
+  yield* addFinalizer(scope, suspend(() => {
+    if (disabledUntil !== void 0) return void_;
+    runExportFork(runExport);
+    return awaitEmpty(exportFibers);
+  }).pipe(ignore, interruptible, timeoutOption(options.shutdownTimeout)));
+  yield* sleep(exportInterval).pipe(andThen(run(exportFibers, runExport)), flatMap2(await_), forever2, forkIn(scope));
+  return {
+    push(data) {
+      if (disabledUntil !== void 0) return;
+      buffer.push(data);
+      if (options.maxBatchSize !== "disabled" && buffer.length >= options.maxBatchSize) {
+        runExportFork(runExport);
+      }
+    }
+  };
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpResource.js
+var make5 = (options) => {
+  const resourceAttributes = options.attributes ? entriesToAttributes(Object.entries(options.attributes)) : [];
+  resourceAttributes.push({
+    key: "service.name",
+    value: {
+      stringValue: options.serviceName
+    }
+  });
+  if (options.serviceVersion) {
+    resourceAttributes.push({
+      key: "service.version",
+      value: {
+        stringValue: options.serviceVersion
+      }
+    });
+  }
+  return {
+    attributes: resourceAttributes,
+    droppedAttributesCount: 0
+  };
+};
+var fromConfig = /* @__PURE__ */ fnUntraced(function* (options) {
+  const env = yield* Record(StringFromUriComponent, StringFromUriComponent, "OTEL_RESOURCE_ATTRIBUTES").pipe(withDefault(void 0));
+  const serviceName = options?.serviceName ?? options?.attributes?.["service.name"] ?? (yield* schema(UndefinedOr(String2), "OTEL_SERVICE_NAME")) ?? env?.["service.name"] ?? (yield* String3("OTEL_SERVICE_NAME"));
+  const serviceVersion = options?.serviceVersion ?? options?.attributes?.["service.version"] ?? (yield* schema(UndefinedOr(String2), "OTEL_SERVICE_VERSION")) ?? env?.["service.version"];
+  const attributes = {
+    ...env,
+    ...options?.attributes
+  };
+  delete attributes["service.name"];
+  delete attributes["service.version"];
+  return make5({
+    serviceName,
+    serviceVersion,
+    attributes
+  });
+}, orDie);
+var serviceNameUnsafe = (resource) => {
+  const serviceNameAttribute = resource.attributes.find((attr) => attr.key === "service.name");
+  if (!serviceNameAttribute || !serviceNameAttribute.value.stringValue) {
+    throw new Error("Resource does not contain a service name");
+  }
+  return serviceNameAttribute.value.stringValue;
+};
+var entriesToAttributes = (entries) => {
+  const attributes = [];
+  for (const [key, value] of entries) {
+    attributes.push({
+      key,
+      value: unknownToAttributeValue(value)
+    });
+  }
+  return attributes;
+};
+var unknownToAttributeValue = (value) => {
+  if (Array.isArray(value)) {
+    return {
+      arrayValue: {
+        values: value.map(unknownToAttributeValue)
+      }
+    };
+  }
+  switch (typeof value) {
+    case "string":
+      return {
+        stringValue: value
+      };
+    case "bigint":
+      return {
+        intValue: String(value)
+      };
+    case "number":
+      return Number.isInteger(value) ? {
+        intValue: value
+      } : {
+        doubleValue: value
+      };
+    case "boolean":
+      return {
+        boolValue: value
+      };
+    default:
+      return {
+        stringValue: format(value)
+      };
+  }
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpSerialization.js
+var OtlpSerialization_exports = {};
+__export(OtlpSerialization_exports, {
+  OtlpSerialization: () => OtlpSerialization,
+  layerJson: () => layerJson,
+  layerProtobuf: () => layerProtobuf
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/internal/protobuf.js
+var WireType2 = {
+  Varint: 0,
+  Fixed64: 1,
+  LengthDelimited: 2,
+  Fixed32: 5
+};
+var encodeTag = (fieldNumber, wireType) => fieldNumber << 3 | wireType;
+var encodeVarint = (value) => {
+  const bytes = [];
+  let n = typeof value === "bigint" ? value : BigInt(value);
+  if (n < BigInt(0)) {
+    n = BigInt.asUintN(64, n);
+  }
+  while (n > BigInt(127)) {
+    bytes.push(Number(n & BigInt(127)) | 128);
+    n >>= BigInt(7);
+  }
+  bytes.push(Number(n));
+  return new Uint8Array(bytes);
+};
+var encodeFixed64 = (value) => {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setBigUint64(0, value, true);
+  return bytes;
+};
+var encodeFixed32 = (value) => {
+  const bytes = new Uint8Array(4);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, value, true);
+  return bytes;
+};
+var encodeDouble = (value) => {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setFloat64(0, value, true);
+  return bytes;
+};
+var encodeString = (value) => new TextEncoder().encode(value);
+var encodeHexBytes = (hex) => {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+};
+var concat = (...arrays) => {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+};
+var varintField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType2.Varint)), encodeVarint(value));
+var boolField = (fieldNumber, value) => varintField(fieldNumber, value ? 1 : 0);
+var fixed64Field = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType2.Fixed64)), encodeFixed64(value));
+var fixed32Field = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType2.Fixed32)), encodeFixed32(value));
+var doubleField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType2.Fixed64)), encodeDouble(value));
+var lengthDelimitedField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType2.LengthDelimited)), encodeVarint(value.length), value);
+var stringField = (fieldNumber, value) => lengthDelimitedField(fieldNumber, encodeString(value));
+var bytesFieldFromHex = (fieldNumber, hex) => lengthDelimitedField(fieldNumber, encodeHexBytes(hex));
+var messageField = (fieldNumber, message) => lengthDelimitedField(fieldNumber, message);
+var repeatedField = (fieldNumber, values, encode) => concat(...values.map((v) => messageField(fieldNumber, encode(v))));
+var optionalStringField = (fieldNumber, value) => value !== void 0 && value !== "" ? stringField(fieldNumber, value) : new Uint8Array(0);
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/internal/otlpProtobuf.js
+var encodeAnyValue = (value) => {
+  if (value.stringValue !== void 0 && value.stringValue !== null) {
+    return stringField(1, value.stringValue);
+  }
+  if (value.boolValue !== void 0 && value.boolValue !== null) {
+    return boolField(2, value.boolValue);
+  }
+  if (value.intValue !== void 0 && value.intValue !== null) {
+    return varintField(3, BigInt(value.intValue));
+  }
+  if (value.doubleValue !== void 0 && value.doubleValue !== null) {
+    return doubleField(4, value.doubleValue);
+  }
+  if (value.arrayValue !== void 0) {
+    return messageField(5, encodeArrayValue(value.arrayValue));
+  }
+  if (value.kvlistValue !== void 0) {
+    return messageField(6, encodeKeyValueList(value.kvlistValue));
+  }
+  if (value.bytesValue !== void 0) {
+    return lengthDelimitedField(7, value.bytesValue);
+  }
+  return new Uint8Array(0);
+};
+var encodeArrayValue = (value) => repeatedField(1, value.values, encodeAnyValue);
+var encodeKeyValueList = (value) => repeatedField(1, value.values, encodeKeyValue);
+var encodeKeyValue = (kv) => concat(stringField(1, kv.key), messageField(2, encodeAnyValue(kv.value)));
+var encodeInstrumentationScope = (scope) => concat(stringField(1, scope.name), optionalStringField(2, scope.version), scope.attributes ? repeatedField(3, scope.attributes, encodeKeyValue) : new Uint8Array(0), scope.droppedAttributesCount ? varintField(4, scope.droppedAttributesCount) : new Uint8Array(0));
+var encodeResource = (resource) => concat(repeatedField(1, resource.attributes, encodeKeyValue), resource.droppedAttributesCount > 0 ? varintField(2, resource.droppedAttributesCount) : new Uint8Array(0));
+var encodeStatus = (status) => concat(optionalStringField(2, status.message), varintField(3, status.code));
+var encodeEvent = (event) => concat(fixed64Field(1, BigInt(event.timeUnixNano)), stringField(2, event.name), repeatedField(3, event.attributes, encodeKeyValue), event.droppedAttributesCount > 0 ? varintField(4, event.droppedAttributesCount) : new Uint8Array(0));
+var encodeLink = (link) => concat(bytesFieldFromHex(1, link.traceId), bytesFieldFromHex(2, link.spanId), optionalStringField(3, link.traceState), repeatedField(4, link.attributes, encodeKeyValue), link.droppedAttributesCount > 0 ? varintField(5, link.droppedAttributesCount) : new Uint8Array(0), link.flags !== void 0 ? fixed32Field(6, link.flags) : new Uint8Array(0));
+var encodeSpan = (span) => concat(bytesFieldFromHex(1, span.traceId), bytesFieldFromHex(2, span.spanId), optionalStringField(3, span.traceState), span.parentSpanId !== void 0 ? bytesFieldFromHex(4, span.parentSpanId) : new Uint8Array(0), stringField(5, span.name), varintField(6, span.kind), fixed64Field(7, BigInt(span.startTimeUnixNano)), fixed64Field(8, BigInt(span.endTimeUnixNano)), repeatedField(9, span.attributes, encodeKeyValue), span.droppedAttributesCount > 0 ? varintField(10, span.droppedAttributesCount) : new Uint8Array(0), repeatedField(11, span.events, encodeEvent), span.droppedEventsCount > 0 ? varintField(12, span.droppedEventsCount) : new Uint8Array(0), repeatedField(13, span.links, encodeLink), span.droppedLinksCount > 0 ? varintField(14, span.droppedLinksCount) : new Uint8Array(0), messageField(15, encodeStatus(span.status)), span.flags !== void 0 ? fixed32Field(16, span.flags) : new Uint8Array(0));
+var encodeScopeSpans = (scopeSpans) => concat(messageField(1, encodeInstrumentationScope(scopeSpans.scope)), repeatedField(2, scopeSpans.spans, encodeSpan), optionalStringField(3, scopeSpans.schemaUrl));
+var encodeResourceSpans = (resourceSpans) => concat(messageField(1, encodeResource(resourceSpans.resource)), repeatedField(2, resourceSpans.scopeSpans, encodeScopeSpans), optionalStringField(3, resourceSpans.schemaUrl));
+var encodeTracesData = (tracesData) => repeatedField(1, tracesData.resourceSpans, encodeResourceSpans);
+var encodeNumberDataPoint = (point) => concat(fixed64Field(2, BigInt(point.startTimeUnixNano)), fixed64Field(3, BigInt(point.timeUnixNano)), point.asDouble !== void 0 ? doubleField(4, point.asDouble) : new Uint8Array(0), point.asInt !== void 0 ? fixed64Field(6, BigInt(point.asInt)) : new Uint8Array(0), repeatedField(7, point.attributes, encodeKeyValue), point.flags !== void 0 ? varintField(8, point.flags) : new Uint8Array(0));
+var encodeHistogramDataPoint = (point) => {
+  const bucketCountsEncoded = concat(...point.bucketCounts.map((count) => fixed64Field(6, BigInt(count))));
+  const explicitBoundsEncoded = concat(...point.explicitBounds.map((bound) => doubleField(7, bound)));
+  return concat(fixed64Field(2, BigInt(point.startTimeUnixNano)), fixed64Field(3, BigInt(point.timeUnixNano)), fixed64Field(4, BigInt(point.count)), point.sum !== void 0 ? doubleField(5, point.sum) : new Uint8Array(0), bucketCountsEncoded, explicitBoundsEncoded, repeatedField(9, point.attributes, encodeKeyValue), point.flags !== void 0 ? varintField(10, point.flags) : new Uint8Array(0), point.min !== void 0 ? doubleField(11, point.min) : new Uint8Array(0), point.max !== void 0 ? doubleField(12, point.max) : new Uint8Array(0));
+};
+var encodeGauge = (gauge) => repeatedField(1, gauge.dataPoints, encodeNumberDataPoint);
+var encodeSum = (sum) => concat(repeatedField(1, sum.dataPoints, encodeNumberDataPoint), varintField(2, sum.aggregationTemporality), boolField(3, sum.isMonotonic));
+var encodeHistogram = (histogram) => concat(repeatedField(1, histogram.dataPoints, encodeHistogramDataPoint), varintField(2, histogram.aggregationTemporality));
+var encodeMetric = (metric) => concat(stringField(1, metric.name), optionalStringField(2, metric.description), optionalStringField(3, metric.unit), metric.gauge !== void 0 ? messageField(5, encodeGauge(metric.gauge)) : new Uint8Array(0), metric.sum !== void 0 ? messageField(7, encodeSum(metric.sum)) : new Uint8Array(0), metric.histogram !== void 0 ? messageField(9, encodeHistogram(metric.histogram)) : new Uint8Array(0));
+var encodeScopeMetrics = (scopeMetrics) => concat(messageField(1, encodeInstrumentationScope(scopeMetrics.scope)), repeatedField(2, scopeMetrics.metrics, encodeMetric), optionalStringField(3, scopeMetrics.schemaUrl));
+var encodeResourceMetrics = (resourceMetrics) => concat(messageField(1, encodeResource(resourceMetrics.resource)), repeatedField(2, resourceMetrics.scopeMetrics, encodeScopeMetrics), optionalStringField(3, resourceMetrics.schemaUrl));
+var encodeMetricsData = (metricsData) => repeatedField(1, metricsData.resourceMetrics, encodeResourceMetrics);
+var encodeLogRecord = (record) => concat(fixed64Field(1, BigInt(record.timeUnixNano)), record.severityNumber !== void 0 ? varintField(2, record.severityNumber) : new Uint8Array(0), optionalStringField(3, record.severityText), record.body !== void 0 ? messageField(5, encodeAnyValue(record.body)) : new Uint8Array(0), repeatedField(6, record.attributes, encodeKeyValue), record.droppedAttributesCount !== void 0 && record.droppedAttributesCount > 0 ? varintField(7, record.droppedAttributesCount) : new Uint8Array(0), record.flags !== void 0 ? fixed32Field(8, record.flags) : new Uint8Array(0), record.traceId !== void 0 && record.traceId !== "" ? bytesFieldFromHex(9, record.traceId) : new Uint8Array(0), record.spanId !== void 0 && record.spanId !== "" ? bytesFieldFromHex(10, record.spanId) : new Uint8Array(0), record.observedTimeUnixNano !== void 0 ? fixed64Field(11, BigInt(record.observedTimeUnixNano)) : new Uint8Array(0));
+var encodeScopeLogs = (scopeLogs) => concat(messageField(1, encodeInstrumentationScope(scopeLogs.scope)), repeatedField(2, scopeLogs.logRecords, encodeLogRecord), optionalStringField(3, scopeLogs.schemaUrl));
+var encodeResourceLogs = (resourceLogs) => concat(messageField(1, encodeResource(resourceLogs.resource)), repeatedField(2, resourceLogs.scopeLogs, encodeScopeLogs), optionalStringField(3, resourceLogs.schemaUrl));
+var encodeLogsData = (logsData) => repeatedField(1, logsData.resourceLogs, encodeResourceLogs);
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpSerialization.js
+var OtlpSerialization = class extends (/* @__PURE__ */ Service()("effect/observability/OtlpSerialization")) {
+};
+var layerJson = /* @__PURE__ */ succeed(OtlpSerialization, {
+  traces: (spans) => jsonUnsafe(spans),
+  metrics: (metrics) => jsonUnsafe(metrics),
+  logs: (logs) => jsonUnsafe(logs)
+});
+var layerProtobuf = /* @__PURE__ */ succeed(OtlpSerialization, {
+  traces: (spans) => uint8Array(encodeTracesData(spans), "application/x-protobuf"),
+  metrics: (metrics) => uint8Array(encodeMetricsData(metrics), "application/x-protobuf"),
+  logs: (logs) => uint8Array(encodeLogsData(logs), "application/x-protobuf")
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpLogger.js
+var make6 = /* @__PURE__ */ fnUntraced(function* (options) {
+  const serialization = yield* OtlpSerialization;
+  const otelResource = yield* fromConfig(options.resource);
+  const scope = {
+    name: serviceNameUnsafe(otelResource)
+  };
+  const exporter = yield* make4({
+    label: "OtlpLogger",
+    url: options.url,
+    headers: options.headers,
+    maxBatchSize: options.maxBatchSize ?? 1e3,
+    exportInterval: options.exportInterval ?? seconds(1),
+    body: (data) => [serialization.logs({
+      resourceLogs: [{
+        resource: otelResource,
+        scopeLogs: [{
+          scope,
+          logRecords: data
+        }]
+      }]
+    }), void_],
+    shutdownTimeout: options.shutdownTimeout ?? seconds(3)
+  });
+  const opts = {
+    excludeLogSpans: options.excludeLogSpans ?? false,
+    clock: yield* Clock
+  };
+  return make3((options2) => {
+    exporter.push(makeLogRecord(options2, opts));
+  });
+});
+var layer2 = (options) => layer([make6(options)], {
+  mergeWithExisting: options.mergeWithExisting ?? true
+}).pipe(provideMerge(layerFlusher));
+var layerFromConfig = (options) => gen(function* () {
+  const {
+    disabled,
+    endpoint: endpoint2,
+    exporters: exporters2
+  } = yield* all({
+    disabled: Boolean("OTEL_SDK_DISABLED").pipe(withDefault(false)),
+    endpoint: endpoint("LOGS"),
+    exporters: exporters("LOGS")
+  });
+  if (disabled || !endpoint2 || !exporters2.includes("otlp")) {
+    return layerFlusher;
+  }
+  const {
+    baseTimeout,
+    logsTimeout,
+    exportTimeout,
+    scheduleDelay,
+    maxBatchSize
+  } = yield* all({
+    baseTimeout: option(Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+    logsTimeout: option(Int("OTEL_EXPORTER_OTLP_LOGS_TIMEOUT")),
+    exportTimeout: option(Int("OTEL_BLRP_EXPORT_TIMEOUT")),
+    scheduleDelay: option(Int("OTEL_BLRP_SCHEDULE_DELAY")),
+    maxBatchSize: option(Int("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE"))
+  });
+  const shutdownTimeout = firstSomeOf([logsTimeout, baseTimeout, exportTimeout]).pipe(map((_) => millis(_)));
+  const exportInterval = map(scheduleDelay, (_) => millis(_));
+  return layer2({
+    url: endpoint2.toString(),
+    resource: options?.resource,
+    headers: options?.headers ?? (yield* headers("LOGS")),
+    exportInterval: getOrUndefined(exportInterval),
+    maxBatchSize: getOrUndefined(maxBatchSize),
+    shutdownTimeout: getOrUndefined(shutdownTimeout),
+    excludeLogSpans: options?.excludeLogSpans,
+    mergeWithExisting: options?.mergeWithExisting
+  });
+}).pipe(orDie, unwrap);
+var makeLogRecord = (options, opts) => {
+  const now = opts.clock.currentTimeNanosUnsafe();
+  const nanosString = now.toString();
+  const nowMillis = options.date.getTime();
+  const attributes = entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)));
+  attributes.push({
+    key: "fiberId",
+    value: {
+      intValue: options.fiber.id
+    }
+  });
+  if (!opts.excludeLogSpans) {
+    for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
+      attributes.push({
+        key: `logSpan.${label}`,
+        value: {
+          stringValue: `${nowMillis - startTime}ms`
+        }
+      });
+    }
+  }
+  if (options.cause.reasons.length > 0) {
+    attributes.push({
+      key: "log.error",
+      value: {
+        stringValue: pretty(options.cause)
+      }
+    });
+  }
+  const message = ensure(options.message);
+  const logRecord = {
+    severityNumber: logLevelToSeverityNumber(options.logLevel),
+    severityText: options.logLevel,
+    timeUnixNano: nanosString,
+    observedTimeUnixNano: nanosString,
+    attributes,
+    body: unknownToAttributeValue(message.length === 1 ? message[0] : message),
+    droppedAttributesCount: 0
+  };
+  if (options.fiber.cache.span) {
+    logRecord.traceId = options.fiber.cache.span.traceId;
+    logRecord.spanId = options.fiber.cache.span.spanId;
+  }
+  return logRecord;
+};
+var logLevelToSeverityNumber = (logLevel) => {
+  switch (logLevel) {
+    case "Trace":
+      return ESeverityNumber.SEVERITY_NUMBER_TRACE;
+    case "Debug":
+      return ESeverityNumber.SEVERITY_NUMBER_DEBUG;
+    case "Info":
+      return ESeverityNumber.SEVERITY_NUMBER_INFO;
+    case "Warn":
+      return ESeverityNumber.SEVERITY_NUMBER_WARN;
+    case "Error":
+      return ESeverityNumber.SEVERITY_NUMBER_ERROR;
+    case "Fatal":
+      return ESeverityNumber.SEVERITY_NUMBER_FATAL;
+    default:
+      return ESeverityNumber.SEVERITY_NUMBER_UNSPECIFIED;
+  }
+};
+var ESeverityNumber = {
+  /** Unspecified. Do NOT use as default */
+  SEVERITY_NUMBER_UNSPECIFIED: 0,
+  SEVERITY_NUMBER_TRACE: 1,
+  SEVERITY_NUMBER_TRACE2: 2,
+  SEVERITY_NUMBER_TRACE3: 3,
+  SEVERITY_NUMBER_TRACE4: 4,
+  SEVERITY_NUMBER_DEBUG: 5,
+  SEVERITY_NUMBER_DEBUG2: 6,
+  SEVERITY_NUMBER_DEBUG3: 7,
+  SEVERITY_NUMBER_DEBUG4: 8,
+  SEVERITY_NUMBER_INFO: 9,
+  SEVERITY_NUMBER_INFO2: 10,
+  SEVERITY_NUMBER_INFO3: 11,
+  SEVERITY_NUMBER_INFO4: 12,
+  SEVERITY_NUMBER_WARN: 13,
+  SEVERITY_NUMBER_WARN2: 14,
+  SEVERITY_NUMBER_WARN3: 15,
+  SEVERITY_NUMBER_WARN4: 16,
+  SEVERITY_NUMBER_ERROR: 17,
+  SEVERITY_NUMBER_ERROR2: 18,
+  SEVERITY_NUMBER_ERROR3: 19,
+  SEVERITY_NUMBER_ERROR4: 20,
+  SEVERITY_NUMBER_FATAL: 21,
+  SEVERITY_NUMBER_FATAL2: 22,
+  SEVERITY_NUMBER_FATAL3: 23,
+  SEVERITY_NUMBER_FATAL4: 24
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpMetrics.js
+var OtlpMetrics_exports = {};
+__export(OtlpMetrics_exports, {
+  layer: () => layer3,
+  layerFromConfig: () => layerFromConfig2,
+  make: () => make7
+});
+var make7 = /* @__PURE__ */ fnUntraced(function* (options) {
+  const clock = yield* Clock;
+  const serialization = yield* OtlpSerialization;
+  const startTimeNanos = yield* clock.currentTimeNanos;
+  const startTime = String(startTimeNanos);
+  const temporality = options.temporality ?? "cumulative";
+  const resource = yield* fromConfig(options.resource);
+  const metricsScope = {
+    name: serviceNameUnsafe(resource)
+  };
+  const services = yield* context();
+  let previousExportTimeNanos = startTimeNanos;
+  let previousCounterState = /* @__PURE__ */ new Map();
+  let previousHistogramState = /* @__PURE__ */ new Map();
+  let previousFrequencyState = /* @__PURE__ */ new Map();
+  let previousSummaryState = /* @__PURE__ */ new Map();
+  let snapshotSequence = 0;
+  let committedSnapshotSequence = -1;
+  const snapshot = () => {
+    const snapshot2 = snapshotUnsafe(services);
+    const currentSnapshotSequence = snapshotSequence++;
+    const nowNanos = clock.currentTimeNanosUnsafe();
+    const nowTime = String(nowNanos);
+    const nextCounterState = new Map(previousCounterState);
+    const nextHistogramState = new Map(previousHistogramState);
+    const nextFrequencyState = new Map(previousFrequencyState);
+    const nextSummaryState = new Map(previousSummaryState);
+    const metricData = [];
+    const metricDataByName = /* @__PURE__ */ new Map();
+    const addMetricData = (data) => {
+      metricData.push(data);
+      metricDataByName.set(data.name, data);
+    };
+    const isDelta = temporality === "delta";
+    const aggregationTemporalityEnum = isDelta ? EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA : EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE;
+    const intervalStartTime = isDelta ? String(previousExportTimeNanos) : startTime;
+    for (let i = 0, len = snapshot2.length; i < len; i++) {
+      const state = snapshot2[i];
+      const unit = state.attributes?.unit ?? state.attributes?.time_unit ?? "1";
+      const attributes = state.attributes ? entriesToAttributes(Object.entries(state.attributes)) : [];
+      const metricKey = makeMetricKey(state.id, state.attributes);
+      switch (state.type) {
+        case "Counter": {
+          const currentCount = state.state.count;
+          let reportValue = currentCount;
+          if (isDelta) {
+            const previousCount = previousCounterState.get(metricKey);
+            if (previousCount !== void 0) {
+              if (typeof currentCount === "bigint" && typeof previousCount === "bigint") {
+                reportValue = currentCount - previousCount;
+                if (state.state.incremental && reportValue < BigInt(0)) {
+                  reportValue = currentCount;
+                }
+              } else {
+                const curr = Number(currentCount);
+                const prev = Number(previousCount);
+                reportValue = curr - prev;
+                if (state.state.incremental && reportValue < 0) {
+                  reportValue = curr;
+                }
+              }
+            }
+            nextCounterState.set(metricKey, currentCount);
+          }
+          const dataPoint = {
+            attributes,
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime
+          };
+          if (typeof reportValue === "bigint") {
+            dataPoint.asInt = Number(reportValue);
+          } else {
+            dataPoint.asDouble = reportValue;
+          }
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id).sum.dataPoints.push(dataPoint);
+          } else {
+            addMetricData({
+              name: state.id,
+              description: state.description,
+              unit,
+              sum: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                isMonotonic: state.state.incremental,
+                dataPoints: [dataPoint]
+              }
+            });
+          }
+          break;
+        }
+        case "Gauge": {
+          const dataPoint = {
+            attributes,
+            startTimeUnixNano: startTime,
+            timeUnixNano: nowTime
+          };
+          if (typeof state.state.value === "bigint") {
+            dataPoint.asInt = Number(state.state.value);
+          } else {
+            dataPoint.asDouble = state.state.value;
+          }
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id).gauge.dataPoints.push(dataPoint);
+          } else {
+            addMetricData({
+              name: state.id,
+              description: state.description,
+              unit,
+              gauge: {
+                dataPoints: [dataPoint]
+              }
+            });
+          }
+          break;
+        }
+        case "Histogram": {
+          const size = state.state.buckets.length;
+          const currentBuckets = {
+            boundaries: allocate(size - 1),
+            counts: allocate(size)
+          };
+          let idx = 0;
+          let prev = 0;
+          for (const [boundary, value] of state.state.buckets) {
+            if (idx < size - 1) {
+              currentBuckets.boundaries[idx] = boundary;
+            }
+            currentBuckets.counts[idx] = value - prev;
+            prev = value;
+            idx++;
+          }
+          let reportCount = state.state.count;
+          let reportSum = state.state.sum;
+          let reportBucketCounts = currentBuckets.counts;
+          const reportMin = state.state.min;
+          const reportMax = state.state.max;
+          if (isDelta) {
+            const previousState = previousHistogramState.get(metricKey);
+            if (previousState !== void 0) {
+              reportCount = state.state.count - previousState.count;
+              reportSum = state.state.sum - previousState.sum;
+              reportBucketCounts = currentBuckets.counts.map((c, i2) => Math.max(0, c - (previousState.bucketCounts[i2] ?? 0)));
+            }
+            nextHistogramState.set(metricKey, {
+              count: state.state.count,
+              sum: state.state.sum,
+              bucketCounts: currentBuckets.counts.slice(),
+              min: state.state.min,
+              max: state.state.max
+            });
+          }
+          const dataPoint = {
+            attributes,
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime,
+            count: reportCount,
+            min: reportMin,
+            max: reportMax,
+            sum: reportSum,
+            bucketCounts: reportBucketCounts,
+            explicitBounds: currentBuckets.boundaries
+          };
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id).histogram.dataPoints.push(dataPoint);
+          } else {
+            addMetricData({
+              name: state.id,
+              description: state.description,
+              unit,
+              histogram: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                dataPoints: [dataPoint]
+              }
+            });
+          }
+          break;
+        }
+        case "Frequency": {
+          const dataPoints = [];
+          const currentOccurrences = /* @__PURE__ */ new Map();
+          for (const [freqKey, value] of state.state.occurrences) {
+            currentOccurrences.set(freqKey, value);
+            let reportValue = value;
+            if (isDelta) {
+              const previousOccurrences = previousFrequencyState.get(metricKey);
+              if (previousOccurrences !== void 0) {
+                const previousValue = previousOccurrences.get(freqKey) ?? 0;
+                reportValue = Math.max(0, value - previousValue);
+              }
+            }
+            dataPoints.push({
+              attributes: [...attributes, {
+                key: "key",
+                value: {
+                  stringValue: freqKey
+                }
+              }],
+              startTimeUnixNano: intervalStartTime,
+              timeUnixNano: nowTime,
+              asInt: reportValue
+            });
+          }
+          if (isDelta) {
+            nextFrequencyState.set(metricKey, currentOccurrences);
+          }
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id).sum.dataPoints.push(...dataPoints);
+          } else {
+            addMetricData({
+              name: state.id,
+              description: state.description,
+              unit,
+              sum: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                isMonotonic: true,
+                dataPoints
+              }
+            });
+          }
+          break;
+        }
+        case "Summary": {
+          const dataPoints = [{
+            attributes: [...attributes, {
+              key: "quantile",
+              value: {
+                stringValue: "min"
+              }
+            }],
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime,
+            asDouble: state.state.min
+          }];
+          for (const [quantile, value] of state.state.quantiles) {
+            dataPoints.push({
+              attributes: [...attributes, {
+                key: "quantile",
+                value: {
+                  stringValue: quantile.toString()
+                }
+              }],
+              startTimeUnixNano: intervalStartTime,
+              timeUnixNano: nowTime,
+              asDouble: value ?? 0
+            });
+          }
+          dataPoints.push({
+            attributes: [...attributes, {
+              key: "quantile",
+              value: {
+                stringValue: "max"
+              }
+            }],
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime,
+            asDouble: state.state.max
+          });
+          let reportCount = state.state.count;
+          let reportSum = state.state.sum;
+          if (isDelta) {
+            const previousState = previousSummaryState.get(metricKey);
+            if (previousState !== void 0) {
+              reportCount = state.state.count - previousState.count;
+              reportSum = state.state.sum - previousState.sum;
+            }
+            nextSummaryState.set(metricKey, {
+              count: state.state.count,
+              sum: state.state.sum
+            });
+          }
+          const countDataPoint = {
+            attributes,
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime,
+            asInt: reportCount
+          };
+          const sumDataPoint = {
+            attributes,
+            startTimeUnixNano: intervalStartTime,
+            timeUnixNano: nowTime,
+            asDouble: reportSum
+          };
+          if (metricDataByName.has(`${state.id}_quantiles`)) {
+            metricDataByName.get(`${state.id}_quantiles`).sum.dataPoints.push(...dataPoints);
+            metricDataByName.get(`${state.id}_count`).sum.dataPoints.push(countDataPoint);
+            metricDataByName.get(`${state.id}_sum`).sum.dataPoints.push(sumDataPoint);
+          } else {
+            addMetricData({
+              name: `${state.id}_quantiles`,
+              description: state.description,
+              unit,
+              sum: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                isMonotonic: false,
+                dataPoints
+              }
+            });
+            addMetricData({
+              name: `${state.id}_count`,
+              description: state.description,
+              unit: "1",
+              sum: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                isMonotonic: true,
+                dataPoints: [countDataPoint]
+              }
+            });
+            addMetricData({
+              name: `${state.id}_sum`,
+              description: state.description,
+              unit: "1",
+              sum: {
+                aggregationTemporality: aggregationTemporalityEnum,
+                isMonotonic: true,
+                dataPoints: [sumDataPoint]
+              }
+            });
+          }
+          break;
+        }
+      }
+    }
+    const body = serialization.metrics({
+      resourceMetrics: [{
+        resource,
+        scopeMetrics: [{
+          scope: metricsScope,
+          metrics: metricData
+        }]
+      }]
+    });
+    const onSuccess = isDelta ? sync2(() => {
+      if (currentSnapshotSequence < committedSnapshotSequence) return;
+      previousCounterState = nextCounterState;
+      previousHistogramState = nextHistogramState;
+      previousFrequencyState = nextFrequencyState;
+      previousSummaryState = nextSummaryState;
+      previousExportTimeNanos = nowNanos;
+      committedSnapshotSequence = currentSnapshotSequence;
+    }) : void_;
+    return [body, onSuccess];
+  };
+  yield* make4({
+    label: "OtlpMetrics",
+    url: options.url,
+    headers: options.headers,
+    maxBatchSize: "disabled",
+    exportEmpty: true,
+    exportInterval: options.exportInterval ?? seconds(10),
+    body: snapshot,
+    shutdownTimeout: options.shutdownTimeout ?? seconds(3)
+  });
+});
+var layer3 = (options) => effectDiscard(make7(options)).pipe(provideMerge(layerFlusher));
+var layerFromConfig2 = (options) => gen(function* () {
+  const {
+    disabled,
+    endpoint: endpoint2,
+    exporters: exporters2
+  } = yield* all({
+    disabled: Boolean("OTEL_SDK_DISABLED").pipe(withDefault(false)),
+    endpoint: endpoint("METRICS"),
+    exporters: exporters("METRICS")
+  });
+  if (disabled || !endpoint2 || !exporters2.includes("otlp")) {
+    return layerFlusher;
+  }
+  const {
+    baseTimeout,
+    metricsTimeout,
+    exportTimeout,
+    exportInterval,
+    temporalityPreference
+  } = yield* all({
+    baseTimeout: option(Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+    metricsTimeout: option(Int("OTEL_EXPORTER_OTLP_METRICS_TIMEOUT")),
+    exportTimeout: option(Int("OTEL_METRIC_EXPORT_TIMEOUT")),
+    exportInterval: option(Int("OTEL_METRIC_EXPORT_INTERVAL").pipe(map3(millis))),
+    temporalityPreference: option(Literals(["delta", "cumulative"], "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE"))
+  });
+  const shutdownTimeout = firstSomeOf([metricsTimeout, baseTimeout, exportTimeout]).pipe(map((_) => millis(_)));
+  return layer3({
+    url: endpoint2.toString(),
+    resource: options?.resource,
+    headers: options?.headers ?? (yield* headers("METRICS")),
+    exportInterval: getOrUndefined(exportInterval),
+    shutdownTimeout: getOrUndefined(shutdownTimeout),
+    temporality: getOrUndefined(temporalityPreference)
+  });
+}).pipe(orDie, unwrap);
+var makeMetricKey = (id, attributes) => {
+  if (attributes === void 0 || Object.keys(attributes).length === 0) {
+    return id;
+  }
+  const sortedEntries = Object.entries(attributes).sort((a, b) => a[0].localeCompare(b[0]));
+  return `${id}:${JSON.stringify(sortedEntries)}`;
+};
+var EAggregationTemporality = {
+  AGGREGATION_TEMPORALITY_UNSPECIFIED: 0,
+  /** DELTA is an AggregationTemporality for a metric aggregator which reports
+    changes since last report time. Successive metrics contain aggregation of
+    values from continuous and non-overlapping intervals.
+       The values for a DELTA metric are based only on the time interval
+    associated with one measurement cycle. There is no dependency on
+    previous measurements like is the case for CUMULATIVE metrics.
+       For example, consider a system measuring the number of requests that
+    it receives and reports the sum of these requests every second as a
+    DELTA metric:
+       1. The system starts receiving at time=t_0.
+    2. A request is received, the system measures 1 request.
+    3. A request is received, the system measures 1 request.
+    4. A request is received, the system measures 1 request.
+    5. The 1 second collection cycle ends. A metric is exported for the
+        number of requests received over the interval of time t_0 to
+        t_0+1 with a value of 3.
+    6. A request is received, the system measures 1 request.
+    7. A request is received, the system measures 1 request.
+    8. The 1 second collection cycle ends. A metric is exported for the
+        number of requests received over the interval of time t_0+1 to
+        t_0+2 with a value of 2. */
+  AGGREGATION_TEMPORALITY_DELTA: 1,
+  /** CUMULATIVE is an AggregationTemporality for a metric aggregator which
+    reports changes since a fixed start time. This means that current values
+    of a CUMULATIVE metric depend on all previous measurements since the
+    start time. Because of this, the sender is required to retain this state
+    in some form. If this state is lost or invalidated, the CUMULATIVE metric
+    values MUST be reset and a new fixed start time following the last
+    reported measurement time sent MUST be used.
+       For example, consider a system measuring the number of requests that
+    it receives and reports the sum of these requests every second as a
+    CUMULATIVE metric:
+       1. The system starts receiving at time=t_0.
+    2. A request is received, the system measures 1 request.
+    3. A request is received, the system measures 1 request.
+    4. A request is received, the system measures 1 request.
+    5. The 1 second collection cycle ends. A metric is exported for the
+        number of requests received over the interval of time t_0 to
+        t_0+1 with a value of 3.
+    6. A request is received, the system measures 1 request.
+    7. A request is received, the system measures 1 request.
+    8. The 1 second collection cycle ends. A metric is exported for the
+        number of requests received over the interval of time t_0 to
+        t_0+2 with a value of 5.
+    9. The system experiences a fault and loses state.
+    10. The system recovers and resumes receiving at time=t_1.
+    11. A request is received, the system measures 1 request.
+    12. The 1 second collection cycle ends. A metric is exported for the
+        number of requests received over the interval of time t_1 to
+        t_0+1 with a value of 1.
+       Note: Even though, when reporting changes since last report time, using
+    CUMULATIVE is valid, it is not recommended. This may cause problems for
+    systems that do not use start_time to determine when the aggregation
+    value was reset (e.g. Prometheus). */
+  AGGREGATION_TEMPORALITY_CUMULATIVE: 2
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/observability/OtlpTracer.js
+var OtlpTracer_exports = {};
+__export(OtlpTracer_exports, {
+  layer: () => layer4,
+  layerFromConfig: () => layerFromConfig3,
+  make: () => make8
+});
+var make8 = /* @__PURE__ */ fnUntraced(function* (options) {
+  const otelResource = yield* fromConfig(options.resource);
+  const serialization = yield* OtlpSerialization;
+  const scope = {
+    name: serviceNameUnsafe(otelResource)
+  };
+  const exporter = yield* make4({
+    label: "OtlpTracer",
+    url: options.url,
+    headers: options.headers,
+    exportInterval: options.exportInterval ?? seconds(5),
+    maxBatchSize: options.maxBatchSize ?? 1e3,
+    body(spans) {
+      const data = {
+        resourceSpans: [{
+          resource: otelResource,
+          scopeSpans: [{
+            scope,
+            spans
+          }]
+        }]
+      };
+      return [serialization.traces(data), void_];
+    },
+    shutdownTimeout: options.shutdownTimeout ?? seconds(3)
+  });
+  function exportFn(span) {
+    if (!span.sampled) return;
+    exporter.push(makeOtlpSpan(span));
+  }
+  return make({
+    span(options2) {
+      return new SpanImpl(options2, exportFn);
+    },
+    context: options.context ? function(primitive, fiber) {
+      if (fiber.cache.span === void 0) {
+        return primitive["~effect/Effect/evaluate"](fiber);
+      }
+      return options.context(primitive, fiber.cache.span);
+    } : void 0
+  });
+});
+var layer4 = /* @__PURE__ */ flow(make8, /* @__PURE__ */ effect(Tracer), /* @__PURE__ */ provideMerge(layerFlusher));
+var layerFromConfig3 = (options) => gen(function* () {
+  const {
+    disabled,
+    endpoint: endpoint2,
+    exporters: exporters2
+  } = yield* all({
+    disabled: Boolean("OTEL_SDK_DISABLED").pipe(withDefault(false)),
+    endpoint: endpoint("TRACES"),
+    exporters: exporters("TRACES")
+  });
+  if (disabled || !endpoint2 || !exporters2.includes("otlp")) {
+    return layerFlusher;
+  }
+  const {
+    baseTimeout,
+    tracesTimeout,
+    exportTimeout,
+    scheduleDelay,
+    maxBatchSize
+  } = yield* all({
+    baseTimeout: option(Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+    tracesTimeout: option(Int("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT")),
+    exportTimeout: option(Int("OTEL_BSP_EXPORT_TIMEOUT")),
+    scheduleDelay: option(Int("OTEL_BSP_SCHEDULE_DELAY").pipe(map3(millis))),
+    maxBatchSize: option(Int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"))
+  });
+  const shutdownTimeout = firstSomeOf([tracesTimeout, baseTimeout, exportTimeout]).pipe(map((_) => millis(_)));
+  return layer4({
+    url: endpoint2.toString(),
+    resource: options?.resource,
+    headers: options?.headers ?? (yield* headers("TRACES")),
+    exportInterval: getOrUndefined(scheduleDelay),
+    maxBatchSize: getOrUndefined(maxBatchSize),
+    context: options?.context,
+    shutdownTimeout: getOrUndefined(shutdownTimeout)
+  });
+}).pipe(orDie, unwrap);
+var SpanImpl = class {
+  _tag = "Span";
+  name;
+  parent;
+  annotations;
+  links;
+  kind;
+  sampled;
+  export;
+  status;
+  _traceId = void 0;
+  _spanId = void 0;
+  _attributes = void 0;
+  _events = void 0;
+  constructor(options, exportFn) {
+    this.name = options.name;
+    this.parent = options.parent;
+    this.annotations = options.annotations;
+    this.links = options.links;
+    this.kind = options.kind;
+    this.sampled = options.sampled;
+    this.export = exportFn;
+    this.status = {
+      _tag: "Started",
+      startTime: options.startTime
+    };
+  }
+  get traceId() {
+    return this._traceId ??= isSome(this.parent) ? this.parent.value.traceId : randomHex(32);
+  }
+  get spanId() {
+    return this._spanId ??= randomHex(16);
+  }
+  get attributes() {
+    return this._attributes ??= /* @__PURE__ */ new Map();
+  }
+  get events() {
+    return this._events ??= [];
+  }
+  end(endTime, exit) {
+    this.status = {
+      _tag: "Ended",
+      startTime: this.status.startTime,
+      endTime,
+      exit
+    };
+    this.export(this);
+  }
+  attribute(key, value) {
+    this.attributes.set(key, value);
+  }
+  event(name, startTime, attributes) {
+    this.events.push([name, startTime, attributes]);
+  }
+  addLinks(links) {
+    this.links.push(...links);
+  }
+};
+var makeOtlpSpan = (self) => {
+  const status = self.status;
+  const attributes = self._attributes === void 0 ? [] : entriesToAttributes(self._attributes);
+  const events = [];
+  if (self._events !== void 0) {
+    for (let i = 0; i < self._events.length; i++) {
+      const [name, startTime, attributes2] = self._events[i];
+      events.push({
+        name,
+        timeUnixNano: String(startTime),
+        attributes: attributes2 ? entriesToAttributes(Object.entries(attributes2)) : [],
+        droppedAttributesCount: 0
+      });
+    }
+  }
+  let otelStatus;
+  if (status.exit._tag === "Success") {
+    otelStatus = {
+      code: StatusCode.Ok
+    };
+  } else if (hasInterruptsOnly(status.exit.cause)) {
+    otelStatus = {
+      code: StatusCode.Ok,
+      message: "Interrupted"
+    };
+    attributes.push({
+      key: "span.label",
+      value: {
+        stringValue: "\u26A0\uFE0E Interrupted"
+      }
+    }, {
+      key: "status.interrupted",
+      value: {
+        boolValue: true
+      }
+    });
+  } else {
+    const errors = prettyErrors(status.exit.cause, {
+      includeCauseInStack: true
+    });
+    otelStatus = {
+      code: StatusCode.Error
+    };
+    if (errors.length > 0) {
+      otelStatus.message = errors[0].message;
+      for (const error of errors) {
+        events.push({
+          name: "exception",
+          timeUnixNano: String(status.endTime),
+          droppedAttributesCount: 0,
+          attributes: [{
+            "key": "exception.type",
+            "value": {
+              "stringValue": error.name
+            }
+          }, {
+            "key": "exception.message",
+            "value": {
+              "stringValue": error.message
+            }
+          }, {
+            "key": "exception.stacktrace",
+            "value": {
+              "stringValue": error.stack ?? "No stack trace available"
+            }
+          }]
+        });
+      }
+    }
+  }
+  const links = [];
+  for (let i = 0; i < self.links.length; i++) {
+    const link = self.links[i];
+    links.push({
+      traceId: link.span.traceId,
+      spanId: link.span.spanId,
+      attributes: entriesToAttributes(Object.entries(link.attributes)),
+      droppedAttributesCount: 0
+    });
+  }
+  return {
+    traceId: self.traceId,
+    spanId: self.spanId,
+    parentSpanId: isSome(self.parent) ? self.parent.value.spanId : void 0,
+    name: self.name,
+    kind: SpanKind[self.kind],
+    startTimeUnixNano: String(status.startTime),
+    endTimeUnixNano: String(status.endTime),
+    attributes,
+    droppedAttributesCount: 0,
+    events,
+    droppedEventsCount: 0,
+    status: otelStatus,
+    links,
+    droppedLinksCount: 0
+  };
+};
+var StatusCode = {
+  Unset: 0,
+  Ok: 1,
+  Error: 2
+};
+var SpanKind = {
+  unspecified: 0,
+  internal: 1,
+  server: 2,
+  client: 3,
+  producer: 4,
+  consumer: 5
+};
+
+// ../telemetry/src/layer.ts
+var telemetryLayer = (config, lifetime = "process", logger = Logger_exports.withConsoleError(Logger_exports.formatJson)) => {
+  const resource = {
+    serviceName: config.service,
+    serviceVersion: config.version,
+    attributes: { "deployment.environment.name": config.environment }
+  };
+  const signal = (target) => ({
+    url: target.url,
+    resource,
+    ...target.headers === void 0 ? {} : { headers: Redacted_exports.value(target.headers) },
+    exportInterval: lifetime === "event" ? "1 hour" : "1 second",
+    shutdownTimeout: "3 seconds"
+  });
+  const console = Logger_exports.layer([logger]);
+  return Layer_exports.mergeAll(
+    Layer_exports.succeed(CurrentTelemetryConfig, config),
+    config.traces === void 0 ? Layer_exports.empty : (
+      // Credentials travel in provider headers and query strings this product does
+      // not choose, so every exported span records only allowlisted HTTP attributes.
+      // Record every operation. Caller-supplied sampling is correlation metadata,
+      // not authority to suppress server diagnostics.
+      spanAttributes(config.clock, true).pipe(
+        Layer_exports.provideMerge(
+          OtlpTracer_exports.layer(signal(config.traces)).pipe(
+            Layer_exports.provide(OtlpSerialization_exports.layerJson)
+          )
+        )
+      )
+    ),
+    config.logs === void 0 ? console : OtlpLogger_exports.layer({
+      ...signal(config.logs),
+      mergeWithExisting: true
+    }).pipe(Layer_exports.provide(OtlpSerialization_exports.layerJson), Layer_exports.provideMerge(console)),
+    config.metrics === void 0 ? Layer_exports.empty : OtlpMetrics_exports.layer({
+      ...signal(config.metrics),
+      exportInterval: "30 seconds",
+      temporality: "delta"
+    }).pipe(
+      Layer_exports.provide(
+        config.metricsProtocol === "http/json" ? OtlpSerialization_exports.layerJson : OtlpSerialization_exports.layerProtobuf
+      )
+    )
+  ).pipe(
+    Layer_exports.provide(telemetryHttpClient),
+    // Export fibers capture services during construction. Their failure evidence
+    // must reach the host logger even after the remote log exporter is closed.
+    Layer_exports.provide(console),
+    // Each event exports only its own measurements; process hosts share a process registry.
+    Layer_exports.provideMerge(Layer_exports.sync(Metric_exports.MetricRegistry, () => /* @__PURE__ */ new Map()))
+  );
+};
+
+// ../telemetry/src/relay.ts
+var makeTelemetryForwarder = Effect_exports.gen(function* () {
+  const fibers = yield* FiberSet_exports.make();
+  const pending = yield* Semaphore_exports.make(16);
+  const sender = yield* Semaphore_exports.make(1);
+  const failed = (reason) => recordExportFailure("app").pipe(Effect_exports.annotateLogs({ "executor.telemetry.failure": reason }));
+  yield* Effect_exports.addFinalizer(
+    () => FiberSet_exports.awaitEmpty(fibers).pipe(
+      Effect_exports.timeoutOption("3 seconds"),
+      Effect_exports.flatMap((drained) => Option_exports.isNone(drained) ? failed("shutdown") : Effect_exports.void)
+    )
+  );
+  return (batch, traceId, build) => FiberSet_exports.run(
+    fibers,
+    sender.withPermits(1)(
+      forwardTelemetry(batch, traceId, build).pipe(Effect_exports.catch(() => failed("relay")))
+    ).pipe(
+      pending.withPermitsIfAvailable(1),
+      Effect_exports.flatMap(
+        (accepted) => Option_exports.isNone(accepted) ? failed("capacity") : Effect_exports.void
+      )
+    )
+  ).pipe(Effect_exports.asVoid);
+});
+var payloadBytes = 262144;
+var encoder = new TextEncoder();
+var Payload = Schema_exports.String.check(
+  Schema_exports.isMaxLength(payloadBytes),
+  Schema_exports.makeFilter((body) => encoder.encode(body).byteLength <= payloadBytes)
+);
+var TelemetryBatch = Schema_exports.Struct({
+  traces: Schema_exports.Array(Payload).check(Schema_exports.isMaxLength(4)),
+  logs: Schema_exports.Array(Payload).check(Schema_exports.isMaxLength(4)),
+  dropped: Schema_exports.Int.check(Schema_exports.isGreaterThanOrEqualTo(0))
+});
+var collectTelemetry = (effect2) => Effect_exports.gen(function* () {
+  const traces = [];
+  const logs = [];
+  let dropped = 0;
+  const capture = async (input, init) => {
+    const request = new Request(input, init);
+    const body = await request.text();
+    if (new URL(request.url).pathname === "/v1/traces") {
+      const payload = Schema_exports.decodeUnknownSync(TracePayload)(body);
+      dropped += packRecords(
+        payload.resourceSpans.flatMap(
+          (resource) => resource.scopeSpans.flatMap((scope) => scope.spans)
+        ),
+        traces,
+        '{"resourceSpans":[{"scopeSpans":[{"spans":[',
+        "]}]}]}"
+      );
+    } else {
+      const payload = Schema_exports.decodeUnknownSync(LogPayload)(body);
+      dropped += packRecords(
+        payload.resourceLogs.flatMap(
+          (resource) => resource.scopeLogs.flatMap((scope) => scope.logRecords)
+        ),
+        logs,
+        '{"resourceLogs":[{"scopeLogs":[{"logRecords":[',
+        "]}]}]}"
+      );
+    }
+    return Response.json({});
+  };
+  const value = yield* effect2.pipe(
+    Effect_exports.provide(
+      telemetryLayer(
+        {
+          service: "executor-app",
+          version: "invocation",
+          environment: "isolated",
+          clock: "WebSocketPair" in globalThis ? "cloudflare-io" : "system",
+          traces: { url: "http://telemetry.internal/v1/traces" },
+          logs: { url: "http://telemetry.internal/v1/logs" }
+        },
+        "event"
+      )
+    ),
+    Effect_exports.provideService(FetchHttpClient_exports.Fetch, capture)
+  );
+  return { value, telemetry: { traces, logs, dropped } };
+});
+var packRecords = (records, target, prefix, suffix) => {
+  let parts = [];
+  const overhead = encoder.encode(prefix + suffix).byteLength;
+  let bytes = overhead;
+  let dropped = 0;
+  const flush = () => {
+    if (parts.length === 0) return;
+    target.push(prefix + parts.join(",") + suffix);
+    parts = [];
+    bytes = overhead;
+  };
+  for (const record of records) {
+    const encoded = JSON.stringify(record);
+    const size = encoder.encode(encoded).byteLength;
+    if (size + overhead > payloadBytes || target.length >= 4) {
+      dropped++;
+      continue;
+    }
+    if (bytes + size + (parts.length > 0 ? 1 : 0) > payloadBytes) flush();
+    if (target.length >= 4) {
+      dropped++;
+      continue;
+    }
+    bytes += size + (parts.length > 0 ? 1 : 0);
+    parts.push(encoded);
+  }
+  flush();
+  return dropped;
+};
+var HexTrace = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{32}$/));
+var HexSpan = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{16}$/));
+var Span = Schema_exports.StructWithRest(Schema_exports.Struct({ traceId: HexTrace, spanId: HexSpan }), [
+  Schema_exports.Record(Schema_exports.String, Schema_exports.Json)
+]);
+var LogRecord = Schema_exports.StructWithRest(
+  Schema_exports.Struct({ traceId: Schema_exports.optional(HexTrace), spanId: Schema_exports.optional(HexSpan) }),
+  [Schema_exports.Record(Schema_exports.String, Schema_exports.Json)]
+);
+var TracePayload = Schema_exports.fromJsonString(
+  Schema_exports.Struct({
+    resourceSpans: Schema_exports.Array(
+      Schema_exports.Struct({
+        scopeSpans: Schema_exports.Array(
+          Schema_exports.Struct({ spans: Schema_exports.Array(Span).check(Schema_exports.isMaxLength(1e3)) })
+        )
+      })
+    )
+  })
+);
+var LogPayload = Schema_exports.fromJsonString(
+  Schema_exports.Struct({
+    resourceLogs: Schema_exports.Array(
+      Schema_exports.Struct({
+        scopeLogs: Schema_exports.Array(
+          Schema_exports.Struct({ logRecords: Schema_exports.Array(LogRecord).check(Schema_exports.isMaxLength(1e3)) })
+        )
+      })
+    )
+  })
+);
+var forwardTelemetry = (batch, traceId, build, service = "executor-app") => Effect_exports.gen(function* () {
+  const config = yield* CurrentTelemetryConfig;
+  if (config === void 0) return;
+  const resource = {
+    attributes: [
+      { key: "service.name", value: { stringValue: service } },
+      { key: "service.version", value: { stringValue: config.version } },
+      { key: "deployment.environment.name", value: { stringValue: config.environment } },
+      ...build === void 0 ? [] : [{ key: "executor.build.id", value: { stringValue: build } }]
+    ]
+  };
+  const client = yield* HttpClient_exports.HttpClient;
+  if (batch.dropped > 0) yield* recordExportFailure("app", "capacity", batch.dropped);
+  for (const signal of ["traces", "logs"]) {
+    const target = config[signal];
+    if (target === void 0) continue;
+    for (const body of batch[signal]) {
+      const data = signal === "traces" ? yield* Schema_exports.decodeUnknownEffect(TracePayload)(body).pipe(
+        Effect_exports.map((payload) => ({
+          resourceSpans: [
+            {
+              resource,
+              scopeSpans: [
+                {
+                  scope: { name: service },
+                  spans: payload.resourceSpans.flatMap((r) => r.scopeSpans.flatMap((s) => s.spans)).filter((span) => traceId === void 0 || span.traceId === traceId)
+                }
+              ]
+            }
+          ]
+        }))
+      ) : yield* Schema_exports.decodeUnknownEffect(LogPayload)(body).pipe(
+        Effect_exports.map((payload) => ({
+          resourceLogs: [
+            {
+              resource,
+              scopeLogs: [
+                {
+                  scope: { name: service },
+                  logRecords: payload.resourceLogs.flatMap((r) => r.scopeLogs.flatMap((s) => s.logRecords)).filter((log) => traceId === void 0 || log.traceId === traceId)
+                }
+              ]
+            }
+          ]
+        }))
+      );
+      yield* client.pipe(HttpClient_exports.filterStatusOk).execute(
+        HttpClientRequest_exports.post(target.url).pipe(
+          HttpClientRequest_exports.setHeaders(
+            target.headers === void 0 ? {} : Redacted_exports.value(target.headers)
+          ),
+          HttpClientRequest_exports.bodyJsonUnsafe(data)
+        )
+      );
+    }
+  }
+}).pipe(
+  Effect_exports.provide(telemetryHttpClient),
+  Effect_exports.provideService(Tracer_exports.DisablePropagation, true),
+  Effect_exports.timeout("3 seconds")
+);
+
+// ../telemetry/src/trace-context.ts
+var TraceContext = Schema_exports.Struct({
+  traceId: Schema_exports.String.check(Schema_exports.isPattern(/^(?!0{32}$)[a-f0-9]{32}$/)),
+  spanId: Schema_exports.String.check(Schema_exports.isPattern(/^(?!0{16}$)[a-f0-9]{16}$/)),
+  sampled: Schema_exports.Boolean
+});
+var currentTraceContext = Effect_exports.currentSpan.pipe(
+  Effect_exports.option,
+  Effect_exports.map(
+    Option_exports.map((span) => ({
+      traceId: span.traceId,
+      spanId: span.spanId,
+      sampled: span.sampled
+    }))
+  ),
+  Effect_exports.map(Option_exports.getOrUndefined)
+);
+var externalTrace = (input) => Schema_exports.decodeUnknownOption(TraceContext)(input).pipe(
+  Option_exports.map((trace) => Tracer_exports.externalSpan(trace))
+);
+var traceLinks = (input, relationship) => {
+  const span = externalTrace(input);
+  return Option_exports.isSome(span) ? [{ span: span.value, attributes: { "executor.link.kind": relationship } }] : [];
+};
+
+// ../telemetry/src/pending-span.ts
+var pendingSpan = (name, options) => Effect_exports.gen(function* () {
+  const span = yield* Effect_exports.makeSpan(name, options);
+  const clock = yield* Clock_exports.Clock;
+  let pending = true;
+  const close = (exit, reached) => Effect_exports.sync(() => {
+    if (!pending) return;
+    pending = false;
+    span.attribute("executor.milestone.reached", reached);
+    span.end(clock.currentTimeNanosUnsafe(), exit);
+  });
+  yield* Effect_exports.addFinalizer((exit) => close(exit, false));
+  return {
+    span,
+    finish: (exit) => close(exit, Exit_exports.isSuccess(exit))
+  };
+});
+
+export {
+  CurrentTelemetryConfig,
+  OtlpExporter_exports,
+  telemetryLayer,
+  captureTelemetry,
+  withRemoteSpan,
+  invocationFetch,
+  collectTelemetry,
+  TraceContext,
+  externalTrace,
+  traceLinks,
+  pendingSpan
+};