@glasstrace/sdk 0.19.0 → 0.20.1

package/dist/index.js

@@ -1,34 +1,47 @@
+import {
+  GlasstraceExporter,
+  SessionManager,
+  captureError,
+  classifyFetchTarget,
+  createGlasstraceSpanProcessor,
+  getDateString,
+  getDiscoveryHandler,
+  getOrigin,
+  getStatus,
+  isReady,
+  registerGlasstrace,
+  waitForReady,
+  withGlasstraceConfig
+} from "./chunk-R4DAIPXD.js";
+import {
+  GlasstraceSpanProcessor,
+  SdkError,
+  captureCorrelationId,
+  createDiscoveryHandler
+} from "./chunk-Z2EGETTT.js";
+import "./chunk-DQ25VOKK.js";
 import {
   PRESIGNED_THRESHOLD_BYTES,
   collectSourceMaps,
   computeBuildHash,
   discoverSourceMapFiles,
-  installConsoleCapture,
-  maybeShowMcpNudge,
-  maybeShowServerActionNudge,
-  sdkLog,
   uploadSourceMaps,
   uploadSourceMapsAuto,
   uploadSourceMapsPresigned
-} from "./chunk-VN3GZDV6.js";
+} from "./chunk-IQN6TRMQ.js";
 import {
-  _setCurrentConfig,
-  buildImportGraph,
-  collectHealthReport,
-  consumeRateLimitFlag,
-  didLastInitSucceed,
-  discoverTestFiles,
-  extractImports,
   getActiveConfig,
-  getClaimResult,
   getLinkedAccountId,
   loadCachedConfig,
   performInit,
-  recordSpansDropped,
-  recordSpansExported,
   saveCachedConfig,
   sendInitRequest
-} from "./chunk-F2TZRBEH.js";
+} from "./chunk-DO2YPMQ5.js";
+import {
+  buildImportGraph,
+  discoverTestFiles,
+  extractImports
+} from "./chunk-BT2OCXCG.js";
 import {
   isAnonymousMode,
   isProductionDisabled,
@@ -38,4601 +51,11 @@ import {
 import {
   getOrCreateAnonKey,
   readAnonKey
-} from "./chunk-YPXW2TN3.js";
+} from "./chunk-IP4NMDJK.js";
 import {
-  GLASSTRACE_ATTRIBUTE_NAMES,
   deriveSessionId
-} from "./chunk-5N2IR4EO.js";
-import {
-  DiagLogLevel,
-  INVALID_SPAN_CONTEXT,
-  ROOT_CONTEXT,
-  SamplingDecision,
-  SpanKind,
-  SpanStatusCode,
-  TraceFlags,
-  baggageEntryMetadataFromString,
-  context,
-  createContextKey,
-  createNoopMeter,
-  diag,
-  isSpanContextValid,
-  isValidTraceId,
-  trace
-} from "./chunk-DQ25VOKK.js";
-import {
-  __require
-} from "./chunk-NSBPE2FW.js";
-
-// src/errors.ts
-var SdkError = class extends Error {
-  code;
-  constructor(code, message, cause) {
-    super(message, { cause });
-    this.name = "SdkError";
-    this.code = code;
-  }
-};
-
-// src/session.ts
-var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
-var cachedGlasstraceEnv = process.env.GLASSTRACE_ENV;
-var cachedPort = process.env.PORT ?? "3000";
-function getOrigin() {
-  if (cachedGlasstraceEnv) {
-    return cachedGlasstraceEnv;
-  }
-  return `localhost:${cachedPort}`;
-}
-function getDateString() {
-  const now = /* @__PURE__ */ new Date();
-  const year = now.getUTCFullYear();
-  const month = String(now.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(now.getUTCDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-var SessionManager = class {
-  windowIndex = 0;
-  lastActivityTimestamp = 0;
-  lastDate = "";
-  lastApiKey = "";
-  currentSessionId = null;
-  /**
-   * Returns the current session ID, deriving a new one if:
-   * - More than 4 hours have elapsed since last activity
-   * - The UTC date has changed (resets window index to 0)
-   * - The API key has changed (e.g., deferred anonymous key swap)
-   * - This is the first call
-   *
-   * @param apiKey - The project's API key used in session derivation.
-   * @returns The current or newly derived SessionId.
-   */
-  getSessionId(apiKey) {
-    const now = Date.now();
-    const currentDate = getDateString();
-    const origin = getOrigin();
-    const elapsed = now - this.lastActivityTimestamp;
-    const dateChanged = currentDate !== this.lastDate;
-    const apiKeyChanged = apiKey !== this.lastApiKey;
-    if (dateChanged) {
-      this.windowIndex = 0;
-      this.lastDate = currentDate;
-      this.lastApiKey = apiKey;
-      this.currentSessionId = deriveSessionId(apiKey, origin, currentDate, this.windowIndex);
-    } else if (apiKeyChanged) {
-      this.lastApiKey = apiKey;
-      this.currentSessionId = deriveSessionId(apiKey, origin, currentDate, this.windowIndex);
-    } else if (this.currentSessionId === null || elapsed > FOUR_HOURS_MS) {
-      if (this.currentSessionId !== null) {
-        this.windowIndex++;
-      }
-      this.lastApiKey = apiKey;
-      this.currentSessionId = deriveSessionId(apiKey, origin, currentDate, this.windowIndex);
-      this.lastDate = currentDate;
-    }
-    this.lastActivityTimestamp = now;
-    return this.currentSessionId;
-  }
-};
-
-// src/fetch-classifier.ts
-var cachedPort2 = process.env.PORT ?? "3000";
-function classifyFetchTarget(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return "unknown";
-  }
-  const hostname = parsed.hostname.toLowerCase();
-  if (hostname === "supabase.co" || hostname.endsWith(".supabase.co") || hostname === "supabase.in" || hostname.endsWith(".supabase.in")) {
-    return "supabase";
-  }
-  if (hostname === "stripe.com" || hostname.endsWith(".stripe.com")) {
-    return "stripe";
-  }
-  const internalOrigin = `localhost:${cachedPort2}`;
-  const parsedPort = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
-  const urlOrigin = `${hostname}:${parsedPort}`;
-  if (urlOrigin === internalOrigin) {
-    return "internal";
-  }
-  return "unknown";
-}
-
-// src/span-processor.ts
-var GlasstraceSpanProcessor = class {
-  wrappedProcessor;
-  /* eslint-disable @typescript-eslint/no-unused-vars -- backward compat signature */
-  constructor(wrappedProcessor, _sessionManager2, _apiKey, _getConfig, _environment) {
-    this.wrappedProcessor = wrappedProcessor;
-  }
-  onStart(span, parentContext) {
-    this.wrappedProcessor.onStart(span, parentContext);
-  }
-  onEnd(readableSpan) {
-    this.wrappedProcessor.onEnd(readableSpan);
-  }
-  async shutdown() {
-    return this.wrappedProcessor.shutdown();
-  }
-  async forceFlush() {
-    return this.wrappedProcessor.forceFlush();
-  }
-};
-
-// src/enriching-exporter.ts
-var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
-var API_KEY_PENDING = "pending";
-var MAX_PENDING_SPANS = 1024;
-var GlasstraceExporter = class {
-  getApiKey;
-  sessionManager;
-  getConfig;
-  environment;
-  endpointUrl;
-  createDelegateFn;
-  verbose;
-  delegate = null;
-  delegateKey = null;
-  pendingBatches = [];
-  pendingSpanCount = 0;
-  overflowLogged = false;
-  constructor(options) {
-    this.getApiKey = options.getApiKey;
-    this.sessionManager = options.sessionManager;
-    this.getConfig = options.getConfig;
-    this.environment = options.environment;
-    this.endpointUrl = options.endpointUrl;
-    this.createDelegateFn = options.createDelegate;
-    this.verbose = options.verbose ?? false;
-    this[/* @__PURE__ */ Symbol.for("glasstrace.exporter")] = true;
-  }
-  export(spans, resultCallback) {
-    const currentKey = this.getApiKey();
-    if (currentKey === API_KEY_PENDING) {
-      this.bufferSpans(spans, resultCallback);
-      return;
-    }
-    const enrichedSpans = spans.map((span) => this.enrichSpan(span));
-    const exporter = this.ensureDelegate();
-    if (exporter) {
-      exporter.export(enrichedSpans, (result) => {
-        if (result.code !== 0) {
-          sdkLog("warn", `[glasstrace] Span export failed: ${result.error?.message ?? "unknown error"}`);
-        }
-        resultCallback(result);
-      });
-      recordSpansExported(enrichedSpans.length);
-    } else {
-      recordSpansDropped(enrichedSpans.length);
-      resultCallback({ code: 0 });
-    }
-  }
-  /**
-   * Called when the API key transitions from "pending" to a resolved value.
-   * Creates the delegate exporter and flushes all buffered spans.
-   */
-  notifyKeyResolved() {
-    this.flushPending();
-  }
-  async shutdown() {
-    const currentKey = this.getApiKey();
-    if (currentKey !== API_KEY_PENDING && this.pendingBatches.length > 0) {
-      this.flushPending();
-    } else if (this.pendingBatches.length > 0) {
-      console.warn(
-        `[glasstrace] Shutdown with ${this.pendingSpanCount} buffered spans \u2014 API key never resolved, spans lost.`
-      );
-      recordSpansDropped(this.pendingSpanCount);
-      for (const batch of this.pendingBatches) {
-        batch.resultCallback({ code: 0 });
-      }
-      this.pendingBatches = [];
-      this.pendingSpanCount = 0;
-    }
-    if (this.delegate) {
-      return this.delegate.shutdown();
-    }
-  }
-  /**
-   * Flushes any pending buffered spans (if the API key has resolved) and
-   * delegates to the underlying exporter's forceFlush to drain its queue.
-   */
-  forceFlush() {
-    if (this.getApiKey() !== API_KEY_PENDING && this.pendingBatches.length > 0) {
-      this.flushPending();
-    }
-    if (this.delegate?.forceFlush) {
-      return this.delegate.forceFlush();
-    }
-    return Promise.resolve();
-  }
-  /**
-   * Enriches a ReadableSpan with all glasstrace.* attributes.
-   * Returns a new ReadableSpan wrapper; the original span is not mutated.
-   *
-   * Only {@link SessionManager.getSessionId} is individually guarded because
-   * it calls into crypto and schema validation — a session ID failure should
-   * not prevent the rest of enrichment. The other helper calls
-   * ({@link deriveErrorCategory}, {@link deriveOrmProvider},
-   * {@link classifyFetchTarget}) are pure functions on typed string inputs
-   * and rely on the outer catch for any unexpected failure.
-   *
-   * On total failure, returns the original span unchanged.
-   */
-  enrichSpan(span) {
-    try {
-      const attrs = span.attributes ?? {};
-      const name = span.name ?? "";
-      const extra = {};
-      extra[ATTR.TRACE_TYPE] = "server";
-      try {
-        const sessionId = this.sessionManager.getSessionId(this.getApiKey());
-        extra[ATTR.SESSION_ID] = sessionId;
-      } catch {
-      }
-      const env = this.environment ?? process.env.GLASSTRACE_ENV;
-      if (env) {
-        extra[ATTR.ENVIRONMENT] = env;
-      }
-      const existingCid = attrs["glasstrace.correlation.id"];
-      if (typeof existingCid === "string") {
-        extra[ATTR.CORRELATION_ID] = existingCid;
-      }
-      const rawRoute = attrs["http.route"];
-      const route = typeof rawRoute === "string" ? rawRoute : name;
-      if (route) {
-        extra[ATTR.ROUTE] = route;
-      }
-      const rawUrl = attrs["http.url"] ?? attrs["url.full"] ?? attrs["http.target"];
-      const trpcUrl = typeof rawUrl === "string" ? rawUrl : void 0;
-      if (trpcUrl) {
-        const trpcMatch = trpcUrl.match(/\/api\/trpc\/([^/?#]+)/);
-        if (trpcMatch) {
-          let procedure;
-          try {
-            procedure = decodeURIComponent(trpcMatch[1]);
-          } catch {
-            procedure = trpcMatch[1];
-          }
-          if (procedure) {
-            extra[ATTR.TRPC_PROCEDURE] = procedure;
-          }
-        }
-      }
-      const method = attrs["http.method"] ?? attrs["http.request.method"];
-      if (method) {
-        extra[ATTR.HTTP_METHOD] = method;
-      }
-      const actionRoute = extractLeadingPath(route);
-      if (method === "POST" && actionRoute) {
-        const isApiRoute = actionRoute === "/api" || actionRoute.startsWith("/api/");
-        const isInternalRoute = actionRoute.startsWith("/_next/");
-        if (!isApiRoute && !isInternalRoute) {
-          extra[ATTR.NEXT_ACTION_DETECTED] = true;
-          if (typeof extra[ATTR.CORRELATION_ID] !== "string") {
-            maybeShowServerActionNudge();
-          }
-        }
-      }
-      const statusCode = attrs["http.status_code"] ?? attrs["http.response.status_code"];
-      if (statusCode !== void 0) {
-        extra[ATTR.HTTP_STATUS_CODE] = statusCode;
-      }
-      const isErrorByStatus = span.status?.code === SpanStatusCode.ERROR;
-      const isErrorByEvent = hasExceptionEvent(span);
-      const isErrorByAttrs = typeof attrs["exception.type"] === "string" || typeof attrs["exception.message"] === "string";
-      const statusNotExplicitlyOK = span.status?.code !== SpanStatusCode.OK;
-      if (this.verbose && method) {
-        sdkLog(
-          "info",
-          `[glasstrace] enrichSpan "${name}": status.code=${span.status?.code}, http.status_code=${statusCode}, isErrorByStatus=${isErrorByStatus}, isErrorByEvent=${isErrorByEvent}, isErrorByAttrs=${isErrorByAttrs}`
-        );
-      }
-      if (method && statusNotExplicitlyOK && (isErrorByStatus || isErrorByEvent || isErrorByAttrs)) {
-        if (statusCode === void 0 || statusCode === 0 || statusCode === 200) {
-          const httpErrorType = attrs["error.type"];
-          if (typeof httpErrorType === "string") {
-            const parsed = parseInt(httpErrorType, 10);
-            if (!isNaN(parsed) && parsed >= 400 && parsed <= 599) {
-              extra[ATTR.HTTP_STATUS_CODE] = parsed;
-            } else {
-              extra[ATTR.HTTP_STATUS_CODE] = 500;
-            }
-          } else {
-            extra[ATTR.HTTP_STATUS_CODE] = 500;
-          }
-          if (this.verbose) {
-            sdkLog(
-              "info",
-              `[glasstrace] enrichSpan "${name}": inferred status_code=${extra[ATTR.HTTP_STATUS_CODE]} (was ${statusCode}), error.type=${attrs["error.type"]}`
-            );
-          }
-        }
-      }
-      if (span.startTime && span.endTime) {
-        const [startSec, startNano] = span.startTime;
-        const [endSec, endNano] = span.endTime;
-        const durationMs = (endSec - startSec) * 1e3 + (endNano - startNano) / 1e6;
-        if (durationMs >= 0) {
-          extra[ATTR.HTTP_DURATION_MS] = durationMs;
-        }
-      }
-      const eventDetails = statusNotExplicitlyOK ? getExceptionEventDetails(span) : { type: void 0, message: void 0 };
-      const errorMessage = attrs["exception.message"];
-      if (typeof errorMessage === "string") {
-        extra[ATTR.ERROR_MESSAGE] = errorMessage;
-      } else if (eventDetails.message) {
-        extra[ATTR.ERROR_MESSAGE] = eventDetails.message;
-      }
-      const errorType = attrs["exception.type"];
-      if (typeof errorType === "string") {
-        extra[ATTR.ERROR_CODE] = errorType;
-        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(errorType);
-      } else if (eventDetails.type) {
-        extra[ATTR.ERROR_CODE] = eventDetails.type;
-        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(eventDetails.type);
-      }
-      if (this.verbose && (extra[ATTR.ERROR_MESSAGE] || extra[ATTR.ERROR_CODE])) {
-        const msgSource = typeof errorMessage === "string" ? "attrs" : eventDetails.message ? "event" : "none";
-        const typeSource = typeof errorType === "string" ? "attrs" : eventDetails.type ? "event" : "none";
-        sdkLog(
-          "info",
-          `[glasstrace] enrichSpan "${name}": error.message source=${msgSource}, error.code source=${typeSource}`
-        );
-      }
-      const errorField = attrs["error.field"];
-      if (typeof errorField === "string") {
-        extra[ATTR.ERROR_FIELD] = errorField;
-      }
-      if (this.getConfig().errorResponseBodies) {
-        const responseBody = attrs["glasstrace.internal.response_body"];
-        if (typeof responseBody === "string") {
-          extra[ATTR.ERROR_RESPONSE_BODY] = responseBody.slice(0, 500);
-        }
-      }
-      const spanAny = span;
-      const instrumentationName = spanAny.instrumentationScope?.name ?? spanAny.instrumentationLibrary?.name ?? "";
-      const ormProvider = deriveOrmProvider(instrumentationName);
-      if (ormProvider) {
-        extra[ATTR.ORM_PROVIDER] = ormProvider;
-        const table = attrs["db.sql.table"];
-        const prismaModel = attrs["db.prisma.model"];
-        const model = typeof table === "string" ? table : typeof prismaModel === "string" ? prismaModel : void 0;
-        if (model) {
-          extra[ATTR.ORM_MODEL] = model;
-        }
-        const operation = attrs["db.operation"];
-        if (typeof operation === "string") {
-          extra[ATTR.ORM_OPERATION] = operation;
-        }
-      }
-      const httpUrl = attrs["http.url"];
-      const fullUrl = attrs["url.full"];
-      const url = typeof httpUrl === "string" ? httpUrl : typeof fullUrl === "string" ? fullUrl : void 0;
-      if (url && span.kind === SpanKind.CLIENT) {
-        extra[ATTR.FETCH_TARGET] = classifyFetchTarget(url);
-      }
-      return createEnrichedSpan(span, extra);
-    } catch {
-      return span;
-    }
-  }
-  /**
-   * Lazily creates the delegate OTLP exporter once the API key is resolved.
-   * Recreates the delegate if the key has changed (e.g., after key rotation)
-   * so the Authorization header stays current.
-   */
-  ensureDelegate() {
-    if (!this.createDelegateFn) return null;
-    const currentKey = this.getApiKey();
-    if (currentKey === API_KEY_PENDING) return null;
-    if (this.delegate && this.delegateKey === currentKey) {
-      return this.delegate;
-    }
-    if (this.delegate) {
-      void this.delegate.shutdown?.().catch(() => {
-      });
-    }
-    this.delegate = this.createDelegateFn(this.endpointUrl, {
-      Authorization: `Bearer ${currentKey}`
-    });
-    this.delegateKey = currentKey;
-    return this.delegate;
-  }
-  /**
-   * Buffers raw (unenriched) spans while the API key is pending.
-   * Evicts oldest batches if the buffer exceeds MAX_PENDING_SPANS.
-   * Re-checks the key after buffering to close the race window where
-   * the key resolves between the caller's check and this buffer call.
-   */
-  bufferSpans(spans, resultCallback) {
-    this.pendingBatches.push({ spans, resultCallback });
-    this.pendingSpanCount += spans.length;
-    while (this.pendingSpanCount > MAX_PENDING_SPANS && this.pendingBatches.length > 1) {
-      const evicted = this.pendingBatches.shift();
-      this.pendingSpanCount -= evicted.spans.length;
-      recordSpansDropped(evicted.spans.length);
-      evicted.resultCallback({ code: 0 });
-      if (!this.overflowLogged) {
-        this.overflowLogged = true;
-        console.warn(
-          "[glasstrace] Pending span buffer overflow \u2014 oldest spans evicted. This usually means the API key is taking too long to resolve."
-        );
-      }
-    }
-    if (this.getApiKey() !== API_KEY_PENDING) {
-      this.flushPending();
-    }
-  }
-  /**
-   * Flushes all buffered spans through the delegate exporter.
-   * Enriches spans at flush time (not buffer time) so that session IDs
-   * are computed with the resolved API key instead of the "pending" sentinel.
-   */
-  flushPending() {
-    if (this.pendingBatches.length === 0) return;
-    const exporter = this.ensureDelegate();
-    if (!exporter) {
-      let discardedCount = 0;
-      for (const batch of this.pendingBatches) {
-        discardedCount += batch.spans.length;
-        batch.resultCallback({ code: 0 });
-      }
-      recordSpansDropped(discardedCount);
-      this.pendingBatches = [];
-      this.pendingSpanCount = 0;
-      return;
-    }
-    const batches = this.pendingBatches;
-    this.pendingBatches = [];
-    this.pendingSpanCount = 0;
-    for (const batch of batches) {
-      const enriched = batch.spans.map((span) => this.enrichSpan(span));
-      exporter.export(enriched, (result) => {
-        if (result.code !== 0) {
-          sdkLog("warn", `[glasstrace] Span export failed: ${result.error?.message ?? "unknown error"}`);
-        }
-        batch.resultCallback(result);
-      });
-      recordSpansExported(enriched.length);
-    }
-  }
-};
-function createEnrichedSpan(span, extra) {
-  const enrichedAttributes = { ...span.attributes, ...extra };
-  return Object.create(span, {
-    attributes: {
-      value: enrichedAttributes,
-      enumerable: true
-    }
-  });
-}
-function hasExceptionEvent(span) {
-  return span.events?.some((e) => e.name === "exception") ?? false;
-}
-function getExceptionEventDetails(span) {
-  const event = span.events?.find((e) => e.name === "exception");
-  if (!event?.attributes) {
-    return { type: void 0, message: void 0 };
-  }
-  const type = event.attributes["exception.type"];
-  const message = event.attributes["exception.message"];
-  return {
-    type: typeof type === "string" ? type : void 0,
-    message: typeof message === "string" ? message : void 0
-  };
-}
-function extractLeadingPath(raw) {
-  if (!raw) return void 0;
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return void 0;
-  if (trimmed.startsWith("/")) {
-    const firstSpace = trimmed.indexOf(" ");
-    return firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
-  }
-  for (const token of trimmed.split(/\s+/)) {
-    if (token.startsWith("/")) {
-      return token;
-    }
-  }
-  return void 0;
-}
-function deriveOrmProvider(instrumentationName) {
-  const lower = instrumentationName.toLowerCase();
-  if (lower.includes("prisma")) {
-    return "prisma";
-  }
-  if (lower.includes("drizzle")) {
-    return "drizzle";
-  }
-  return null;
-}
-function deriveErrorCategory(errorType) {
-  const lower = errorType.toLowerCase();
-  if (lower.includes("validation") || lower.includes("zod")) {
-    return "validation";
-  }
-  if (lower.includes("network") || lower.includes("econnrefused") || lower.includes("fetch") || lower.includes("timeout")) {
-    return "network";
-  }
-  if (lower.includes("auth") || lower.includes("unauthorized") || lower.includes("forbidden")) {
-    return "auth";
-  }
-  if (lower.includes("notfound") || lower.includes("not_found")) {
-    return "not-found";
-  }
-  return "internal";
-}
-
-// src/discovery-endpoint.ts
-function isAllowedOrigin(origin) {
-  if (origin === null) return true;
-  if (origin.startsWith("chrome-extension://")) return true;
-  if (origin.startsWith("moz-extension://")) return true;
-  if (origin.startsWith("safari-web-extension://")) return true;
-  return false;
-}
-function buildCorsHeaders(origin) {
-  const headers = {
-    "Content-Type": "application/json",
-    Vary: "Origin"
-  };
-  if (origin && isAllowedOrigin(origin)) {
-    headers["Access-Control-Allow-Origin"] = origin;
-  }
-  return headers;
-}
-function createDiscoveryHandler(getAnonKey, getSessionId, getClaimState) {
-  return async (request) => {
-    let url;
-    try {
-      url = new URL(request.url);
-    } catch {
-      return null;
-    }
-    if (url.pathname !== "/__glasstrace/config") {
-      return null;
-    }
-    const origin = request.headers.get("Origin");
-    const corsHeaders = buildCorsHeaders(origin);
-    if (request.method === "OPTIONS") {
-      return new Response(null, {
-        status: 204,
-        headers: {
-          ...corsHeaders,
-          "Access-Control-Allow-Methods": "GET, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type"
-        }
-      });
-    }
-    if (request.method !== "GET") {
-      return new Response(
-        JSON.stringify({ error: "method_not_allowed" }),
-        {
-          status: 405,
-          headers: corsHeaders
-        }
-      );
-    }
-    try {
-      const anonKey = await getAnonKey();
-      if (anonKey === null) {
-        return new Response(
-          JSON.stringify({ error: "not_ready" }),
-          {
-            status: 503,
-            headers: corsHeaders
-          }
-        );
-      }
-      const sessionId = getSessionId();
-      const responseBody = { key: anonKey, sessionId };
-      const claimState = getClaimState?.();
-      if (claimState?.claimed) {
-        responseBody.claimed = true;
-        if (claimState.accountHint) {
-          responseBody.accountHint = claimState.accountHint;
-        }
-      }
-      return new Response(
-        JSON.stringify(responseBody),
-        {
-          status: 200,
-          headers: corsHeaders
-        }
-      );
-    } catch {
-      return new Response(
-        JSON.stringify({ error: "internal_error" }),
-        {
-          status: 500,
-          headers: corsHeaders
-        }
-      );
-    }
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
-var OTLPExporterBase = class {
-  _delegate;
-  constructor(delegate) {
-    this._delegate = delegate;
-  }
-  /**
-   * Export items.
-   * @param items
-   * @param resultCallback
-   */
-  export(items, resultCallback) {
-    this._delegate.export(items, resultCallback);
-  }
-  forceFlush() {
-    return this._delegate.forceFlush();
-  }
-  shutdown() {
-    return this._delegate.shutdown();
-  }
-};
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js
-var OTLPExporterError = class extends Error {
-  code;
-  name = "OTLPExporterError";
-  data;
-  constructor(message, code, data) {
-    super(message);
-    this.data = data;
-    this.code = code;
-  }
-};
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
-function validateTimeoutMillis(timeoutMillis) {
-  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
-    return timeoutMillis;
-  }
-  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
-}
-function wrapStaticHeadersInFunction(headers) {
-  if (headers == null) {
-    return void 0;
-  }
-  return async () => headers;
-}
-function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    timeoutMillis: validateTimeoutMillis(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis),
-    concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit,
-    compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression
-  };
-}
-function getSharedConfigurationDefaults() {
-  return {
-    timeoutMillis: 1e4,
-    concurrencyLimit: 30,
-    compression: "none"
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
-var BoundedQueueExportPromiseHandler = class {
-  _concurrencyLimit;
-  _sendingPromises = [];
-  /**
-   * @param concurrencyLimit maximum promises allowed in a queue at the same time.
-   */
-  constructor(concurrencyLimit) {
-    this._concurrencyLimit = concurrencyLimit;
-  }
-  pushPromise(promise) {
-    if (this.hasReachedLimit()) {
-      throw new Error("Concurrency Limit reached");
-    }
-    this._sendingPromises.push(promise);
-    const popPromise = () => {
-      const index = this._sendingPromises.indexOf(promise);
-      void this._sendingPromises.splice(index, 1);
-    };
-    promise.then(popPromise, popPromise);
-  }
-  hasReachedLimit() {
-    return this._sendingPromises.length >= this._concurrencyLimit;
-  }
-  async awaitAll() {
-    await Promise.all(this._sendingPromises);
-  }
-};
-function createBoundedQueueExportPromiseHandler(options) {
-  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
-var SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
-function suppressTracing(context2) {
-  return context2.setValue(SUPPRESS_TRACING_KEY, true);
-}
-function isTracingSuppressed(context2) {
-  return context2.getValue(SUPPRESS_TRACING_KEY) === true;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js
-var BAGGAGE_KEY_PAIR_SEPARATOR = "=";
-var BAGGAGE_PROPERTIES_SEPARATOR = ";";
-var BAGGAGE_ITEMS_SEPARATOR = ",";
-
-// ../../node_modules/@opentelemetry/core/build/esm/baggage/utils.js
-function parsePairKeyValue(entry) {
-  if (!entry)
-    return;
-  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
-  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
-  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
-  if (separatorIndex <= 0)
-    return;
-  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
-  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
-  if (!rawKey || !rawValue)
-    return;
-  let key;
-  let value;
-  try {
-    key = decodeURIComponent(rawKey);
-    value = decodeURIComponent(rawValue);
-  } catch {
-    return;
-  }
-  let metadata;
-  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
-    const metadataString = entry.substring(metadataSeparatorIndex + 1);
-    metadata = baggageEntryMetadataFromString(metadataString);
-  }
-  return { key, value, metadata };
-}
-function parseKeyPairsIntoRecord(value) {
-  const result = {};
-  if (typeof value === "string" && value.length > 0) {
-    value.split(BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
-      const keyPair = parsePairKeyValue(entry);
-      if (keyPair !== void 0 && keyPair.value.length > 0) {
-        result[keyPair.key] = keyPair.value;
-      }
-    });
-  }
-  return result;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/common/attributes.js
-function sanitizeAttributes(attributes) {
-  const out = {};
-  if (typeof attributes !== "object" || attributes == null) {
-    return out;
-  }
-  for (const key in attributes) {
-    if (!Object.prototype.hasOwnProperty.call(attributes, key)) {
-      continue;
-    }
-    if (!isAttributeKey(key)) {
-      diag.warn(`Invalid attribute key: ${key}`);
-      continue;
-    }
-    const val = attributes[key];
-    if (!isAttributeValue(val)) {
-      diag.warn(`Invalid attribute value set for key: ${key}`);
-      continue;
-    }
-    if (Array.isArray(val)) {
-      out[key] = val.slice();
-    } else {
-      out[key] = val;
-    }
-  }
-  return out;
-}
-function isAttributeKey(key) {
-  return typeof key === "string" && key !== "";
-}
-function isAttributeValue(val) {
-  if (val == null) {
-    return true;
-  }
-  if (Array.isArray(val)) {
-    return isHomogeneousAttributeValueArray(val);
-  }
-  return isValidPrimitiveAttributeValueType(typeof val);
-}
-function isHomogeneousAttributeValueArray(arr) {
-  let type;
-  for (const element of arr) {
-    if (element == null)
-      continue;
-    const elementType = typeof element;
-    if (elementType === type) {
-      continue;
-    }
-    if (!type) {
-      if (isValidPrimitiveAttributeValueType(elementType)) {
-        type = elementType;
-        continue;
-      }
-      return false;
-    }
-    return false;
-  }
-  return true;
-}
-function isValidPrimitiveAttributeValueType(valType) {
-  switch (valType) {
-    case "number":
-    case "boolean":
-    case "string":
-      return true;
-  }
-  return false;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
-function loggingErrorHandler() {
-  return (ex) => {
-    diag.error(stringifyException(ex));
-  };
-}
-function stringifyException(ex) {
-  if (typeof ex === "string") {
-    return ex;
-  } else {
-    return JSON.stringify(flattenException(ex));
-  }
-}
-function flattenException(ex) {
-  const result = {};
-  let current = ex;
-  while (current !== null) {
-    Object.getOwnPropertyNames(current).forEach((propertyName) => {
-      if (result[propertyName])
-        return;
-      const value = current[propertyName];
-      if (value) {
-        result[propertyName] = String(value);
-      }
-    });
-    current = Object.getPrototypeOf(current);
-  }
-  return result;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
-var delegateHandler = loggingErrorHandler();
-function globalErrorHandler(ex) {
-  try {
-    delegateHandler(ex);
-  } catch {
-  }
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
-import { inspect } from "util";
-function getNumberFromEnv(key) {
-  const raw = process.env[key];
-  if (raw == null || raw.trim() === "") {
-    return void 0;
-  }
-  const value = Number(raw);
-  if (isNaN(value)) {
-    diag.warn(`Unknown value ${inspect(raw)} for ${key}, expected a number, using defaults`);
-    return void 0;
-  }
-  return value;
-}
-function getStringFromEnv(key) {
-  const raw = process.env[key];
-  if (raw == null || raw.trim() === "") {
-    return void 0;
-  }
-  return raw;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/version.js
-var VERSION = "2.6.1";
-
-// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
-var ATTR_EXCEPTION_MESSAGE = "exception.message";
-var ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
-var ATTR_EXCEPTION_TYPE = "exception.type";
-var ATTR_SERVICE_NAME = "service.name";
-var ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
-var TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
-var ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
-var ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
-
-// ../../node_modules/@opentelemetry/core/build/esm/semconv.js
-var ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
-
-// ../../node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
-var SDK_INFO = {
-  [ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
-  [ATTR_PROCESS_RUNTIME_NAME]: "node",
-  [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
-  [ATTR_TELEMETRY_SDK_VERSION]: VERSION
-};
-
-// ../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js
-var otperformance = performance;
-
-// ../../node_modules/@opentelemetry/core/build/esm/common/time.js
-var NANOSECOND_DIGITS = 9;
-var NANOSECOND_DIGITS_IN_MILLIS = 6;
-var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
-var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
-function millisToHrTime(epochMillis) {
-  const epochSeconds = epochMillis / 1e3;
-  const seconds = Math.trunc(epochSeconds);
-  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
-  return [seconds, nanos];
-}
-function hrTime(performanceNow) {
-  const timeOrigin = millisToHrTime(otperformance.timeOrigin);
-  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
-  return addHrTimes(timeOrigin, now);
-}
-function hrTimeDuration(startTime, endTime) {
-  let seconds = endTime[0] - startTime[0];
-  let nanos = endTime[1] - startTime[1];
-  if (nanos < 0) {
-    seconds -= 1;
-    nanos += SECOND_TO_NANOSECONDS;
-  }
-  return [seconds, nanos];
-}
-function hrTimeToNanoseconds(time) {
-  return time[0] * SECOND_TO_NANOSECONDS + time[1];
-}
-function isTimeInputHrTime(value) {
-  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
-}
-function isTimeInput(value) {
-  return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
-}
-function addHrTimes(time1, time2) {
-  const out = [time1[0] + time2[0], time1[1] + time2[1]];
-  if (out[1] >= SECOND_TO_NANOSECONDS) {
-    out[1] -= SECOND_TO_NANOSECONDS;
-    out[0] += 1;
-  }
-  return out;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/ExportResult.js
-var ExportResultCode;
-(function(ExportResultCode2) {
-  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
-  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
-})(ExportResultCode || (ExportResultCode = {}));
-
-// ../../node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
-var objectTag = "[object Object]";
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var funcProto = Function.prototype;
-var funcToString = funcProto.toString;
-var objectCtorString = funcToString.call(Object);
-var getPrototypeOf = Object.getPrototypeOf;
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
-var nativeObjectToString = objectProto.toString;
-function isPlainObject(value) {
-  if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
-    return false;
-  }
-  const proto = getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
-}
-function isObjectLike(value) {
-  return value != null && typeof value == "object";
-}
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
-}
-function getRawTag(value) {
-  const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  let unmasked = false;
-  try {
-    value[symToStringTag] = void 0;
-    unmasked = true;
-  } catch {
-  }
-  const result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-function objectToString(value) {
-  return nativeObjectToString.call(value);
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/utils/merge.js
-var MAX_LEVEL = 20;
-function merge(...args) {
-  let result = args.shift();
-  const objects = /* @__PURE__ */ new WeakMap();
-  while (args.length > 0) {
-    result = mergeTwoObjects(result, args.shift(), 0, objects);
-  }
-  return result;
-}
-function takeValue(value) {
-  if (isArray(value)) {
-    return value.slice();
-  }
-  return value;
-}
-function mergeTwoObjects(one, two, level = 0, objects) {
-  let result;
-  if (level > MAX_LEVEL) {
-    return void 0;
-  }
-  level++;
-  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
-    result = takeValue(two);
-  } else if (isArray(one)) {
-    result = one.slice();
-    if (isArray(two)) {
-      for (let i = 0, j = two.length; i < j; i++) {
-        result.push(takeValue(two[i]));
-      }
-    } else if (isObject(two)) {
-      const keys = Object.keys(two);
-      for (let i = 0, j = keys.length; i < j; i++) {
-        const key = keys[i];
-        result[key] = takeValue(two[key]);
-      }
-    }
-  } else if (isObject(one)) {
-    if (isObject(two)) {
-      if (!shouldMerge(one, two)) {
-        return two;
-      }
-      result = Object.assign({}, one);
-      const keys = Object.keys(two);
-      for (let i = 0, j = keys.length; i < j; i++) {
-        const key = keys[i];
-        const twoValue = two[key];
-        if (isPrimitive(twoValue)) {
-          if (typeof twoValue === "undefined") {
-            delete result[key];
-          } else {
-            result[key] = twoValue;
-          }
-        } else {
-          const obj1 = result[key];
-          const obj2 = twoValue;
-          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
-            delete result[key];
-          } else {
-            if (isObject(obj1) && isObject(obj2)) {
-              const arr1 = objects.get(obj1) || [];
-              const arr2 = objects.get(obj2) || [];
-              arr1.push({ obj: one, key });
-              arr2.push({ obj: two, key });
-              objects.set(obj1, arr1);
-              objects.set(obj2, arr2);
-            }
-            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
-          }
-        }
-      }
-    } else {
-      result = two;
-    }
-  }
-  return result;
-}
-function wasObjectReferenced(obj, key, objects) {
-  const arr = objects.get(obj[key]) || [];
-  for (let i = 0, j = arr.length; i < j; i++) {
-    const info = arr[i];
-    if (info.key === key && info.obj === obj) {
-      return true;
-    }
-  }
-  return false;
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isObject(value) {
-  return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
-}
-function isPrimitive(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
-}
-function shouldMerge(one, two) {
-  if (!isPlainObject(one) || !isPlainObject(two)) {
-    return false;
-  }
-  return true;
-}
-
-// ../../node_modules/@opentelemetry/core/build/esm/utils/promise.js
-var Deferred = class {
-  _promise;
-  _resolve;
-  _reject;
-  constructor() {
-    this._promise = new Promise((resolve2, reject) => {
-      this._resolve = resolve2;
-      this._reject = reject;
-    });
-  }
-  get promise() {
-    return this._promise;
-  }
-  resolve(val) {
-    this._resolve(val);
-  }
-  reject(err) {
-    this._reject(err);
-  }
-};
-
-// ../../node_modules/@opentelemetry/core/build/esm/utils/callback.js
-var BindOnceFuture = class {
-  _isCalled = false;
-  _deferred = new Deferred();
-  _callback;
-  _that;
-  constructor(callback, that) {
-    this._callback = callback;
-    this._that = that;
-  }
-  get isCalled() {
-    return this._isCalled;
-  }
-  get promise() {
-    return this._deferred.promise;
-  }
-  call(...args) {
-    if (!this._isCalled) {
-      this._isCalled = true;
-      try {
-        Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
-      } catch (err) {
-        this._deferred.reject(err);
-      }
-    }
-    return this._deferred.promise;
-  }
-};
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
-function isPartialSuccessResponse(response) {
-  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
-}
-function createLoggingPartialSuccessResponseHandler() {
-  return {
-    handleResponse(response) {
-      if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
-        return;
-      }
-      diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
-    }
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
-var OTLPExportDelegate = class {
-  _diagLogger;
-  _transport;
-  _serializer;
-  _responseHandler;
-  _promiseQueue;
-  _timeout;
-  constructor(transport, serializer, responseHandler, promiseQueue, timeout) {
-    this._transport = transport;
-    this._serializer = serializer;
-    this._responseHandler = responseHandler;
-    this._promiseQueue = promiseQueue;
-    this._timeout = timeout;
-    this._diagLogger = diag.createComponentLogger({
-      namespace: "OTLPExportDelegate"
-    });
-  }
-  export(internalRepresentation, resultCallback) {
-    this._diagLogger.debug("items to be sent", internalRepresentation);
-    if (this._promiseQueue.hasReachedLimit()) {
-      resultCallback({
-        code: ExportResultCode.FAILED,
-        error: new Error("Concurrent export limit reached")
-      });
-      return;
-    }
-    const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
-    if (serializedRequest == null) {
-      resultCallback({
-        code: ExportResultCode.FAILED,
-        error: new Error("Nothing to send")
-      });
-      return;
-    }
-    this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
-      if (response.status === "success") {
-        if (response.data != null) {
-          try {
-            this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
-          } catch (e) {
-            this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
-          }
-        }
-        resultCallback({
-          code: ExportResultCode.SUCCESS
-        });
-        return;
-      } else if (response.status === "failure" && response.error) {
-        resultCallback({
-          code: ExportResultCode.FAILED,
-          error: response.error
-        });
-        return;
-      } else if (response.status === "retryable") {
-        resultCallback({
-          code: ExportResultCode.FAILED,
-          error: response.error ?? new OTLPExporterError("Export failed with retryable status")
-        });
-      } else {
-        resultCallback({
-          code: ExportResultCode.FAILED,
-          error: new OTLPExporterError("Export failed with unknown error")
-        });
-      }
-    }, (reason) => resultCallback({
-      code: ExportResultCode.FAILED,
-      error: reason
-    })));
-  }
-  forceFlush() {
-    return this._promiseQueue.awaitAll();
-  }
-  async shutdown() {
-    this._diagLogger.debug("shutdown started");
-    await this.forceFlush();
-    this._transport.shutdown();
-  }
-};
-function createOtlpExportDelegate(components, settings) {
-  return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
-}
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
-function createResource(resource, encoder) {
-  const result = {
-    attributes: toAttributes(resource.attributes, encoder),
-    droppedAttributesCount: 0
-  };
-  const schemaUrl = resource.schemaUrl;
-  if (schemaUrl && schemaUrl !== "")
-    result.schemaUrl = schemaUrl;
-  return result;
-}
-function createInstrumentationScope(scope) {
-  return {
-    name: scope.name,
-    version: scope.version
-  };
-}
-function toAttributes(attributes, encoder) {
-  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
-}
-function toKeyValue(key, value, encoder) {
-  return {
-    key,
-    value: toAnyValue(value, encoder)
-  };
-}
-function toAnyValue(value, encoder) {
-  const t = typeof value;
-  if (t === "string")
-    return { stringValue: value };
-  if (t === "number") {
-    if (!Number.isInteger(value))
-      return { doubleValue: value };
-    return { intValue: value };
-  }
-  if (t === "boolean")
-    return { boolValue: value };
-  if (value instanceof Uint8Array)
-    return { bytesValue: encoder.encodeUint8Array(value) };
-  if (Array.isArray(value)) {
-    const values = new Array(value.length);
-    for (let i = 0; i < value.length; i++) {
-      values[i] = toAnyValue(value[i], encoder);
-    }
-    return { arrayValue: { values } };
-  }
-  if (t === "object" && value != null) {
-    const keys = Object.keys(value);
-    const values = new Array(keys.length);
-    for (let i = 0; i < keys.length; i++) {
-      values[i] = {
-        key: keys[i],
-        value: toAnyValue(value[keys[i]], encoder)
-      };
-    }
-    return { kvlistValue: { values } };
-  }
-  return {};
-}
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
-function hrTimeToNanos(hrTime2) {
-  const NANOSECONDS = BigInt(1e9);
-  return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1]));
-}
-function encodeAsString(hrTime2) {
-  const nanos = hrTimeToNanos(hrTime2);
-  return nanos.toString();
-}
-var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
-function identity(value) {
-  return value;
-}
-var JSON_ENCODER = {
-  encodeHrTime: encodeTimestamp,
-  encodeSpanContext: identity,
-  encodeOptionalSpanContext: identity,
-  encodeUint8Array: (bytes) => {
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(bytes).toString("base64");
-    }
-    const chars = new Array(bytes.length);
-    for (let i = 0; i < bytes.length; i++) {
-      chars[i] = String.fromCharCode(bytes[i]);
-    }
-    return btoa(chars.join(""));
-  }
-};
-
-// ../../node_modules/@opentelemetry/resources/build/esm/default-service-name.js
-var serviceName;
-function defaultServiceName() {
-  if (serviceName === void 0) {
-    try {
-      const argv0 = globalThis.process.argv0;
-      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
-    } catch {
-      serviceName = "unknown_service";
-    }
-  }
-  return serviceName;
-}
-
-// ../../node_modules/@opentelemetry/resources/build/esm/utils.js
-var isPromiseLike = (val) => {
-  return val !== null && typeof val === "object" && typeof val.then === "function";
-};
-
-// ../../node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
-var ResourceImpl = class _ResourceImpl {
-  _rawAttributes;
-  _asyncAttributesPending = false;
-  _schemaUrl;
-  _memoizedAttributes;
-  static FromAttributeList(attributes, options) {
-    const res = new _ResourceImpl({}, options);
-    res._rawAttributes = guardedRawAttributes(attributes);
-    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
-    return res;
-  }
-  constructor(resource, options) {
-    const attributes = resource.attributes ?? {};
-    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
-      if (isPromiseLike(v)) {
-        this._asyncAttributesPending = true;
-      }
-      return [k, v];
-    });
-    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
-    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
-  }
-  get asyncAttributesPending() {
-    return this._asyncAttributesPending;
-  }
-  async waitForAsyncAttributes() {
-    if (!this.asyncAttributesPending) {
-      return;
-    }
-    for (let i = 0; i < this._rawAttributes.length; i++) {
-      const [k, v] = this._rawAttributes[i];
-      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
-    }
-    this._asyncAttributesPending = false;
-  }
-  get attributes() {
-    if (this.asyncAttributesPending) {
-      diag.error("Accessing resource attributes before async attributes settled");
-    }
-    if (this._memoizedAttributes) {
-      return this._memoizedAttributes;
-    }
-    const attrs = {};
-    for (const [k, v] of this._rawAttributes) {
-      if (isPromiseLike(v)) {
-        diag.debug(`Unsettled resource attribute ${k} skipped`);
-        continue;
-      }
-      if (v != null) {
-        attrs[k] ??= v;
-      }
-    }
-    if (!this._asyncAttributesPending) {
-      this._memoizedAttributes = attrs;
-    }
-    return attrs;
-  }
-  getRawAttributes() {
-    return this._rawAttributes;
-  }
-  get schemaUrl() {
-    return this._schemaUrl;
-  }
-  merge(resource) {
-    if (resource == null)
-      return this;
-    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
-    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
-    return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
-  }
-};
-function resourceFromAttributes(attributes, options) {
-  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
-}
-function defaultResource() {
-  return resourceFromAttributes({
-    [ATTR_SERVICE_NAME]: defaultServiceName(),
-    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
-    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
-    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
-  });
-}
-function guardedRawAttributes(attributes) {
-  return attributes.map(([k, v]) => {
-    if (isPromiseLike(v)) {
-      return [
-        k,
-        v.catch((err) => {
-          diag.debug("promise rejection for resource attribute: %s - %s", k, err);
-          return void 0;
-        })
-      ];
-    }
-    return [k, v];
-  });
-}
-function validateSchemaUrl(schemaUrl) {
-  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
-    return schemaUrl;
-  }
-  diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
-  return void 0;
-}
-function mergeSchemaUrl(old, updating) {
-  const oldSchemaUrl = old?.schemaUrl;
-  const updatingSchemaUrl = updating?.schemaUrl;
-  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
-  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
-  if (isOldEmpty) {
-    return updatingSchemaUrl;
-  }
-  if (isUpdatingEmpty) {
-    return oldSchemaUrl;
-  }
-  if (oldSchemaUrl === updatingSchemaUrl) {
-    return oldSchemaUrl;
-  }
-  diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
-  return void 0;
-}
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
-var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
-var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
-function buildSpanFlagsFrom(traceFlags, isRemote) {
-  let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK;
-  if (isRemote) {
-    flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
-  }
-  return flags;
-}
-function sdkSpanToOtlpSpan(span, encoder) {
-  const ctx = span.spanContext();
-  const status = span.status;
-  const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0;
-  return {
-    traceId: encoder.encodeSpanContext(ctx.traceId),
-    spanId: encoder.encodeSpanContext(ctx.spanId),
-    parentSpanId,
-    traceState: ctx.traceState?.serialize(),
-    name: span.name,
-    // Span kind is offset by 1 because the API does not define a value for unset
-    kind: span.kind == null ? 0 : span.kind + 1,
-    startTimeUnixNano: encoder.encodeHrTime(span.startTime),
-    endTimeUnixNano: encoder.encodeHrTime(span.endTime),
-    attributes: toAttributes(span.attributes, encoder),
-    droppedAttributesCount: span.droppedAttributesCount,
-    events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
-    droppedEventsCount: span.droppedEventsCount,
-    status: {
-      // API and proto enums share the same values
-      code: status.code,
-      message: status.message
-    },
-    links: span.links.map((link) => toOtlpLink(link, encoder)),
-    droppedLinksCount: span.droppedLinksCount,
-    flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote)
-  };
-}
-function toOtlpLink(link, encoder) {
-  return {
-    attributes: link.attributes ? toAttributes(link.attributes, encoder) : [],
-    spanId: encoder.encodeSpanContext(link.context.spanId),
-    traceId: encoder.encodeSpanContext(link.context.traceId),
-    traceState: link.context.traceState?.serialize(),
-    droppedAttributesCount: link.droppedAttributesCount || 0,
-    flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote)
-  };
-}
-function toOtlpSpanEvent(timedEvent, encoder) {
-  return {
-    attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes, encoder) : [],
-    name: timedEvent.name,
-    timeUnixNano: encoder.encodeHrTime(timedEvent.time),
-    droppedAttributesCount: timedEvent.droppedAttributesCount || 0
-  };
-}
-function createExportTraceServiceRequest(spans, encoder) {
-  return {
-    resourceSpans: spanRecordsToResourceSpans(spans, encoder)
-  };
-}
-function createResourceMap(readableSpans) {
-  const resourceMap = /* @__PURE__ */ new Map();
-  for (const record of readableSpans) {
-    let ilsMap = resourceMap.get(record.resource);
-    if (!ilsMap) {
-      ilsMap = /* @__PURE__ */ new Map();
-      resourceMap.set(record.resource, ilsMap);
-    }
-    const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
-    let records = ilsMap.get(instrumentationScopeKey);
-    if (!records) {
-      records = [];
-      ilsMap.set(instrumentationScopeKey, records);
-    }
-    records.push(record);
-  }
-  return resourceMap;
-}
-function spanRecordsToResourceSpans(readableSpans, encoder) {
-  const resourceMap = createResourceMap(readableSpans);
-  const out = [];
-  const entryIterator = resourceMap.entries();
-  let entry = entryIterator.next();
-  while (!entry.done) {
-    const [resource, ilmMap] = entry.value;
-    const scopeResourceSpans = [];
-    const ilmIterator = ilmMap.values();
-    let ilmEntry = ilmIterator.next();
-    while (!ilmEntry.done) {
-      const scopeSpans = ilmEntry.value;
-      if (scopeSpans.length > 0) {
-        const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
-        scopeResourceSpans.push({
-          scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
-          spans,
-          schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
-        });
-      }
-      ilmEntry = ilmIterator.next();
-    }
-    const processedResource = createResource(resource, encoder);
-    const transformedSpans = {
-      resource: processedResource,
-      scopeSpans: scopeResourceSpans,
-      schemaUrl: processedResource.schemaUrl
-    };
-    out.push(transformedSpans);
-    entry = entryIterator.next();
-  }
-  return out;
-}
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
-var JsonTraceSerializer = {
-  serializeRequest: (arg) => {
-    const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
-    const encoder = new TextEncoder();
-    return encoder.encode(JSON.stringify(request));
-  },
-  deserializeResponse: (arg) => {
-    if (arg.length === 0) {
-      return {};
-    }
-    const decoder = new TextDecoder();
-    return JSON.parse(decoder.decode(arg));
-  }
-};
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
-function validateAndNormalizeHeaders(partialHeaders) {
-  const headers = {};
-  Object.entries(partialHeaders ?? {}).forEach(([key, value]) => {
-    if (typeof value !== "undefined") {
-      headers[key] = String(value);
-    } else {
-      diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
-    }
-  });
-  return headers;
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
-function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
-  return async () => {
-    const requiredHeaders = {
-      ...await defaultHeaders()
-    };
-    const headers = {};
-    if (fallbackHeaders != null) {
-      Object.assign(headers, await fallbackHeaders());
-    }
-    if (userProvidedHeaders != null) {
-      Object.assign(headers, validateAndNormalizeHeaders(await userProvidedHeaders()));
-    }
-    return Object.assign(headers, requiredHeaders);
-  };
-}
-function validateUserProvidedUrl(url) {
-  if (url == null) {
-    return void 0;
-  }
-  try {
-    const base = globalThis.location?.href;
-    return new URL(url, base).href;
-  } catch {
-    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
-  }
-}
-function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
-    headers: mergeHeaders(userProvidedConfiguration.headers, fallbackConfiguration.headers, defaultConfiguration.headers),
-    url: validateUserProvidedUrl(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url
-  };
-}
-function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
-  return {
-    ...getSharedConfigurationDefaults(),
-    headers: async () => requiredHeaders,
-    url: "http://localhost:4318/" + signalResourcePath
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js
-function httpAgentFactoryFromOptions(options) {
-  return async (protocol) => {
-    const isInsecure = protocol === "http:";
-    const module = isInsecure ? import("http") : import("https");
-    const { Agent } = await module;
-    if (isInsecure) {
-      const { ca, cert, key, ...insecureOptions } = options;
-      return new Agent(insecureOptions);
-    }
-    return new Agent(options);
-  };
-}
-function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
-  return {
-    ...mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
-    agentFactory: userProvidedConfiguration.agentFactory ?? fallbackConfiguration.agentFactory ?? defaultConfiguration.agentFactory,
-    userAgent: userProvidedConfiguration.userAgent
-  };
-}
-function getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
-  return {
-    ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath),
-    agentFactory: httpAgentFactoryFromOptions({ keepAlive: true })
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
-import * as zlib from "zlib";
-import { Readable } from "stream";
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
-function isExportHTTPErrorRetryable(statusCode) {
-  return statusCode === 429 || statusCode === 502 || statusCode === 503 || statusCode === 504;
-}
-function parseRetryAfterToMills(retryAfter) {
-  if (retryAfter == null) {
-    return void 0;
-  }
-  const seconds = Number.parseInt(retryAfter, 10);
-  if (Number.isInteger(seconds)) {
-    return seconds > 0 ? seconds * 1e3 : -1;
-  }
-  const delay = new Date(retryAfter).getTime() - Date.now();
-  if (delay >= 0) {
-    return delay;
-  }
-  return 0;
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js
-var VERSION2 = "0.214.0";
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
-var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION2}`;
-function sendWithHttp(request, url, headers, compression, userAgent, agent, data, timeoutMillis) {
-  return new Promise((resolve2) => {
-    const parsedUrl = new URL(url);
-    if (userAgent) {
-      headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`;
-    } else {
-      headers["User-Agent"] = DEFAULT_USER_AGENT;
-    }
-    const options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port,
-      path: parsedUrl.pathname,
-      method: "POST",
-      headers,
-      agent
-    };
-    const req = request(options, (res) => {
-      const responseData = [];
-      res.on("data", (chunk) => responseData.push(chunk));
-      res.on("end", () => {
-        if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
-            status: "success",
-            data: Buffer.concat(responseData)
-          });
-        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
-            status: "retryable",
-            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
-          });
-        } else {
-          const error = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
-          resolve2({
-            status: "failure",
-            error
-          });
-        }
-      });
-      res.on("error", (error) => {
-        if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
-            status: "success"
-          });
-        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
-            status: "retryable",
-            error,
-            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
-          });
-        } else {
-          resolve2({
-            status: "failure",
-            error
-          });
-        }
-      });
-    });
-    req.setTimeout(timeoutMillis, () => {
-      req.destroy();
-      resolve2({
-        status: "retryable",
-        error: new Error("Request timed out")
-      });
-    });
-    req.on("error", (error) => {
-      if (isHttpTransportNetworkErrorRetryable(error)) {
-        resolve2({
-          status: "retryable",
-          error
-        });
-      } else {
-        resolve2({
-          status: "failure",
-          error
-        });
-      }
-    });
-    compressAndSend(req, compression, data, (error) => {
-      resolve2({
-        status: "failure",
-        error
-      });
-    });
-  });
-}
-function compressAndSend(req, compression, data, onError) {
-  let dataStream = readableFromUint8Array(data);
-  if (compression === "gzip") {
-    req.setHeader("Content-Encoding", "gzip");
-    dataStream = dataStream.on("error", onError).pipe(zlib.createGzip()).on("error", onError);
-  }
-  dataStream.pipe(req).on("error", onError);
-}
-function readableFromUint8Array(buff) {
-  const readable = new Readable();
-  readable.push(buff);
-  readable.push(null);
-  return readable;
-}
-function isHttpTransportNetworkErrorRetryable(error) {
-  const RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-    "ECONNRESET",
-    "ECONNREFUSED",
-    "EPIPE",
-    "ETIMEDOUT",
-    "EAI_AGAIN",
-    "ENOTFOUND",
-    "ENETUNREACH",
-    "EHOSTUNREACH"
-  ]);
-  if ("code" in error && typeof error.code === "string") {
-    return RETRYABLE_NETWORK_ERROR_CODES.has(error.code);
-  }
-  return false;
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js
-var HttpExporterTransport = class {
-  _utils = null;
-  _parameters;
-  constructor(parameters) {
-    this._parameters = parameters;
-  }
-  async send(data, timeoutMillis) {
-    const { agent, request } = await this._loadUtils();
-    const headers = await this._parameters.headers();
-    return sendWithHttp(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis);
-  }
-  shutdown() {
-  }
-  async _loadUtils() {
-    let utils = this._utils;
-    if (utils === null) {
-      const protocol = new URL(this._parameters.url).protocol;
-      const [agent, request] = await Promise.all([
-        this._parameters.agentFactory(protocol),
-        requestFunctionFactory(protocol)
-      ]);
-      utils = this._utils = { agent, request };
-    }
-    return utils;
-  }
-};
-async function requestFunctionFactory(protocol) {
-  const module = protocol === "http:" ? import("http") : import("https");
-  const { request } = await module;
-  return request;
-}
-function createHttpExporterTransport(parameters) {
-  return new HttpExporterTransport(parameters);
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js
-var MAX_ATTEMPTS = 5;
-var INITIAL_BACKOFF = 1e3;
-var MAX_BACKOFF = 5e3;
-var BACKOFF_MULTIPLIER = 1.5;
-var JITTER = 0.2;
-function getJitter() {
-  return Math.random() * (2 * JITTER) - JITTER;
-}
-var RetryingTransport = class {
-  _transport;
-  constructor(transport) {
-    this._transport = transport;
-  }
-  retry(data, timeoutMillis, inMillis) {
-    return new Promise((resolve2, reject) => {
-      setTimeout(() => {
-        this._transport.send(data, timeoutMillis).then(resolve2, reject);
-      }, inMillis);
-    });
-  }
-  async send(data, timeoutMillis) {
-    let attempts = MAX_ATTEMPTS;
-    let nextBackoff = INITIAL_BACKOFF;
-    const deadline = Date.now() + timeoutMillis;
-    let result = await this._transport.send(data, timeoutMillis);
-    while (result.status === "retryable" && attempts > 0) {
-      attempts--;
-      const backoff = Math.max(Math.min(nextBackoff * (1 + getJitter()), MAX_BACKOFF), 0);
-      nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
-      const retryInMillis = result.retryInMillis ?? backoff;
-      const remainingTimeoutMillis = deadline - Date.now();
-      if (retryInMillis > remainingTimeoutMillis) {
-        diag.info(`Export retry time ${Math.round(retryInMillis)}ms exceeds remaining timeout ${Math.round(remainingTimeoutMillis)}ms, not retrying further.`);
-        return result;
-      }
-      diag.verbose(`Scheduling export retry in ${Math.round(retryInMillis)}ms`);
-      result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
-    }
-    if (result.status === "success") {
-      diag.verbose(`Export succeeded after ${MAX_ATTEMPTS - attempts} retry attempts.`);
-    } else if (result.status === "retryable") {
-      diag.info(`Export failed after maximum retry attempts (${MAX_ATTEMPTS}).`);
-    } else {
-      diag.info(`Export failed with non-retryable error: ${result.error}`);
-    }
-    return result;
-  }
-  shutdown() {
-    return this._transport.shutdown();
-  }
-};
-function createRetryingTransport(options) {
-  return new RetryingTransport(options.transport);
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js
-function createOtlpHttpExportDelegate(options, serializer) {
-  return createOtlpExportDelegate({
-    transport: createRetryingTransport({
-      transport: createHttpExporterTransport(options)
-    }),
-    serializer,
-    promiseHandler: createBoundedQueueExportPromiseHandler(options)
-  }, { timeout: options.timeoutMillis });
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js
-function parseAndValidateTimeoutFromEnv(timeoutEnvVar) {
-  const envTimeout = getNumberFromEnv(timeoutEnvVar);
-  if (envTimeout != null) {
-    if (Number.isFinite(envTimeout) && envTimeout > 0) {
-      return envTimeout;
-    }
-    diag.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`);
-  }
-  return void 0;
-}
-function getTimeoutFromEnv(signalIdentifier) {
-  const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`);
-  const nonSpecificTimeout = parseAndValidateTimeoutFromEnv("OTEL_EXPORTER_OTLP_TIMEOUT");
-  return specificTimeout ?? nonSpecificTimeout;
-}
-function parseAndValidateCompressionFromEnv(compressionEnvVar) {
-  const compression = getStringFromEnv(compressionEnvVar)?.trim();
-  if (compression == null || compression === "none" || compression === "gzip") {
-    return compression;
-  }
-  diag.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`);
-  return void 0;
-}
-function getCompressionFromEnv(signalIdentifier) {
-  const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`);
-  const nonSpecificCompression = parseAndValidateCompressionFromEnv("OTEL_EXPORTER_OTLP_COMPRESSION");
-  return specificCompression ?? nonSpecificCompression;
-}
-function getSharedConfigurationFromEnvironment(signalIdentifier) {
-  return {
-    timeoutMillis: getTimeoutFromEnv(signalIdentifier),
-    compression: getCompressionFromEnv(signalIdentifier)
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js
-import * as fs from "fs";
-import * as path from "path";
-function getStaticHeadersFromEnv(signalIdentifier) {
-  const signalSpecificRawHeaders = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`);
-  const nonSignalSpecificRawHeaders = getStringFromEnv("OTEL_EXPORTER_OTLP_HEADERS");
-  const signalSpecificHeaders = parseKeyPairsIntoRecord(signalSpecificRawHeaders);
-  const nonSignalSpecificHeaders = parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders);
-  if (Object.keys(signalSpecificHeaders).length === 0 && Object.keys(nonSignalSpecificHeaders).length === 0) {
-    return void 0;
-  }
-  return Object.assign({}, parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders), parseKeyPairsIntoRecord(signalSpecificRawHeaders));
-}
-function appendRootPathToUrlIfNeeded(url) {
-  try {
-    const parsedUrl = new URL(url);
-    return parsedUrl.toString();
-  } catch {
-    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
-    return void 0;
-  }
-}
-function appendResourcePathToUrl(url, path2) {
-  try {
-    new URL(url);
-  } catch {
-    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
-    return void 0;
-  }
-  if (!url.endsWith("/")) {
-    url = url + "/";
-  }
-  url += path2;
-  try {
-    new URL(url);
-  } catch {
-    diag.warn(`Configuration: Provided URL appended with '${path2}' is not a valid URL, using 'undefined' instead of '${url}'`);
-    return void 0;
-  }
-  return url;
-}
-function getNonSpecificUrlFromEnv(signalResourcePath) {
-  const envUrl = getStringFromEnv("OTEL_EXPORTER_OTLP_ENDPOINT");
-  if (envUrl === void 0) {
-    return void 0;
-  }
-  return appendResourcePathToUrl(envUrl, signalResourcePath);
-}
-function getSpecificUrlFromEnv(signalIdentifier) {
-  const envUrl = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`);
-  if (envUrl === void 0) {
-    return void 0;
-  }
-  return appendRootPathToUrlIfNeeded(envUrl);
-}
-function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningMessage) {
-  const signalSpecificPath = getStringFromEnv(signalSpecificEnvVar);
-  const nonSignalSpecificPath = getStringFromEnv(nonSignalSpecificEnvVar);
-  const filePath = signalSpecificPath ?? nonSignalSpecificPath;
-  if (filePath != null) {
-    try {
-      return fs.readFileSync(path.resolve(process.cwd(), filePath));
-    } catch {
-      diag.warn(warningMessage);
-      return void 0;
-    }
-  } else {
-    return void 0;
-  }
-}
-function getClientCertificateFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", "Failed to read client certificate chain file");
-}
-function getClientKeyFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_KEY`, "OTEL_EXPORTER_OTLP_CLIENT_KEY", "Failed to read client certificate private key file");
-}
-function getRootCertificateFromEnv(signalIdentifier) {
-  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CERTIFICATE", "Failed to read root certificate file");
-}
-function getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) {
-  return {
-    ...getSharedConfigurationFromEnvironment(signalIdentifier),
-    url: getSpecificUrlFromEnv(signalIdentifier) ?? getNonSpecificUrlFromEnv(signalResourcePath),
-    headers: wrapStaticHeadersInFunction(getStaticHeadersFromEnv(signalIdentifier)),
-    agentFactory: httpAgentFactoryFromOptions({
-      keepAlive: true,
-      ca: getRootCertificateFromEnv(signalIdentifier),
-      cert: getClientCertificateFromEnv(signalIdentifier),
-      key: getClientKeyFromEnv(signalIdentifier)
-    })
-  };
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js
-function convertLegacyHeaders(config) {
-  if (typeof config.headers === "function") {
-    return config.headers;
-  }
-  return wrapStaticHeadersInFunction(config.headers);
-}
-
-// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js
-function convertLegacyAgentOptions(config) {
-  if (typeof config.httpAgentOptions === "function") {
-    return config.httpAgentOptions;
-  }
-  let legacy = config.httpAgentOptions;
-  if (config.keepAlive != null) {
-    legacy = { keepAlive: config.keepAlive, ...legacy };
-  }
-  if (legacy != null) {
-    return httpAgentFactoryFromOptions(legacy);
-  } else {
-    return void 0;
-  }
-}
-function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
-  if (config.metadata) {
-    diag.warn("Metadata cannot be set when using http");
-  }
-  return mergeOtlpNodeHttpConfigurationWithDefaults({
-    url: config.url,
-    headers: convertLegacyHeaders(config),
-    concurrencyLimit: config.concurrencyLimit,
-    timeoutMillis: config.timeoutMillis,
-    compression: config.compression,
-    agentFactory: convertLegacyAgentOptions(config),
-    userAgent: config.userAgent
-  }, getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
-}
-
-// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js
-var OTLPTraceExporter = class extends OTLPExporterBase {
-  constructor(config = {}) {
-    super(createOtlpHttpExportDelegate(convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
-      "Content-Type": "application/json"
-    }), JsonTraceSerializer));
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
-var ExceptionEventName = "exception";
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
-var SpanImpl = class {
-  // Below properties are included to implement ReadableSpan for export
-  // purposes but are not intended to be written-to directly.
-  _spanContext;
-  kind;
-  parentSpanContext;
-  attributes = {};
-  links = [];
-  events = [];
-  startTime;
-  resource;
-  instrumentationScope;
-  _droppedAttributesCount = 0;
-  _droppedEventsCount = 0;
-  _droppedLinksCount = 0;
-  _attributesCount = 0;
-  name;
-  status = {
-    code: SpanStatusCode.UNSET
-  };
-  endTime = [0, 0];
-  _ended = false;
-  _duration = [-1, -1];
-  _spanProcessor;
-  _spanLimits;
-  _attributeValueLengthLimit;
-  _recordEndMetrics;
-  _performanceStartTime;
-  _performanceOffset;
-  _startTimeProvided;
-  /**
-   * Constructs a new SpanImpl instance.
-   */
-  constructor(opts) {
-    const now = Date.now();
-    this._spanContext = opts.spanContext;
-    this._performanceStartTime = otperformance.now();
-    this._performanceOffset = now - (this._performanceStartTime + otperformance.timeOrigin);
-    this._startTimeProvided = opts.startTime != null;
-    this._spanLimits = opts.spanLimits;
-    this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit ?? 0;
-    this._spanProcessor = opts.spanProcessor;
-    this.name = opts.name;
-    this.parentSpanContext = opts.parentSpanContext;
-    this.kind = opts.kind;
-    if (opts.links) {
-      for (const link of opts.links) {
-        this.addLink(link);
-      }
-    }
-    this.startTime = this._getTime(opts.startTime ?? now);
-    this.resource = opts.resource;
-    this.instrumentationScope = opts.scope;
-    this._recordEndMetrics = opts.recordEndMetrics;
-    if (opts.attributes != null) {
-      this.setAttributes(opts.attributes);
-    }
-    this._spanProcessor.onStart(this, opts.context);
-  }
-  spanContext() {
-    return this._spanContext;
-  }
-  setAttribute(key, value) {
-    if (value == null || this._isSpanEnded())
-      return this;
-    if (key.length === 0) {
-      diag.warn(`Invalid attribute key: ${key}`);
-      return this;
-    }
-    if (!isAttributeValue(value)) {
-      diag.warn(`Invalid attribute value set for key: ${key}`);
-      return this;
-    }
-    const { attributeCountLimit } = this._spanLimits;
-    const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
-    if (attributeCountLimit !== void 0 && this._attributesCount >= attributeCountLimit && isNewKey) {
-      this._droppedAttributesCount++;
-      return this;
-    }
-    this.attributes[key] = this._truncateToSize(value);
-    if (isNewKey) {
-      this._attributesCount++;
-    }
-    return this;
-  }
-  setAttributes(attributes) {
-    for (const key in attributes) {
-      if (Object.prototype.hasOwnProperty.call(attributes, key)) {
-        this.setAttribute(key, attributes[key]);
-      }
-    }
-    return this;
-  }
-  /**
-   *
-   * @param name Span Name
-   * @param [attributesOrStartTime] Span attributes or start time
-   *     if type is {@type TimeInput} and 3rd param is undefined
-   * @param [timeStamp] Specified time stamp for the event
-   */
-  addEvent(name, attributesOrStartTime, timeStamp) {
-    if (this._isSpanEnded())
-      return this;
-    const { eventCountLimit } = this._spanLimits;
-    if (eventCountLimit === 0) {
-      diag.warn("No events allowed.");
-      this._droppedEventsCount++;
-      return this;
-    }
-    if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
-      if (this._droppedEventsCount === 0) {
-        diag.debug("Dropping extra events.");
-      }
-      this.events.shift();
-      this._droppedEventsCount++;
-    }
-    if (isTimeInput(attributesOrStartTime)) {
-      if (!isTimeInput(timeStamp)) {
-        timeStamp = attributesOrStartTime;
-      }
-      attributesOrStartTime = void 0;
-    }
-    const sanitized = sanitizeAttributes(attributesOrStartTime);
-    const { attributePerEventCountLimit } = this._spanLimits;
-    const attributes = {};
-    let droppedAttributesCount = 0;
-    let eventAttributesCount = 0;
-    for (const attr in sanitized) {
-      if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) {
-        continue;
-      }
-      const attrVal = sanitized[attr];
-      if (attributePerEventCountLimit !== void 0 && eventAttributesCount >= attributePerEventCountLimit) {
-        droppedAttributesCount++;
-        continue;
-      }
-      attributes[attr] = this._truncateToSize(attrVal);
-      eventAttributesCount++;
-    }
-    this.events.push({
-      name,
-      attributes,
-      time: this._getTime(timeStamp),
-      droppedAttributesCount
-    });
-    return this;
-  }
-  addLink(link) {
-    if (this._isSpanEnded())
-      return this;
-    const { linkCountLimit } = this._spanLimits;
-    if (linkCountLimit === 0) {
-      this._droppedLinksCount++;
-      return this;
-    }
-    if (linkCountLimit !== void 0 && this.links.length >= linkCountLimit) {
-      if (this._droppedLinksCount === 0) {
-        diag.debug("Dropping extra links.");
-      }
-      this.links.shift();
-      this._droppedLinksCount++;
-    }
-    const { attributePerLinkCountLimit } = this._spanLimits;
-    const sanitized = sanitizeAttributes(link.attributes);
-    const attributes = {};
-    let droppedAttributesCount = 0;
-    let linkAttributesCount = 0;
-    for (const attr in sanitized) {
-      if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) {
-        continue;
-      }
-      const attrVal = sanitized[attr];
-      if (attributePerLinkCountLimit !== void 0 && linkAttributesCount >= attributePerLinkCountLimit) {
-        droppedAttributesCount++;
-        continue;
-      }
-      attributes[attr] = this._truncateToSize(attrVal);
-      linkAttributesCount++;
-    }
-    const processedLink = { context: link.context };
-    if (linkAttributesCount > 0) {
-      processedLink.attributes = attributes;
-    }
-    if (droppedAttributesCount > 0) {
-      processedLink.droppedAttributesCount = droppedAttributesCount;
-    }
-    this.links.push(processedLink);
-    return this;
-  }
-  addLinks(links) {
-    for (const link of links) {
-      this.addLink(link);
-    }
-    return this;
-  }
-  setStatus(status) {
-    if (this._isSpanEnded())
-      return this;
-    if (status.code === SpanStatusCode.UNSET)
-      return this;
-    if (this.status.code === SpanStatusCode.OK)
-      return this;
-    const newStatus = { code: status.code };
-    if (status.code === SpanStatusCode.ERROR) {
-      if (typeof status.message === "string") {
-        newStatus.message = status.message;
-      } else if (status.message != null) {
-        diag.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
-      }
-    }
-    this.status = newStatus;
-    return this;
-  }
-  updateName(name) {
-    if (this._isSpanEnded())
-      return this;
-    this.name = name;
-    return this;
-  }
-  end(endTime) {
-    if (this._isSpanEnded()) {
-      diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
-      return;
-    }
-    this.endTime = this._getTime(endTime);
-    this._duration = hrTimeDuration(this.startTime, this.endTime);
-    if (this._duration[0] < 0) {
-      diag.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime);
-      this.endTime = this.startTime.slice();
-      this._duration = [0, 0];
-    }
-    if (this._droppedEventsCount > 0) {
-      diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
-    }
-    if (this._droppedLinksCount > 0) {
-      diag.warn(`Dropped ${this._droppedLinksCount} links because linkCountLimit reached`);
-    }
-    if (this._spanProcessor.onEnding) {
-      this._spanProcessor.onEnding(this);
-    }
-    this._recordEndMetrics?.();
-    this._ended = true;
-    this._spanProcessor.onEnd(this);
-  }
-  _getTime(inp) {
-    if (typeof inp === "number" && inp <= otperformance.now()) {
-      return hrTime(inp + this._performanceOffset);
-    }
-    if (typeof inp === "number") {
-      return millisToHrTime(inp);
-    }
-    if (inp instanceof Date) {
-      return millisToHrTime(inp.getTime());
-    }
-    if (isTimeInputHrTime(inp)) {
-      return inp;
-    }
-    if (this._startTimeProvided) {
-      return millisToHrTime(Date.now());
-    }
-    const msDuration = otperformance.now() - this._performanceStartTime;
-    return addHrTimes(this.startTime, millisToHrTime(msDuration));
-  }
-  isRecording() {
-    return this._ended === false;
-  }
-  recordException(exception, time) {
-    const attributes = {};
-    if (typeof exception === "string") {
-      attributes[ATTR_EXCEPTION_MESSAGE] = exception;
-    } else if (exception) {
-      if (exception.code) {
-        attributes[ATTR_EXCEPTION_TYPE] = exception.code.toString();
-      } else if (exception.name) {
-        attributes[ATTR_EXCEPTION_TYPE] = exception.name;
-      }
-      if (exception.message) {
-        attributes[ATTR_EXCEPTION_MESSAGE] = exception.message;
-      }
-      if (exception.stack) {
-        attributes[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
-      }
-    }
-    if (attributes[ATTR_EXCEPTION_TYPE] || attributes[ATTR_EXCEPTION_MESSAGE]) {
-      this.addEvent(ExceptionEventName, attributes, time);
-    } else {
-      diag.warn(`Failed to record an exception ${exception}`);
-    }
-  }
-  get duration() {
-    return this._duration;
-  }
-  get ended() {
-    return this._ended;
-  }
-  get droppedAttributesCount() {
-    return this._droppedAttributesCount;
-  }
-  get droppedEventsCount() {
-    return this._droppedEventsCount;
-  }
-  get droppedLinksCount() {
-    return this._droppedLinksCount;
-  }
-  _isSpanEnded() {
-    if (this._ended) {
-      const error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
-      diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
-    }
-    return this._ended;
-  }
-  // Utility function to truncate given value within size
-  // for value type of string, will truncate to given limit
-  // for type of non-string, will return same value
-  _truncateToLimitUtil(value, limit) {
-    if (value.length <= limit) {
-      return value;
-    }
-    return value.substring(0, limit);
-  }
-  /**
-   * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
-   * return string with truncated to {@code attributeValueLengthLimit} characters
-   *
-   * If the given attribute value is array of strings then
-   * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
-   *
-   * Otherwise return same Attribute {@code value}
-   *
-   * @param value Attribute value
-   * @returns truncated attribute value if required, otherwise same value
-   */
-  _truncateToSize(value) {
-    const limit = this._attributeValueLengthLimit;
-    if (limit <= 0) {
-      diag.warn(`Attribute value limit must be positive, got ${limit}`);
-      return value;
-    }
-    if (typeof value === "string") {
-      return this._truncateToLimitUtil(value, limit);
-    }
-    if (Array.isArray(value)) {
-      return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
-    }
-    return value;
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
-var SamplingDecision2;
-(function(SamplingDecision3) {
-  SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD";
-  SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD";
-  SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
-})(SamplingDecision2 || (SamplingDecision2 = {}));
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
-var AlwaysOffSampler = class {
-  shouldSample() {
-    return {
-      decision: SamplingDecision2.NOT_RECORD
-    };
-  }
-  toString() {
-    return "AlwaysOffSampler";
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
-var AlwaysOnSampler = class {
-  shouldSample() {
-    return {
-      decision: SamplingDecision2.RECORD_AND_SAMPLED
-    };
-  }
-  toString() {
-    return "AlwaysOnSampler";
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
-var ParentBasedSampler = class {
-  _root;
-  _remoteParentSampled;
-  _remoteParentNotSampled;
-  _localParentSampled;
-  _localParentNotSampled;
-  constructor(config) {
-    this._root = config.root;
-    if (!this._root) {
-      globalErrorHandler(new Error("ParentBasedSampler must have a root sampler configured"));
-      this._root = new AlwaysOnSampler();
-    }
-    this._remoteParentSampled = config.remoteParentSampled ?? new AlwaysOnSampler();
-    this._remoteParentNotSampled = config.remoteParentNotSampled ?? new AlwaysOffSampler();
-    this._localParentSampled = config.localParentSampled ?? new AlwaysOnSampler();
-    this._localParentNotSampled = config.localParentNotSampled ?? new AlwaysOffSampler();
-  }
-  shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
-    const parentContext = trace.getSpanContext(context2);
-    if (!parentContext || !isSpanContextValid(parentContext)) {
-      return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
-    }
-    if (parentContext.isRemote) {
-      if (parentContext.traceFlags & TraceFlags.SAMPLED) {
-        return this._remoteParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
-      }
-      return this._remoteParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
-    }
-    if (parentContext.traceFlags & TraceFlags.SAMPLED) {
-      return this._localParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
-    }
-    return this._localParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
-  }
-  toString() {
-    return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
-var TraceIdRatioBasedSampler = class {
-  _ratio;
-  _upperBound;
-  constructor(ratio = 0) {
-    this._ratio = this._normalize(ratio);
-    this._upperBound = Math.floor(this._ratio * 4294967295);
-  }
-  shouldSample(context2, traceId) {
-    return {
-      decision: isValidTraceId(traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision2.RECORD_AND_SAMPLED : SamplingDecision2.NOT_RECORD
-    };
-  }
-  toString() {
-    return `TraceIdRatioBased{${this._ratio}}`;
-  }
-  _normalize(ratio) {
-    if (typeof ratio !== "number" || isNaN(ratio))
-      return 0;
-    return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
-  }
-  _accumulate(traceId) {
-    let accumulation = 0;
-    for (let i = 0; i < traceId.length / 8; i++) {
-      const pos = i * 8;
-      const part = parseInt(traceId.slice(pos, pos + 8), 16);
-      accumulation = (accumulation ^ part) >>> 0;
-    }
-    return accumulation;
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
-var TracesSamplerValues;
-(function(TracesSamplerValues2) {
-  TracesSamplerValues2["AlwaysOff"] = "always_off";
-  TracesSamplerValues2["AlwaysOn"] = "always_on";
-  TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off";
-  TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on";
-  TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
-  TracesSamplerValues2["TraceIdRatio"] = "traceidratio";
-})(TracesSamplerValues || (TracesSamplerValues = {}));
-var DEFAULT_RATIO = 1;
-function loadDefaultConfig() {
-  return {
-    sampler: buildSamplerFromEnv(),
-    forceFlushTimeoutMillis: 3e4,
-    generalLimits: {
-      attributeValueLengthLimit: getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
-      attributeCountLimit: getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128
-    },
-    spanLimits: {
-      attributeValueLengthLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
-      attributeCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? 128,
-      linkCountLimit: getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT") ?? 128,
-      eventCountLimit: getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT") ?? 128,
-      attributePerEventCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT") ?? 128,
-      attributePerLinkCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT") ?? 128
-    }
-  };
-}
-function buildSamplerFromEnv() {
-  const sampler = getStringFromEnv("OTEL_TRACES_SAMPLER") ?? TracesSamplerValues.ParentBasedAlwaysOn;
-  switch (sampler) {
-    case TracesSamplerValues.AlwaysOn:
-      return new AlwaysOnSampler();
-    case TracesSamplerValues.AlwaysOff:
-      return new AlwaysOffSampler();
-    case TracesSamplerValues.ParentBasedAlwaysOn:
-      return new ParentBasedSampler({
-        root: new AlwaysOnSampler()
-      });
-    case TracesSamplerValues.ParentBasedAlwaysOff:
-      return new ParentBasedSampler({
-        root: new AlwaysOffSampler()
-      });
-    case TracesSamplerValues.TraceIdRatio:
-      return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
-    case TracesSamplerValues.ParentBasedTraceIdRatio:
-      return new ParentBasedSampler({
-        root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv())
-      });
-    default:
-      diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`);
-      return new ParentBasedSampler({
-        root: new AlwaysOnSampler()
-      });
-  }
-}
-function getSamplerProbabilityFromEnv() {
-  const probability = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
-  if (probability == null) {
-    diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
-    return DEFAULT_RATIO;
-  }
-  if (probability < 0 || probability > 1) {
-    diag.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
-    return DEFAULT_RATIO;
-  }
-  return probability;
-}
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js
-var DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
-var DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
-function mergeConfig(userConfig) {
-  const perInstanceDefaults = {
-    sampler: buildSamplerFromEnv()
-  };
-  const DEFAULT_CONFIG = loadDefaultConfig();
-  const target = Object.assign({}, DEFAULT_CONFIG, perInstanceDefaults, userConfig);
-  target.generalLimits = Object.assign({}, DEFAULT_CONFIG.generalLimits, userConfig.generalLimits || {});
-  target.spanLimits = Object.assign({}, DEFAULT_CONFIG.spanLimits, userConfig.spanLimits || {});
-  return target;
-}
-function reconfigureLimits(userConfig) {
-  const spanLimits = Object.assign({}, userConfig.spanLimits);
-  spanLimits.attributeCountLimit = userConfig.spanLimits?.attributeCountLimit ?? userConfig.generalLimits?.attributeCountLimit ?? getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? DEFAULT_ATTRIBUTE_COUNT_LIMIT;
-  spanLimits.attributeValueLengthLimit = userConfig.spanLimits?.attributeValueLengthLimit ?? userConfig.generalLimits?.attributeValueLengthLimit ?? getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT;
-  return Object.assign({}, userConfig, { spanLimits });
-}
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
-var BatchSpanProcessorBase = class {
-  _maxExportBatchSize;
-  _maxQueueSize;
-  _scheduledDelayMillis;
-  _exportTimeoutMillis;
-  _exporter;
-  _isExporting = false;
-  _finishedSpans = [];
-  _timer;
-  _shutdownOnce;
-  _droppedSpansCount = 0;
-  constructor(exporter, config) {
-    this._exporter = exporter;
-    this._maxExportBatchSize = typeof config?.maxExportBatchSize === "number" ? config.maxExportBatchSize : getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE") ?? 512;
-    this._maxQueueSize = typeof config?.maxQueueSize === "number" ? config.maxQueueSize : getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE") ?? 2048;
-    this._scheduledDelayMillis = typeof config?.scheduledDelayMillis === "number" ? config.scheduledDelayMillis : getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY") ?? 5e3;
-    this._exportTimeoutMillis = typeof config?.exportTimeoutMillis === "number" ? config.exportTimeoutMillis : getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT") ?? 3e4;
-    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
-    if (this._maxExportBatchSize > this._maxQueueSize) {
-      diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
-      this._maxExportBatchSize = this._maxQueueSize;
-    }
-  }
-  forceFlush() {
-    if (this._shutdownOnce.isCalled) {
-      return this._shutdownOnce.promise;
-    }
-    return this._flushAll();
-  }
-  // does nothing.
-  onStart(_span, _parentContext) {
-  }
-  onEnd(span) {
-    if (this._shutdownOnce.isCalled) {
-      return;
-    }
-    if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
-      return;
-    }
-    this._addToBuffer(span);
-  }
-  shutdown() {
-    return this._shutdownOnce.call();
-  }
-  _shutdown() {
-    return Promise.resolve().then(() => {
-      return this.onShutdown();
-    }).then(() => {
-      return this._flushAll();
-    }).then(() => {
-      return this._exporter.shutdown();
-    });
-  }
-  /** Add a span in the buffer. */
-  _addToBuffer(span) {
-    if (this._finishedSpans.length >= this._maxQueueSize) {
-      if (this._droppedSpansCount === 0) {
-        diag.debug("maxQueueSize reached, dropping spans");
-      }
-      this._droppedSpansCount++;
-      return;
-    }
-    if (this._droppedSpansCount > 0) {
-      diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
-      this._droppedSpansCount = 0;
-    }
-    this._finishedSpans.push(span);
-    this._maybeStartTimer();
-  }
-  /**
-   * Send all spans to the exporter respecting the batch size limit
-   * This function is used only on forceFlush or shutdown,
-   * for all other cases _flush should be used
-   * */
-  _flushAll() {
-    return new Promise((resolve2, reject) => {
-      const promises = [];
-      const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
-      for (let i = 0, j = count; i < j; i++) {
-        promises.push(this._flushOneBatch());
-      }
-      Promise.all(promises).then(() => {
-        resolve2();
-      }).catch(reject);
-    });
-  }
-  _flushOneBatch() {
-    this._clearTimer();
-    if (this._finishedSpans.length === 0) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("Timeout"));
-      }, this._exportTimeoutMillis);
-      context.with(suppressTracing(context.active()), () => {
-        let spans;
-        if (this._finishedSpans.length <= this._maxExportBatchSize) {
-          spans = this._finishedSpans;
-          this._finishedSpans = [];
-        } else {
-          spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
-        }
-        const doExport = () => this._exporter.export(spans, (result) => {
-          clearTimeout(timer);
-          if (result.code === ExportResultCode.SUCCESS) {
-            resolve2();
-          } else {
-            reject(result.error ?? new Error("BatchSpanProcessor: span export failed"));
-          }
-        });
-        let pendingResources = null;
-        for (let i = 0, len = spans.length; i < len; i++) {
-          const span = spans[i];
-          if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
-            pendingResources ??= [];
-            pendingResources.push(span.resource.waitForAsyncAttributes());
-          }
-        }
-        if (pendingResources === null) {
-          doExport();
-        } else {
-          Promise.all(pendingResources).then(doExport, (err) => {
-            globalErrorHandler(err);
-            reject(err);
-          });
-        }
-      });
-    });
-  }
-  _maybeStartTimer() {
-    if (this._isExporting)
-      return;
-    const flush = () => {
-      this._isExporting = true;
-      this._flushOneBatch().finally(() => {
-        this._isExporting = false;
-        if (this._finishedSpans.length > 0) {
-          this._clearTimer();
-          this._maybeStartTimer();
-        }
-      }).catch((e) => {
-        this._isExporting = false;
-        globalErrorHandler(e);
-      });
-    };
-    if (this._finishedSpans.length >= this._maxExportBatchSize) {
-      return flush();
-    }
-    if (this._timer !== void 0)
-      return;
-    this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
-    if (typeof this._timer !== "number") {
-      this._timer.unref();
-    }
-  }
-  _clearTimer() {
-    if (this._timer !== void 0) {
-      clearTimeout(this._timer);
-      this._timer = void 0;
-    }
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
-var BatchSpanProcessor = class extends BatchSpanProcessorBase {
-  onShutdown() {
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js
-var SPAN_ID_BYTES = 8;
-var TRACE_ID_BYTES = 16;
-var RandomIdGenerator = class {
-  /**
-   * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
-   * characters corresponding to 128 bits.
-   */
-  generateTraceId = getIdGenerator(TRACE_ID_BYTES);
-  /**
-   * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
-   * characters corresponding to 64 bits.
-   */
-  generateSpanId = getIdGenerator(SPAN_ID_BYTES);
-};
-var SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
-function getIdGenerator(bytes) {
-  return function generateId() {
-    for (let i = 0; i < bytes / 4; i++) {
-      SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4);
-    }
-    for (let i = 0; i < bytes; i++) {
-      if (SHARED_BUFFER[i] > 0) {
-        break;
-      } else if (i === bytes - 1) {
-        SHARED_BUFFER[bytes - 1] = 1;
-      }
-    }
-    return SHARED_BUFFER.toString("hex", 0, bytes);
-  };
-}
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/semconv.js
-var ATTR_OTEL_SPAN_PARENT_ORIGIN = "otel.span.parent.origin";
-var ATTR_OTEL_SPAN_SAMPLING_RESULT = "otel.span.sampling_result";
-var METRIC_OTEL_SDK_SPAN_LIVE = "otel.sdk.span.live";
-var METRIC_OTEL_SDK_SPAN_STARTED = "otel.sdk.span.started";
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/TracerMetrics.js
-var TracerMetrics = class {
-  startedSpans;
-  liveSpans;
-  constructor(meter) {
-    this.startedSpans = meter.createCounter(METRIC_OTEL_SDK_SPAN_STARTED, {
-      unit: "{span}",
-      description: "The number of created spans."
-    });
-    this.liveSpans = meter.createUpDownCounter(METRIC_OTEL_SDK_SPAN_LIVE, {
-      unit: "{span}",
-      description: "The number of currently live spans."
-    });
-  }
-  startSpan(parentSpanCtx, samplingDecision) {
-    const samplingDecisionStr = samplingDecisionToString(samplingDecision);
-    this.startedSpans.add(1, {
-      [ATTR_OTEL_SPAN_PARENT_ORIGIN]: parentOrigin(parentSpanCtx),
-      [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr
-    });
-    if (samplingDecision === SamplingDecision2.NOT_RECORD) {
-      return () => {
-      };
-    }
-    const liveSpanAttributes = {
-      [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr
-    };
-    this.liveSpans.add(1, liveSpanAttributes);
-    return () => {
-      this.liveSpans.add(-1, liveSpanAttributes);
-    };
-  }
-};
-function parentOrigin(parentSpanContext) {
-  if (!parentSpanContext) {
-    return "none";
-  }
-  if (parentSpanContext.isRemote) {
-    return "remote";
-  }
-  return "local";
-}
-function samplingDecisionToString(decision) {
-  switch (decision) {
-    case SamplingDecision2.RECORD_AND_SAMPLED:
-      return "RECORD_AND_SAMPLE";
-    case SamplingDecision2.RECORD:
-      return "RECORD_ONLY";
-    case SamplingDecision2.NOT_RECORD:
-      return "DROP";
-  }
-}
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/version.js
-var VERSION3 = "2.6.1";
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
-var Tracer = class {
-  _sampler;
-  _generalLimits;
-  _spanLimits;
-  _idGenerator;
-  instrumentationScope;
-  _resource;
-  _spanProcessor;
-  _tracerMetrics;
-  /**
-   * Constructs a new Tracer instance.
-   */
-  constructor(instrumentationScope, config, resource, spanProcessor) {
-    const localConfig = mergeConfig(config);
-    this._sampler = localConfig.sampler;
-    this._generalLimits = localConfig.generalLimits;
-    this._spanLimits = localConfig.spanLimits;
-    this._idGenerator = config.idGenerator || new RandomIdGenerator();
-    this._resource = resource;
-    this._spanProcessor = spanProcessor;
-    this.instrumentationScope = instrumentationScope;
-    const meter = localConfig.meterProvider ? localConfig.meterProvider.getMeter("@opentelemetry/sdk-trace", VERSION3) : createNoopMeter();
-    this._tracerMetrics = new TracerMetrics(meter);
-  }
-  /**
-   * Starts a new Span or returns the default NoopSpan based on the sampling
-   * decision.
-   */
-  startSpan(name, options = {}, context2 = context.active()) {
-    if (options.root) {
-      context2 = trace.deleteSpan(context2);
-    }
-    const parentSpan = trace.getSpan(context2);
-    if (isTracingSuppressed(context2)) {
-      diag.debug("Instrumentation suppressed, returning Noop Span");
-      const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
-      return nonRecordingSpan;
-    }
-    const parentSpanContext = parentSpan?.spanContext();
-    const spanId = this._idGenerator.generateSpanId();
-    let validParentSpanContext;
-    let traceId;
-    let traceState;
-    if (!parentSpanContext || !trace.isSpanContextValid(parentSpanContext)) {
-      traceId = this._idGenerator.generateTraceId();
-    } else {
-      traceId = parentSpanContext.traceId;
-      traceState = parentSpanContext.traceState;
-      validParentSpanContext = parentSpanContext;
-    }
-    const spanKind = options.kind ?? SpanKind.INTERNAL;
-    const links = (options.links ?? []).map((link) => {
-      return {
-        context: link.context,
-        attributes: sanitizeAttributes(link.attributes)
-      };
-    });
-    const attributes = sanitizeAttributes(options.attributes);
-    const samplingResult = this._sampler.shouldSample(context2, traceId, name, spanKind, attributes, links);
-    const recordEndMetrics = this._tracerMetrics.startSpan(parentSpanContext, samplingResult.decision);
-    traceState = samplingResult.traceState ?? traceState;
-    const traceFlags = samplingResult.decision === SamplingDecision.RECORD_AND_SAMPLED ? TraceFlags.SAMPLED : TraceFlags.NONE;
-    const spanContext = { traceId, spanId, traceFlags, traceState };
-    if (samplingResult.decision === SamplingDecision.NOT_RECORD) {
-      diag.debug("Recording is off, propagating context in a non-recording span");
-      const nonRecordingSpan = trace.wrapSpanContext(spanContext);
-      return nonRecordingSpan;
-    }
-    const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
-    const span = new SpanImpl({
-      resource: this._resource,
-      scope: this.instrumentationScope,
-      context: context2,
-      spanContext,
-      name,
-      kind: spanKind,
-      links,
-      parentSpanContext: validParentSpanContext,
-      attributes: initAttributes,
-      startTime: options.startTime,
-      spanProcessor: this._spanProcessor,
-      spanLimits: this._spanLimits,
-      recordEndMetrics
-    });
-    return span;
-  }
-  startActiveSpan(name, arg2, arg3, arg4) {
-    let opts;
-    let ctx;
-    let fn;
-    if (arguments.length < 2) {
-      return;
-    } else if (arguments.length === 2) {
-      fn = arg2;
-    } else if (arguments.length === 3) {
-      opts = arg2;
-      fn = arg3;
-    } else {
-      opts = arg2;
-      ctx = arg3;
-      fn = arg4;
-    }
-    const parentContext = ctx ?? context.active();
-    const span = this.startSpan(name, opts, parentContext);
-    const contextWithSpanSet = trace.setSpan(parentContext, span);
-    return context.with(contextWithSpanSet, fn, void 0, span);
-  }
-  /** Returns the active {@link GeneralLimits}. */
-  getGeneralLimits() {
-    return this._generalLimits;
-  }
-  /** Returns the active {@link SpanLimits}. */
-  getSpanLimits() {
-    return this._spanLimits;
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
-var MultiSpanProcessor = class {
-  _spanProcessors;
-  constructor(spanProcessors) {
-    this._spanProcessors = spanProcessors;
-  }
-  forceFlush() {
-    const promises = [];
-    for (const spanProcessor of this._spanProcessors) {
-      promises.push(spanProcessor.forceFlush());
-    }
-    return new Promise((resolve2) => {
-      Promise.all(promises).then(() => {
-        resolve2();
-      }).catch((error) => {
-        globalErrorHandler(error || new Error("MultiSpanProcessor: forceFlush failed"));
-        resolve2();
-      });
-    });
-  }
-  onStart(span, context2) {
-    for (const spanProcessor of this._spanProcessors) {
-      spanProcessor.onStart(span, context2);
-    }
-  }
-  onEnding(span) {
-    for (const spanProcessor of this._spanProcessors) {
-      if (spanProcessor.onEnding) {
-        spanProcessor.onEnding(span);
-      }
-    }
-  }
-  onEnd(span) {
-    for (const spanProcessor of this._spanProcessors) {
-      spanProcessor.onEnd(span);
-    }
-  }
-  shutdown() {
-    const promises = [];
-    for (const spanProcessor of this._spanProcessors) {
-      promises.push(spanProcessor.shutdown());
-    }
-    return new Promise((resolve2, reject) => {
-      Promise.all(promises).then(() => {
-        resolve2();
-      }, reject);
-    });
-  }
-};
-
-// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
-var ForceFlushState;
-(function(ForceFlushState2) {
-  ForceFlushState2[ForceFlushState2["resolved"] = 0] = "resolved";
-  ForceFlushState2[ForceFlushState2["timeout"] = 1] = "timeout";
-  ForceFlushState2[ForceFlushState2["error"] = 2] = "error";
-  ForceFlushState2[ForceFlushState2["unresolved"] = 3] = "unresolved";
-})(ForceFlushState || (ForceFlushState = {}));
-var BasicTracerProvider = class {
-  _config;
-  _tracers = /* @__PURE__ */ new Map();
-  _resource;
-  _activeSpanProcessor;
-  constructor(config = {}) {
-    const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
-    this._resource = mergedConfig.resource ?? defaultResource();
-    this._config = Object.assign({}, mergedConfig, {
-      resource: this._resource
-    });
-    const spanProcessors = [];
-    if (config.spanProcessors?.length) {
-      spanProcessors.push(...config.spanProcessors);
-    }
-    this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
-  }
-  getTracer(name, version, options) {
-    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
-    if (!this._tracers.has(key)) {
-      this._tracers.set(key, new Tracer({ name, version, schemaUrl: options?.schemaUrl }, this._config, this._resource, this._activeSpanProcessor));
-    }
-    return this._tracers.get(key);
-  }
-  forceFlush() {
-    const timeout = this._config.forceFlushTimeoutMillis;
-    const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
-      return new Promise((resolve2) => {
-        let state;
-        const timeoutInterval = setTimeout(() => {
-          resolve2(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
-          state = ForceFlushState.timeout;
-        }, timeout);
-        spanProcessor.forceFlush().then(() => {
-          clearTimeout(timeoutInterval);
-          if (state !== ForceFlushState.timeout) {
-            state = ForceFlushState.resolved;
-            resolve2(state);
-          }
-        }).catch((error) => {
-          clearTimeout(timeoutInterval);
-          state = ForceFlushState.error;
-          resolve2(error);
-        });
-      });
-    });
-    return new Promise((resolve2, reject) => {
-      Promise.all(promises).then((results) => {
-        const errors = results.filter((result) => result !== ForceFlushState.resolved);
-        if (errors.length > 0) {
-          reject(errors);
-        } else {
-          resolve2();
-        }
-      }).catch((error) => reject([error]));
-    });
-  }
-  shutdown() {
-    return this._activeSpanProcessor.shutdown();
-  }
-};
-
-// src/lifecycle.ts
-import { EventEmitter } from "node:events";
-
-// src/signal-handler.ts
-var coexistenceState = "unknown";
-function setCoexistenceState(s) {
-  coexistenceState = s;
-}
-function getCoexistenceState() {
-  return coexistenceState;
-}
-
-// src/lifecycle.ts
-var CoreState = {
-  IDLE: "IDLE",
-  REGISTERING: "REGISTERING",
-  KEY_PENDING: "KEY_PENDING",
-  KEY_RESOLVED: "KEY_RESOLVED",
-  ACTIVE: "ACTIVE",
-  ACTIVE_DEGRADED: "ACTIVE_DEGRADED",
-  SHUTTING_DOWN: "SHUTTING_DOWN",
-  SHUTDOWN: "SHUTDOWN",
-  PRODUCTION_DISABLED: "PRODUCTION_DISABLED",
-  REGISTRATION_FAILED: "REGISTRATION_FAILED"
-};
-var AuthState = {
-  ANONYMOUS: "ANONYMOUS",
-  AUTHENTICATED: "AUTHENTICATED",
-  CLAIMING: "CLAIMING",
-  CLAIMED: "CLAIMED"
-};
-var OtelState = {
-  UNCONFIGURED: "UNCONFIGURED",
-  CONFIGURING: "CONFIGURING",
-  OWNS_PROVIDER: "OWNS_PROVIDER",
-  AUTO_ATTACHED: "AUTO_ATTACHED",
-  PROCESSOR_PRESENT: "PROCESSOR_PRESENT",
-  COEXISTENCE_FAILED: "COEXISTENCE_FAILED"
-};
-var VALID_CORE_TRANSITIONS = {
-  [CoreState.IDLE]: [CoreState.REGISTERING, CoreState.REGISTRATION_FAILED, CoreState.SHUTTING_DOWN],
-  [CoreState.REGISTERING]: [
-    CoreState.KEY_PENDING,
-    CoreState.PRODUCTION_DISABLED,
-    CoreState.REGISTRATION_FAILED,
-    CoreState.SHUTTING_DOWN
-  ],
-  [CoreState.KEY_PENDING]: [
-    CoreState.KEY_RESOLVED,
-    CoreState.REGISTRATION_FAILED,
-    CoreState.SHUTTING_DOWN
-  ],
-  [CoreState.KEY_RESOLVED]: [
-    CoreState.ACTIVE,
-    CoreState.ACTIVE_DEGRADED,
-    CoreState.SHUTTING_DOWN
-  ],
-  [CoreState.ACTIVE]: [
-    CoreState.ACTIVE_DEGRADED,
-    CoreState.SHUTTING_DOWN
-  ],
-  [CoreState.ACTIVE_DEGRADED]: [
-    CoreState.ACTIVE,
-    CoreState.SHUTTING_DOWN
-  ],
-  [CoreState.SHUTTING_DOWN]: [CoreState.SHUTDOWN],
-  [CoreState.SHUTDOWN]: [],
-  [CoreState.PRODUCTION_DISABLED]: [],
-  [CoreState.REGISTRATION_FAILED]: []
-};
-var VALID_AUTH_TRANSITIONS = {
-  [AuthState.ANONYMOUS]: [AuthState.CLAIMING],
-  [AuthState.AUTHENTICATED]: [AuthState.CLAIMING],
-  [AuthState.CLAIMING]: [AuthState.CLAIMED],
-  [AuthState.CLAIMED]: [AuthState.CLAIMING]
-};
-var VALID_OTEL_TRANSITIONS = {
-  [OtelState.UNCONFIGURED]: [OtelState.CONFIGURING],
-  [OtelState.CONFIGURING]: [
-    OtelState.OWNS_PROVIDER,
-    OtelState.AUTO_ATTACHED,
-    OtelState.PROCESSOR_PRESENT,
-    OtelState.COEXISTENCE_FAILED
-  ],
-  [OtelState.OWNS_PROVIDER]: [],
-  [OtelState.AUTO_ATTACHED]: [],
-  [OtelState.PROCESSOR_PRESENT]: [],
-  [OtelState.COEXISTENCE_FAILED]: []
-};
-var _coreState = CoreState.IDLE;
-var _authState = AuthState.ANONYMOUS;
-var _otelState = OtelState.UNCONFIGURED;
-var _emitter = new EventEmitter();
-var _logger = null;
-var _initialized = false;
-var _initWarned = false;
-var _coreReadyEmitted = false;
-var _authInitialized = false;
-var _emitting = false;
-function initLifecycle(options) {
-  if (_initialized) {
-    options.logger("warn", "[glasstrace] initLifecycle() called twice \u2014 ignored.");
-    return;
-  }
-  _logger = options.logger;
-  _initialized = true;
-}
-function warnIfNotInitialized() {
-  if (!_initialized && !_initWarned) {
-    _initWarned = true;
-    console.warn(
-      "[glasstrace] Lifecycle state changed before initLifecycle() was called. Logger not available \u2014 errors will be silent."
-    );
-  }
-}
-function setCoreState(to) {
-  warnIfNotInitialized();
-  const from = _coreState;
-  if (from === to) return;
-  const valid = VALID_CORE_TRANSITIONS[from];
-  if (!valid.includes(to)) {
-    _logger?.(
-      "warn",
-      `[glasstrace] Invalid core state transition: ${from} \u2192 ${to}. Ignored.`
-    );
-    return;
-  }
-  _coreState = to;
-  if (_emitting) return;
-  _emitting = true;
-  try {
-    emitSafe("core:state_changed", { from, to });
-    const current = _coreState;
-    if (!_coreReadyEmitted && (current === CoreState.ACTIVE || current === CoreState.ACTIVE_DEGRADED)) {
-      _coreReadyEmitted = true;
-      emitSafe("core:ready", {});
-    }
-    if (current === CoreState.SHUTTING_DOWN) {
-      emitSafe("core:shutdown_started", {});
-    }
-    if (current === CoreState.SHUTDOWN) {
-      emitSafe("core:shutdown_completed", {});
-    }
-  } finally {
-    _emitting = false;
-  }
-}
-function initAuthState(state) {
-  if (_authInitialized) {
-    _logger?.(
-      "warn",
-      "[glasstrace] initAuthState() called after auth state already initialized. Ignored."
-    );
-    return;
-  }
-  _authInitialized = true;
-  _authState = state;
-}
-function setAuthState(to) {
-  warnIfNotInitialized();
-  const from = _authState;
-  if (from === to) return;
-  const valid = VALID_AUTH_TRANSITIONS[from];
-  if (!valid.includes(to)) {
-    _logger?.(
-      "warn",
-      `[glasstrace] Invalid auth state transition: ${from} \u2192 ${to}. Ignored.`
-    );
-    return;
-  }
-  _authState = to;
-}
-function setOtelState(to) {
-  warnIfNotInitialized();
-  const from = _otelState;
-  if (from === to) return;
-  const valid = VALID_OTEL_TRANSITIONS[from];
-  if (!valid.includes(to)) {
-    _logger?.(
-      "warn",
-      `[glasstrace] Invalid OTel state transition: ${from} \u2192 ${to}. Ignored.`
-    );
-    return;
-  }
-  _otelState = to;
-}
-function getCoreState() {
-  return _coreState;
-}
-function getSdkState() {
-  return {
-    core: _coreState,
-    auth: _authState,
-    otel: _otelState
-  };
-}
-function onLifecycleEvent(event, listener) {
-  _emitter.on(event, listener);
-}
-function emitLifecycleEvent(event, payload) {
-  emitSafe(event, payload);
-}
-function offLifecycleEvent(event, listener) {
-  _emitter.off(event, listener);
-}
-function emitSafe(event, payload) {
-  const listeners = _emitter.listeners(event);
-  for (const listener of listeners) {
-    try {
-      const result = listener(payload);
-      if (result && typeof result.catch === "function") {
-        result.catch((err) => {
-          _logger?.(
-            "error",
-            `[glasstrace] Async error in lifecycle event listener for "${event}": ${err instanceof Error ? err.message : String(err)}`
-          );
-        });
-      }
-    } catch (err) {
-      _logger?.(
-        "error",
-        `[glasstrace] Error in lifecycle event listener for "${event}": ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-}
-function isReady() {
-  return _coreState === CoreState.ACTIVE || _coreState === CoreState.ACTIVE_DEGRADED;
-}
-function waitForReady(timeoutMs = 3e4) {
-  if (isReady()) {
-    return Promise.resolve();
-  }
-  if (_coreState === CoreState.PRODUCTION_DISABLED || _coreState === CoreState.REGISTRATION_FAILED || _coreState === CoreState.SHUTTING_DOWN || _coreState === CoreState.SHUTDOWN) {
-    return Promise.reject(new Error(`SDK is in terminal state: ${_coreState}`));
-  }
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    const listener = ({ to }) => {
-      if (settled) return;
-      if (to === CoreState.ACTIVE || to === CoreState.ACTIVE_DEGRADED) {
-        settled = true;
-        offLifecycleEvent("core:state_changed", listener);
-        resolve2();
-      } else if (to === CoreState.PRODUCTION_DISABLED || to === CoreState.REGISTRATION_FAILED || to === CoreState.SHUTTING_DOWN || to === CoreState.SHUTDOWN) {
-        settled = true;
-        offLifecycleEvent("core:state_changed", listener);
-        reject(new Error(`SDK reached terminal state: ${to}`));
-      }
-    };
-    onLifecycleEvent("core:state_changed", listener);
-    if (timeoutMs > 0) {
-      const timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
-        offLifecycleEvent("core:state_changed", listener);
-        reject(new Error(`waitForReady timed out after ${timeoutMs}ms (state: ${_coreState})`));
-      }, timeoutMs);
-      if (typeof timer === "object" && "unref" in timer) {
-        timer.unref();
-      }
-    }
-  });
-}
-function getStatus() {
-  let mode;
-  if (_coreState === CoreState.PRODUCTION_DISABLED) {
-    mode = "disabled";
-  } else if (_authState === AuthState.CLAIMING || _authState === AuthState.CLAIMED) {
-    mode = "claiming";
-  } else if (_authState === AuthState.AUTHENTICATED) {
-    mode = "authenticated";
-  } else {
-    mode = "anonymous";
-  }
-  let tracing;
-  if (_otelState === OtelState.COEXISTENCE_FAILED || _otelState === OtelState.UNCONFIGURED || _otelState === OtelState.CONFIGURING) {
-    tracing = "not-configured";
-  } else if (_coreState === CoreState.ACTIVE_DEGRADED) {
-    tracing = "degraded";
-  } else if (_otelState === OtelState.AUTO_ATTACHED || _otelState === OtelState.PROCESSOR_PRESENT) {
-    tracing = "coexistence";
-  } else {
-    tracing = "active";
-  }
-  return {
-    ready: isReady(),
-    mode,
-    tracing
-  };
-}
-var _shutdownHooks = [];
-var _signalHandlersRegistered = false;
-var _signalHandler = null;
-var _beforeExitRegistered = false;
-var _beforeExitHandler = null;
-var _shutdownExecuted = false;
-function registerShutdownHook(hook) {
-  _shutdownHooks.push(hook);
-  _shutdownHooks.sort((a, b) => a.priority - b.priority);
-}
-async function executeShutdown(timeoutMs = 5e3) {
-  if (_shutdownExecuted) return;
-  _shutdownExecuted = true;
-  setCoreState(CoreState.SHUTTING_DOWN);
-  for (const hook of _shutdownHooks) {
-    try {
-      const hookPromise = hook.fn();
-      hookPromise.catch(() => {
-      });
-      await Promise.race([
-        hookPromise,
-        new Promise((_, reject) => {
-          const timer = setTimeout(() => reject(new Error(`Shutdown hook "${hook.name}" timed out`)), timeoutMs);
-          if (typeof timer === "object" && "unref" in timer) {
-            timer.unref();
-          }
-        })
-      ]);
-    } catch (err) {
-      _logger?.(
-        "warn",
-        `[glasstrace] Shutdown hook "${hook.name}" failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  setCoreState(CoreState.SHUTDOWN);
-}
-function registerSignalHandlers() {
-  if (_signalHandlersRegistered) return;
-  if (typeof process === "undefined" || typeof process.once !== "function") return;
-  _signalHandlersRegistered = true;
-  const otherSigtermListeners = process.listenerCount("SIGTERM");
-  const otherSigintListeners = process.listenerCount("SIGINT");
-  const handler = (signal) => {
-    void executeShutdown().finally(() => {
-      if (_signalHandler) {
-        process.removeListener("SIGTERM", _signalHandler);
-        process.removeListener("SIGINT", _signalHandler);
-      }
-      const otherListeners = signal === "SIGTERM" ? otherSigtermListeners : otherSigintListeners;
-      const otherProviderOwnsSignal = getCoexistenceState() === "coexisting" && otherListeners > 0;
-      if (!otherProviderOwnsSignal) {
-        process.kill(process.pid, signal);
-      }
-    });
-  };
-  _signalHandler = handler;
-  process.once("SIGTERM", handler);
-  process.once("SIGINT", handler);
-}
-function registerBeforeExitTrigger() {
-  if (_beforeExitRegistered) return;
-  if (typeof process === "undefined" || typeof process.once !== "function") return;
-  _beforeExitRegistered = true;
-  const handler = () => {
-    void executeShutdown();
-  };
-  _beforeExitHandler = handler;
-  process.once("beforeExit", handler);
-}
-
-// src/coexistence.ts
-var GLASSTRACE_EXPORTER_BRAND = /* @__PURE__ */ Symbol.for("glasstrace.exporter");
-function createGlasstraceSpanProcessor(options) {
-  const config = resolveConfig(options);
-  const exporterUrl = `${config.endpoint}/v1/traces`;
-  const createOtlpExporter = (url, headers) => new OTLPTraceExporter({ url, headers });
-  const exporter = new GlasstraceExporter({
-    getApiKey: getResolvedApiKey,
-    sessionManager: getSessionManager(),
-    getConfig: () => getActiveConfig(),
-    environment: config.environment,
-    endpointUrl: exporterUrl,
-    createDelegate: createOtlpExporter,
-    // Propagate verbose so exporter-level enrichment and export logs
-    // stay observable whether the processor is built automatically by
-    // the coexistence path or wired manually by the developer.
-    verbose: config.verbose
-  });
-  registerExporterForKeyNotification(exporter);
-  return new BatchSpanProcessor(exporter, {
-    scheduledDelayMillis: 1e3
-  });
-}
-function isGlasstraceProcessorPresent(tracerProvider) {
-  try {
-    const proxy = tracerProvider;
-    const delegate = typeof proxy.getDelegate === "function" ? proxy.getDelegate() : tracerProvider;
-    const v2 = delegate;
-    const v2Processors = v2._activeSpanProcessor?._spanProcessors;
-    if (Array.isArray(v2Processors) && hasBrandedProcessor(v2Processors)) {
-      return true;
-    }
-    const v1 = delegate;
-    if (typeof v1.getActiveSpanProcessor === "function") {
-      const active = v1.getActiveSpanProcessor();
-      const processors = active?._spanProcessors;
-      if (Array.isArray(processors) && hasBrandedProcessor(processors)) {
-        return true;
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function tryAutoAttachGlasstraceProcessor(tracerProvider, options) {
-  try {
-    if (isGlasstraceProcessorPresent(tracerProvider)) {
-      return "already_present";
-    }
-    const proxy = tracerProvider;
-    const delegate = typeof proxy.getDelegate === "function" ? proxy.getDelegate() : tracerProvider;
-    const withAdd = delegate;
-    if (typeof withAdd.addSpanProcessor === "function") {
-      const processor2 = createGlasstraceSpanProcessor(options);
-      withAdd.addSpanProcessor(processor2);
-      return { method: "v1_public", processor: processor2 };
-    }
-    const v2 = delegate;
-    const multiProcessor = v2._activeSpanProcessor;
-    if (!multiProcessor || !Array.isArray(multiProcessor._spanProcessors)) {
-      return null;
-    }
-    const processor = createGlasstraceSpanProcessor(options);
-    multiProcessor._spanProcessors.push(processor);
-    return { method: "v2_private", processor };
-  } catch {
-    return null;
-  }
-}
-function emitNudgeMessage() {
-  const isSentry = detectSentry();
-  if (isSentry) {
-    sdkLog(
-      "info",
-      `[glasstrace] Detected existing OTel provider \u2014 auto-attached Glasstrace span processor.
-For a cleaner setup, add Glasstrace to your Sentry config:
-
-  import { createGlasstraceSpanProcessor } from '@glasstrace/sdk';
-
-  Sentry.init({
-    dsn: '...',
-    openTelemetrySpanProcessors: [createGlasstraceSpanProcessor()],
-  });
-
-This message will not appear once Glasstrace is added to your provider config.`
-    );
-  } else {
-    sdkLog(
-      "info",
-      `[glasstrace] Detected existing OTel provider \u2014 auto-attached Glasstrace span processor.
-For a cleaner setup, add Glasstrace to your provider config:
-
-  import { createGlasstraceSpanProcessor } from '@glasstrace/sdk';
-
-  const provider = new BasicTracerProvider({
-    spanProcessors: [
-      // ... your existing processors,
-      createGlasstraceSpanProcessor(),
-    ],
-  });
-
-This message will not appear once Glasstrace is added to your provider config.`
-    );
-  }
-}
-function emitGuidanceMessage() {
-  const isSentry = detectSentry();
-  if (isSentry) {
-    sdkLog(
-      "warn",
-      `[glasstrace] An existing OTel TracerProvider is registered but Glasstrace could not auto-attach its span processor.
-Add Glasstrace to your Sentry config:
-
-  import { createGlasstraceSpanProcessor } from '@glasstrace/sdk';
-
-  Sentry.init({
-    dsn: '...',
-    openTelemetrySpanProcessors: [createGlasstraceSpanProcessor()],
-  });`
-    );
-  } else {
-    sdkLog(
-      "warn",
-      `[glasstrace] An existing OTel TracerProvider is registered but Glasstrace could not auto-attach its span processor.
-Add Glasstrace to your provider configuration:
-
-  import { createGlasstraceSpanProcessor } from '@glasstrace/sdk';
-
-  const provider = new BasicTracerProvider({
-    spanProcessors: [
-      // ... your existing processors,
-      createGlasstraceSpanProcessor(),
-    ],
-  });`
-    );
-  }
-}
-function hasBrandedProcessor(processors) {
-  return processors.some((p) => {
-    const exporter = p._exporter;
-    return exporter?.[GLASSTRACE_EXPORTER_BRAND] === true;
-  });
-}
-function detectSentry() {
-  try {
-    __require.resolve("@sentry/node");
-    return true;
-  } catch {
-    try {
-      __require.resolve("@sentry/nextjs");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// src/otel-config.ts
-var _resolvedApiKey = API_KEY_PENDING;
-var _activeExporter = null;
-var _additionalExporters = [];
-var _injectedProcessor = null;
-function setResolvedApiKey(key) {
-  _resolvedApiKey = key;
-}
-function getResolvedApiKey() {
-  return _resolvedApiKey;
-}
-function notifyApiKeyResolved() {
-  _activeExporter?.notifyKeyResolved();
-  for (const exporter of _additionalExporters) {
-    exporter.notifyKeyResolved();
-  }
-}
-function registerExporterForKeyNotification(exporter) {
-  _additionalExporters.push(exporter);
-}
-async function tryImport(moduleId) {
-  try {
-    return await Function("id", "return import(id)")(moduleId);
-  } catch {
-    return null;
-  }
-}
-async function configureOtel(config, sessionManager) {
-  setOtelState(OtelState.CONFIGURING);
-  await new Promise((resolve2) => {
-    if (typeof setImmediate === "function") {
-      setImmediate(resolve2);
-    } else {
-      setTimeout(resolve2, 0);
-    }
-  });
-  const existingProvider = trace.getTracerProvider();
-  const probeTracer = existingProvider.getTracer("glasstrace-probe");
-  const anotherProviderRegistered = probeTracer.constructor.name !== "ProxyTracer";
-  if (anotherProviderRegistered) {
-    setCoexistenceState("coexisting");
-    await runCoexistencePath(existingProvider, config);
-    return;
-  }
-  setCoexistenceState("sole-owner");
-  await runRegistrationPath(config, sessionManager);
-}
-async function runCoexistencePath(existingProvider, config) {
-  const result = tryAutoAttachGlasstraceProcessor(existingProvider, {
-    endpoint: config.endpoint,
-    verbose: config.verbose
-  });
-  if (result === "already_present") {
-    if (config.verbose) {
-      sdkLog("info", "[glasstrace] Existing provider detected \u2014 Glasstrace processor already present.");
-    }
-    setOtelState(OtelState.PROCESSOR_PRESENT);
-    emitLifecycleEvent("otel:configured", { state: OtelState.PROCESSOR_PRESENT, scenario: "B-clean" });
-    return;
-  }
-  if (result !== null) {
-    _injectedProcessor = result.processor;
-    if (config.verbose) {
-      sdkLog(
-        "info",
-        "[glasstrace] Existing provider detected \u2014 auto-attached Glasstrace span processor."
-      );
-    }
-    registerShutdownHook({
-      name: "coexistence-flush",
-      priority: 5,
-      fn: async () => {
-        if (_injectedProcessor) {
-          await _injectedProcessor.forceFlush();
-        }
-      }
-    });
-    registerBeforeExitTrigger();
-    const scenario = result.method === "v1_public" ? "D1" : "B-auto";
-    setOtelState(OtelState.AUTO_ATTACHED);
-    emitLifecycleEvent("otel:configured", { state: OtelState.AUTO_ATTACHED, scenario });
-    emitLifecycleEvent("otel:injection_succeeded", { method: result.method });
-    emitNudgeMessage();
-    return;
-  }
-  if (config.verbose) {
-    sdkLog("info", "[glasstrace] Existing provider detected \u2014 could not auto-attach.");
-  }
-  emitGuidanceMessage();
-  setOtelState(OtelState.COEXISTENCE_FAILED);
-  emitLifecycleEvent("otel:configured", { state: OtelState.COEXISTENCE_FAILED, scenario: "C/F" });
-  emitLifecycleEvent("otel:injection_failed", { reason: "provider internals inaccessible" });
-  const coreState = getCoreState();
-  if (coreState === CoreState.ACTIVE || coreState === CoreState.KEY_RESOLVED) {
-    setCoreState(CoreState.ACTIVE_DEGRADED);
-  }
-}
-async function runRegistrationPath(config, sessionManager) {
-  const exporterUrl = `${config.endpoint}/v1/traces`;
-  const createOtlpExporter = (url, headers) => new OTLPTraceExporter({ url, headers });
-  const glasstraceExporter = new GlasstraceExporter({
-    getApiKey: getResolvedApiKey,
-    sessionManager,
-    getConfig: () => getActiveConfig(),
-    environment: config.environment,
-    endpointUrl: exporterUrl,
-    createDelegate: createOtlpExporter,
-    verbose: config.verbose
-  });
-  _activeExporter = glasstraceExporter;
-  const vercelOtel = await tryImport("@vercel/otel");
-  if (vercelOtel && typeof vercelOtel.registerOTel === "function") {
-    const otelConfig = {
-      serviceName: "glasstrace-sdk",
-      traceExporter: glasstraceExporter
-    };
-    const prismaModule2 = await tryImport("@prisma/instrumentation");
-    if (prismaModule2) {
-      const PrismaInstrumentation = prismaModule2.PrismaInstrumentation;
-      if (PrismaInstrumentation) {
-        otelConfig.instrumentations = [new PrismaInstrumentation()];
-      }
-    }
-    vercelOtel.registerOTel(otelConfig);
-    const vercelProxy = trace.getTracerProvider();
-    const vercelConcreteProvider = typeof vercelProxy.getDelegate === "function" ? vercelProxy.getDelegate() : vercelProxy;
-    registerShutdownHook({
-      name: "vercel-otel-shutdown",
-      priority: 0,
-      fn: async () => {
-        try {
-          await vercelConcreteProvider.shutdown?.();
-        } catch {
-        }
-      }
-    });
-    registerBeforeExitTrigger();
-    setOtelState(OtelState.OWNS_PROVIDER);
-    emitLifecycleEvent("otel:configured", { state: OtelState.OWNS_PROVIDER, scenario: "E" });
-    return;
-  }
-  if (config.verbose) {
-    diag.setLogger(
-      {
-        verbose: (msg) => sdkLog("info", `[otel] ${msg}`),
-        debug: (msg) => sdkLog("info", `[otel] ${msg}`),
-        info: (msg) => sdkLog("info", `[otel] ${msg}`),
-        warn: (msg) => sdkLog("warn", `[otel] ${msg}`),
-        error: (msg) => sdkLog("error", `[otel] ${msg}`)
-      },
-      DiagLogLevel.WARN
-    );
-  }
-  const processor = new BatchSpanProcessor(glasstraceExporter, {
-    scheduledDelayMillis: 1e3
-  });
-  const provider = new BasicTracerProvider({
-    spanProcessors: [processor]
-  });
-  trace.setGlobalTracerProvider(provider);
-  registerShutdownHook({
-    name: "otel-provider-shutdown",
-    priority: 0,
-    fn: async () => {
-      await provider.shutdown();
-    }
-  });
-  registerBeforeExitTrigger();
-  const prismaModule = await tryImport("@prisma/instrumentation");
-  if (prismaModule) {
-    const PrismaInstrumentation = prismaModule.PrismaInstrumentation;
-    if (PrismaInstrumentation) {
-      try {
-        const inst = new PrismaInstrumentation();
-        inst.setTracerProvider(provider);
-        inst.enable();
-      } catch {
-      }
-    }
-  }
-  setOtelState(OtelState.OWNS_PROVIDER);
-  emitLifecycleEvent("otel:configured", { state: OtelState.OWNS_PROVIDER, scenario: "A" });
-}
-
-// src/context-manager.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-function installContextManager() {
-  try {
-    const als = new AsyncLocalStorage();
-    const contextManager = {
-      active: () => als.getStore() ?? ROOT_CONTEXT,
-      with: (context2, fn, thisArg, ...args) => als.run(context2, () => fn.apply(thisArg, args)),
-      bind: (context2, target) => {
-        if (typeof target === "function") {
-          const bound = (...fnArgs) => als.run(context2, () => target(...fnArgs));
-          return bound;
-        }
-        return target;
-      },
-      enable: () => contextManager,
-      disable: () => contextManager
-    };
-    const success = context.setGlobalContextManager(contextManager);
-    if (!success) {
-      console.warn(
-        "[glasstrace] Another context manager is already registered. Trace context propagation may not work as expected."
-      );
-    }
-    return success;
-  } catch {
-    return false;
-  }
-}
-
-// src/heartbeat.ts
-var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
-var BACKOFF_BASE_MS = HEARTBEAT_INTERVAL_MS;
-var BACKOFF_MAX_MS = 30 * 60 * 1e3;
-var BACKOFF_JITTER = 0.2;
-var HEARTBEAT_SHUTDOWN_PRIORITY = 10;
-var SHUTDOWN_MARKER_RELPATH = ".glasstrace/shutdown-requested";
-var heartbeatTimer = null;
-var heartbeatGeneration = 0;
-var backoffAttempts = 0;
-var backoffUntil = 0;
-var tickInProgress = false;
-var shutdownHookRegistered = false;
-var shutdownFired = false;
-function startHeartbeat(config, anonKey, sdkVersion, generation, onClaimTransition) {
-  if (heartbeatTimer !== null) return;
-  heartbeatGeneration = generation;
-  heartbeatTimer = setInterval(() => {
-    void heartbeatTick(config, anonKey, sdkVersion, generation, onClaimTransition);
-  }, HEARTBEAT_INTERVAL_MS);
-  heartbeatTimer.unref();
-  registerHeartbeatShutdownHook(config, anonKey, sdkVersion);
-  if (config.verbose) {
-    sdkLog("info", "[glasstrace] Heartbeat started (5-minute interval).");
-  }
-}
-function stopHeartbeat() {
-  if (heartbeatTimer !== null) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = null;
-  }
-}
-function checkShutdownMarker(projectRoot) {
-  let fsSync = null;
-  let pathSync = null;
-  try {
-    fsSync = __require("node:fs");
-    pathSync = __require("node:path");
-  } catch {
-    return { triggered: false };
-  }
-  const root = projectRoot ?? (typeof process !== "undefined" ? process.cwd() : ".");
-  const markerPath = pathSync.join(root, SHUTDOWN_MARKER_RELPATH);
-  if (!fsSync.existsSync(markerPath)) return { triggered: false };
-  try {
-    fsSync.unlinkSync(markerPath);
-  } catch {
-  }
-  const shutdown = executeShutdown().catch(() => {
-  });
-  return { triggered: true, shutdown };
-}
-async function heartbeatTick(config, anonKey, sdkVersion, generation, onClaimTransition) {
-  if (tickInProgress) return;
-  tickInProgress = true;
-  try {
-    if (generation !== heartbeatGeneration) {
-      stopHeartbeat();
-      return;
-    }
-    const markerResult = checkShutdownMarker();
-    if (markerResult.triggered) {
-      stopHeartbeat();
-      if (markerResult.shutdown) {
-        await markerResult.shutdown;
-      }
-      return;
-    }
-    if (Date.now() < backoffUntil) {
-      if (config.verbose) {
-        sdkLog("info", "[glasstrace] Heartbeat skipped (rate-limit backoff).");
-      }
-      return;
-    }
-    const healthReport = collectHealthReport(sdkVersion);
-    const initResult = await performInit(config, anonKey, sdkVersion, healthReport);
-    if (generation !== heartbeatGeneration) return;
-    if (initResult === null && consumeRateLimitFlag()) {
-      backoffAttempts++;
-      const delay = Math.min(
-        BACKOFF_BASE_MS * Math.pow(2, backoffAttempts - 1),
-        BACKOFF_MAX_MS
-      );
-      const jitter = delay * BACKOFF_JITTER * (Math.random() * 2 - 1);
-      backoffUntil = Date.now() + delay + jitter;
-      if (config.verbose) {
-        sdkLog("info", `[glasstrace] Heartbeat backing off for ${Math.round((delay + jitter) / 1e3)}s.`);
-      }
-    } else {
-      backoffAttempts = 0;
-      backoffUntil = 0;
-    }
-    if (initResult?.claimResult) {
-      onClaimTransition(initResult.claimResult.newApiKey, initResult.claimResult.accountId);
-    }
-    if (config.verbose) {
-      sdkLog("info", "[glasstrace] Heartbeat completed.");
-    }
-  } finally {
-    tickInProgress = false;
-  }
-}
-function registerHeartbeatShutdownHook(config, anonKey, sdkVersion) {
-  if (shutdownHookRegistered) return;
-  shutdownHookRegistered = true;
-  registerShutdownHook({
-    name: "heartbeat-final-report",
-    priority: HEARTBEAT_SHUTDOWN_PRIORITY,
-    fn: async () => {
-      if (shutdownFired) return;
-      shutdownFired = true;
-      if (heartbeatTimer !== null) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-      }
-      try {
-        const healthReport = collectHealthReport(sdkVersion);
-        await performInit(config, anonKey, sdkVersion, healthReport);
-      } catch {
-      }
-    }
-  });
-}
-
-// src/runtime-state.ts
-import { writeFileSync, renameSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-var _projectRoot = null;
-var _sdkVersion = "unknown";
-var _lastScenario;
-var _debounceTimer = null;
-var _started = false;
-function startRuntimeStateWriter(options) {
-  if (_started) return;
-  _started = true;
-  _projectRoot = options.projectRoot;
-  _sdkVersion = options.sdkVersion;
-  onLifecycleEvent("core:state_changed", ({ to }) => {
-    if (to === CoreState.SHUTDOWN) {
-      writeStateNow();
-    } else {
-      debouncedWrite();
-    }
-  });
-  onLifecycleEvent("otel:configured", ({ scenario }) => {
-    _lastScenario = scenario;
-    debouncedWrite();
-  });
-  onLifecycleEvent("auth:key_resolved", () => debouncedWrite());
-  onLifecycleEvent("auth:claim_started", () => debouncedWrite());
-  onLifecycleEvent("auth:claim_completed", () => debouncedWrite());
-  writeStateNow();
-}
-function debouncedWrite() {
-  if (_debounceTimer) return;
-  _debounceTimer = setTimeout(() => {
-    _debounceTimer = null;
-    writeStateNow();
-  }, 1e3);
-  if (typeof _debounceTimer === "object" && "unref" in _debounceTimer) {
-    _debounceTimer.unref();
-  }
-}
-function writeStateNow() {
-  if (!_projectRoot) return;
-  try {
-    const state = getSdkState();
-    const runtimeState = {
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pid: process.pid,
-      sdkVersion: _sdkVersion,
-      core: { state: state.core },
-      auth: { state: state.auth },
-      otel: { state: state.otel, scenario: _lastScenario }
-    };
-    const dir = join(_projectRoot, ".glasstrace");
-    const filePath = join(dir, "runtime-state.json");
-    const tmpPath = join(dir, "runtime-state.json.tmp");
-    mkdirSync(dir, { recursive: true, mode: 448 });
-    writeFileSync(tmpPath, JSON.stringify(runtimeState, null, 2) + "\n", {
-      mode: 384
-    });
-    renameSync(tmpPath, filePath);
-  } catch (err) {
-    sdkLog(
-      "warn",
-      `[glasstrace] Failed to write runtime state: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-
-// src/register.ts
-function maskKey(key) {
-  if (key.length <= 12) return key.slice(0, 4) + "...";
-  return key.slice(0, 8) + "..." + key.slice(-4);
-}
-var consoleCaptureInstalled = false;
-var discoveryHandler = null;
-var registrationGeneration = 0;
-var _sessionManager = null;
-function getSessionManager() {
-  if (!_sessionManager) {
-    _sessionManager = new SessionManager();
-  }
-  return _sessionManager;
-}
-function registerGlasstrace(options) {
-  try {
-    if (getCoreState() !== CoreState.IDLE) {
-      return;
-    }
-    initLifecycle({ logger: sdkLog });
-    if (typeof process === "undefined" || typeof process.versions?.node !== "string") {
-      console.warn(
-        "[glasstrace] SDK requires a Node.js runtime. Edge Runtime, browser, and Deno without Node compat are not supported. Glasstrace is disabled in this environment."
-      );
-      return;
-    }
-    setCoreState(CoreState.REGISTERING);
-    startRuntimeStateWriter({
-      projectRoot: process.cwd(),
-      sdkVersion: "0.19.0"
-    });
-    const config = resolveConfig(options);
-    if (config.verbose) {
-      console.info("[glasstrace] Config resolved.");
-    }
-    if (isProductionDisabled(config)) {
-      setCoreState(CoreState.PRODUCTION_DISABLED);
-      console.warn(
-        "[glasstrace] Disabled in production. Set GLASSTRACE_FORCE_ENABLE=true to override."
-      );
-      return;
-    }
-    if (config.verbose) {
-      console.info("[glasstrace] Not production-disabled.");
-    }
-    const existingProbe = trace.getTracerProvider().getTracer("glasstrace-probe");
-    const anotherProviderRegistered = existingProbe.constructor.name !== "ProxyTracer";
-    if (anotherProviderRegistered) {
-      setCoexistenceState("coexisting");
-    }
-    registerSignalHandlers();
-    const anonymous = isAnonymousMode(config);
-    let effectiveKey = config.apiKey;
-    initAuthState(anonymous ? AuthState.ANONYMOUS : AuthState.AUTHENTICATED);
-    if (effectiveKey) {
-      setResolvedApiKey(effectiveKey);
-      emitLifecycleEvent("auth:key_resolved", {
-        key: maskKey(effectiveKey),
-        mode: anonymous ? "anonymous" : "dev"
-      });
-    }
-    if (config.verbose) {
-      console.info(
-        `[glasstrace] Auth mode = ${anonymous ? "anonymous" : "dev-key"}.`
-      );
-    }
-    const cachedInitResponse = loadCachedConfig();
-    if (cachedInitResponse) {
-      _setCurrentConfig(cachedInitResponse);
-    }
-    if (config.verbose) {
-      console.info(
-        `[glasstrace] Cached config ${cachedInitResponse ? "loaded and applied" : "not found"}.`
-      );
-    }
-    const sessionManager = getSessionManager();
-    if (config.verbose) {
-      console.info("[glasstrace] SessionManager created.");
-    }
-    setCoreState(CoreState.KEY_PENDING);
-    const currentGeneration = registrationGeneration;
-    if (anotherProviderRegistered) {
-      if (config.verbose) {
-        console.info("[glasstrace] Another OTel provider detected \u2014 using existing context manager.");
-      }
-    } else {
-      const contextManagerInstalled = installContextManager();
-      if (config.verbose) {
-        console.info(
-          contextManagerInstalled ? "[glasstrace] Context manager installed." : "[glasstrace] Context manager not available \u2014 trace context propagation disabled."
-        );
-      }
-    }
-    void configureOtel(config, sessionManager).then(
-      () => {
-        maybeInstallConsoleCapture();
-        if (config.verbose) {
-          console.info("[glasstrace] OTel configured.");
-        }
-      },
-      (err) => {
-        console.warn(
-          `[glasstrace] Failed to configure OTel: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    );
-    if (anonymous) {
-      if (isDiscoveryEnabled(config)) {
-        let resolvedAnonKey = null;
-        const anonKeyPromise = getOrCreateAnonKey();
-        const getClaimState = () => {
-          if (getLinkedAccountId()) return { claimed: true };
-          if (getClaimResult()) return { claimed: true };
-          return null;
-        };
-        discoveryHandler = createDiscoveryHandler(
-          async () => resolvedAnonKey,
-          () => sessionManager.getSessionId(getResolvedApiKey()),
-          getClaimState
-        );
-        if (config.verbose) {
-          console.info("[glasstrace] Discovery endpoint registered (key pending).");
-        }
-        void (async () => {
-          try {
-            if (currentGeneration !== registrationGeneration) return;
-            const anonKey = await anonKeyPromise;
-            resolvedAnonKey = anonKey;
-            setResolvedApiKey(anonKey);
-            notifyApiKeyResolved();
-            emitLifecycleEvent("auth:key_resolved", { key: maskKey(anonKey), mode: "anonymous" });
-            effectiveKey = anonKey;
-            if (currentGeneration !== registrationGeneration) return;
-            discoveryHandler = createDiscoveryHandler(
-              () => Promise.resolve(anonKey),
-              () => sessionManager.getSessionId(getResolvedApiKey()),
-              getClaimState
-            );
-            await backgroundInit(config, anonKey, currentGeneration);
-          } catch (err) {
-            console.warn(
-              `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        })();
-      } else {
-        void (async () => {
-          try {
-            if (currentGeneration !== registrationGeneration) return;
-            const anonKey = await getOrCreateAnonKey();
-            setResolvedApiKey(anonKey);
-            notifyApiKeyResolved();
-            emitLifecycleEvent("auth:key_resolved", { key: maskKey(anonKey), mode: "anonymous" });
-            effectiveKey = anonKey;
-            if (currentGeneration !== registrationGeneration) return;
-            await backgroundInit(config, anonKey, currentGeneration);
-          } catch (err) {
-            console.warn(
-              `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        })();
-      }
-    } else {
-      void (async () => {
-        try {
-          if (currentGeneration !== registrationGeneration) return;
-          let anonKeyForInit = null;
-          try {
-            anonKeyForInit = await readAnonKey();
-          } catch {
-          }
-          if (currentGeneration !== registrationGeneration) return;
-          await backgroundInit(config, anonKeyForInit, currentGeneration);
-        } catch (err) {
-          console.warn(
-            `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      })();
-    }
-    if (config.coverageMapEnabled && config.verbose) {
-      console.info("[glasstrace] Import graph building skipped.");
-    }
-  } catch (err) {
-    setCoreState(CoreState.REGISTRATION_FAILED);
-    console.warn(
-      `[glasstrace] Registration failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-async function backgroundInit(config, anonKeyForInit, generation) {
-  if (config.verbose) {
-    console.info("[glasstrace] Background init firing.");
-  }
-  const healthReport = collectHealthReport("0.19.0");
-  const initResult = await performInit(config, anonKeyForInit, "0.19.0", healthReport);
-  if (generation !== registrationGeneration) return;
-  const currentState = getCoreState();
-  if (currentState === CoreState.SHUTTING_DOWN || currentState === CoreState.SHUTDOWN) {
-    return;
-  }
-  if (currentState === CoreState.KEY_PENDING) {
-    setCoreState(CoreState.KEY_RESOLVED);
-  }
-  if (getCoreState() === CoreState.KEY_RESOLVED) {
-    setCoreState(didLastInitSucceed() ? CoreState.ACTIVE : CoreState.ACTIVE_DEGRADED);
-  }
-  if (initResult?.claimResult) {
-    const { newApiKey, accountId } = initResult.claimResult;
-    setAuthState(AuthState.CLAIMING);
-    emitLifecycleEvent("auth:claim_started", { accountId });
-    setResolvedApiKey(newApiKey);
-    notifyApiKeyResolved();
-    setAuthState(AuthState.CLAIMED);
-    emitLifecycleEvent("auth:claim_completed", { newKey: maskKey(newApiKey), accountId });
-  }
-  maybeInstallConsoleCapture();
-  if (didLastInitSucceed()) {
-    startHeartbeat(config, anonKeyForInit, "0.19.0", generation, (newApiKey, accountId) => {
-      setAuthState(AuthState.CLAIMING);
-      emitLifecycleEvent("auth:claim_started", { accountId });
-      setResolvedApiKey(newApiKey);
-      notifyApiKeyResolved();
-      setAuthState(AuthState.CLAIMED);
-      emitLifecycleEvent("auth:claim_completed", { newKey: maskKey(newApiKey), accountId });
-    });
-  }
-}
-function getDiscoveryHandler() {
-  return discoveryHandler;
-}
-function maybeInstallConsoleCapture() {
-  if (consoleCaptureInstalled) return;
-  if (getActiveConfig().consoleErrors) {
-    consoleCaptureInstalled = true;
-    void installConsoleCapture();
-  }
-}
-function isDiscoveryEnabled(config) {
-  if (process.env.GLASSTRACE_DISCOVERY_ENABLED === "true") return true;
-  if (process.env.GLASSTRACE_DISCOVERY_ENABLED === "false") return false;
-  if (config.nodeEnv === "production") return false;
-  if (config.vercelEnv === "production") return false;
-  if (config.nodeEnv === "development" || config.nodeEnv === void 0) return true;
-  return false;
-}
-
-// src/config-wrapper.ts
-import { isBuiltin as isNodeBuiltin } from "node:module";
-function isTurbopackBuild() {
-  if (typeof process === "undefined") return false;
-  const argv = Array.isArray(process.argv) ? process.argv : [];
-  if (argv.includes("--webpack")) return false;
-  if (argv.includes("--turbopack")) return true;
-  if (process.env?.TURBOPACK === "1") return true;
-  return false;
-}
-var SDK_PACKAGE_NAME = "@glasstrace/sdk";
-function appendNodeSchemeExternal(webpackConfig) {
-  const nodeBuiltinExternal = (data, callback) => {
-    const request = data.request;
-    if (typeof request === "string" && isNodeBuiltin(request)) {
-      callback(null, "commonjs " + request);
-      return;
-    }
-    callback(null);
-  };
-  const existing = webpackConfig.externals;
-  if (Array.isArray(existing)) {
-    webpackConfig.externals = [...existing, nodeBuiltinExternal];
-  } else if (existing == null) {
-    webpackConfig.externals = [nodeBuiltinExternal];
-  } else {
-    webpackConfig.externals = [existing, nodeBuiltinExternal];
-  }
-}
-function ensureServerExternal(config) {
-  const existingStable = config.serverExternalPackages;
-  const stable = Array.isArray(existingStable) ? (
-    // Clone so we never mutate a caller-owned array in place.
-    existingStable.filter((entry) => typeof entry === "string")
-  ) : [];
-  if (!stable.includes(SDK_PACKAGE_NAME)) {
-    stable.push(SDK_PACKAGE_NAME);
-  }
-  config.serverExternalPackages = stable;
-}
-function withGlasstraceConfig(nextConfig) {
-  if (typeof process === "undefined" || typeof process.versions?.node !== "string") {
-    return nextConfig != null ? { ...nextConfig } : {};
-  }
-  const config = nextConfig != null ? { ...nextConfig } : {};
-  const bag = config;
-  const existingExperimental = bag.experimental ?? {};
-  bag.experimental = {
-    ...existingExperimental,
-    serverSourceMaps: true
-  };
-  ensureServerExternal(bag);
-  if (bag.turbopack == null) {
-    bag.turbopack = {};
-  }
-  if (isTurbopackBuild()) {
-    warnTurbopackLimitationOnce();
-  }
-  const distDir = typeof bag.distDir === "string" ? bag.distDir : ".next";
-  const existingWebpack = bag.webpack;
-  bag.webpack = (webpackConfig, context2) => {
-    let result = webpackConfig;
-    if (typeof existingWebpack === "function") {
-      result = existingWebpack(webpackConfig, context2);
-    }
-    const webpackContext = context2;
-    if (webpackContext.isServer) {
-      appendNodeSchemeExternal(result);
-    }
-    if (!webpackContext.isServer && webpackContext.dev === false) {
-      const plugins = result.plugins ?? [];
-      plugins.push({
-        apply(compiler) {
-          const typedCompiler = compiler;
-          if (typedCompiler.hooks?.afterEmit?.tapPromise) {
-            typedCompiler.hooks.afterEmit.tapPromise(
-              "GlasstraceSourceMapUpload",
-              async () => {
-                await handleSourceMapUpload(distDir);
-              }
-            );
-          }
-        }
-      });
-      result.plugins = plugins;
-    }
-    return result;
-  };
-  return config;
-}
-var _turbopackWarningEmitted = false;
-function warnTurbopackLimitationOnce() {
-  if (_turbopackWarningEmitted) return;
-  _turbopackWarningEmitted = true;
-  console.warn(
-    "[glasstrace] Turbopack detected. Source-map upload currently runs only under webpack \u2014 run `next build --webpack` to upload source maps, or wait for the Turbopack port in a future SDK release."
-  );
-}
-async function handleSourceMapUpload(distDir) {
-  try {
-    const apiKey = process.env.GLASSTRACE_API_KEY;
-    const endpoint = process.env.GLASSTRACE_ENDPOINT ?? "https://api.glasstrace.dev";
-    if (!apiKey || apiKey.trim() === "") {
-      console.info(
-        "[glasstrace] Source map upload skipped (no API key). Stack traces will show compiled locations."
-      );
-      return;
-    }
-    const { discoverSourceMapFiles: discoverSourceMapFiles2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await import("./source-map-uploader-VPDZWWM2.js");
-    const files = await discoverSourceMapFiles2(distDir);
-    if (files.length === 0) {
-      console.info("[glasstrace] No source map files found. Skipping upload.");
-      return;
-    }
-    const buildHash = await computeBuildHash2(files);
-    await uploadSourceMaps2(apiKey, endpoint, buildHash, files);
-    console.info(
-      `[glasstrace] Uploaded ${String(files.length)} source map(s) for build ${buildHash}.`
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    console.warn(
-      `[glasstrace] Source map upload failed: ${message}. Build continues normally.`
-    );
-  }
-}
-
-// src/capture-error.ts
-function captureError(error) {
-  try {
-    const span = trace.getSpan(context.active());
-    if (!span) return;
-    const attributes = {
-      "error.message": String(error)
-    };
-    if (error instanceof Error) {
-      attributes["error.type"] = error.constructor.name;
-      if (error.stack) {
-        attributes["error.stack"] = error.stack;
-      }
-    }
-    span.addEvent("glasstrace.error", attributes);
-    maybeShowMcpNudge(String(error));
-  } catch {
-  }
-}
-
-// src/correlation-id.ts
-var ATTR2 = GLASSTRACE_ATTRIBUTE_NAMES;
-var HEADER_NAME = "x-gt-cid";
-var MAX_CID_LENGTH = 128;
-function captureCorrelationId(req) {
-  try {
-    if (!req || !req.headers) {
-      return;
-    }
-    const value = readHeader(req.headers);
-    if (!value) {
-      return;
-    }
-    const span = trace.getActiveSpan();
-    if (!span) {
-      return;
-    }
-    span.setAttribute(ATTR2.CORRELATION_ID, value);
-  } catch {
-  }
-}
-function readHeader(headers) {
-  const asFetch = headers;
-  if (typeof asFetch.get === "function") {
-    const raw = asFetch.get(HEADER_NAME);
-    return firstToken(raw);
-  }
-  const dict = headers;
-  const direct = dict[HEADER_NAME];
-  if (direct !== void 0) {
-    return firstValue(direct);
-  }
-  for (const key of Object.keys(dict)) {
-    if (key.toLowerCase() === HEADER_NAME) {
-      return firstValue(dict[key]);
-    }
-  }
-  return void 0;
-}
-function firstValue(value) {
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      const token = firstToken(entry);
-      if (token) return token;
-    }
-    return void 0;
-  }
-  return firstToken(value);
-}
-function firstToken(value) {
-  if (typeof value !== "string") return void 0;
-  const parts = value.split(",");
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (trimmed.length === 0) continue;
-    if (trimmed.length > MAX_CID_LENGTH) return void 0;
-    return trimmed;
-  }
-  return void 0;
-}
+} from "./chunk-TQ54WLCZ.js";
+import "./chunk-NSBPE2FW.js";
 export {
   GlasstraceExporter,
   GlasstraceSpanProcessor,