@glasstrace/sdk 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1191 @@
+import {
+  buildImportGraph,
+  discoverTestFiles,
+  extractImports
+} from "./chunk-BKMITIEZ.js";
+
+// src/errors.ts
+var SdkError = class extends Error {
+  code;
+  constructor(code, message, cause) {
+    super(message, { cause });
+    this.name = "SdkError";
+    this.code = code;
+  }
+};
+
+// src/env-detection.ts
+var DEFAULT_ENDPOINT = "https://api.glasstrace.dev";
+function readEnvVars() {
+  return {
+    GLASSTRACE_API_KEY: process.env.GLASSTRACE_API_KEY,
+    GLASSTRACE_FORCE_ENABLE: process.env.GLASSTRACE_FORCE_ENABLE,
+    GLASSTRACE_ENV: process.env.GLASSTRACE_ENV,
+    GLASSTRACE_COVERAGE_MAP: process.env.GLASSTRACE_COVERAGE_MAP,
+    NODE_ENV: process.env.NODE_ENV,
+    VERCEL_ENV: process.env.VERCEL_ENV
+  };
+}
+function resolveConfig(options) {
+  const env = readEnvVars();
+  return {
+    apiKey: options?.apiKey ?? env.GLASSTRACE_API_KEY,
+    endpoint: options?.endpoint ?? DEFAULT_ENDPOINT,
+    forceEnable: options?.forceEnable ?? env.GLASSTRACE_FORCE_ENABLE === "true",
+    verbose: options?.verbose ?? false,
+    environment: env.GLASSTRACE_ENV,
+    coverageMapEnabled: env.GLASSTRACE_COVERAGE_MAP === "true",
+    nodeEnv: env.NODE_ENV,
+    vercelEnv: env.VERCEL_ENV
+  };
+}
+function isProductionDisabled(config) {
+  if (config.forceEnable) {
+    return false;
+  }
+  if (config.nodeEnv === "production") {
+    return true;
+  }
+  if (config.vercelEnv === "production") {
+    return true;
+  }
+  return false;
+}
+function isAnonymousMode(config) {
+  if (config.apiKey === void 0) {
+    return true;
+  }
+  if (config.apiKey.trim() === "") {
+    return true;
+  }
+  if (config.apiKey.startsWith("gt_anon_")) {
+    return true;
+  }
+  return false;
+}
+
+// src/session.ts
+import { createHash } from "crypto";
+import { SessionIdSchema } from "@glasstrace/protocol";
+var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
+function deriveSessionId(apiKey, origin, date, windowIndex) {
+  const input = JSON.stringify([apiKey, origin, date, windowIndex]);
+  const hash = createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return SessionIdSchema.parse(hash);
+}
+function getOrigin() {
+  if (process.env.GLASSTRACE_ENV) {
+    return process.env.GLASSTRACE_ENV;
+  }
+  const port = process.env.PORT ?? "3000";
+  return `localhost:${port}`;
+}
+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
+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 port = process.env.PORT ?? "3000";
+  const internalOrigin = `localhost:${port}`;
+  const parsedPort = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+  const urlOrigin = `${hostname}:${parsedPort}`;
+  if (urlOrigin === internalOrigin) {
+    return "internal";
+  }
+  return "unknown";
+}
+
+// src/anon-key.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
+import { AnonApiKeySchema, createAnonApiKey } from "@glasstrace/protocol";
+var GLASSTRACE_DIR = ".glasstrace";
+var ANON_KEY_FILE = "anon_key";
+var ephemeralKeyCache = /* @__PURE__ */ new Map();
+async function readAnonKey(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const keyPath = join(root, GLASSTRACE_DIR, ANON_KEY_FILE);
+  try {
+    const content = await readFile(keyPath, "utf-8");
+    const result = AnonApiKeySchema.safeParse(content);
+    if (result.success) {
+      return result.data;
+    }
+  } catch {
+  }
+  const cached = ephemeralKeyCache.get(root);
+  if (cached !== void 0) {
+    return cached;
+  }
+  return null;
+}
+async function getOrCreateAnonKey(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const dirPath = join(root, GLASSTRACE_DIR);
+  const keyPath = join(dirPath, ANON_KEY_FILE);
+  const existingKey = await readAnonKey(root);
+  if (existingKey !== null) {
+    return existingKey;
+  }
+  const cached = ephemeralKeyCache.get(root);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const newKey = createAnonApiKey();
+  try {
+    await mkdir(dirPath, { recursive: true, mode: 448 });
+    await writeFile(keyPath, newKey, "utf-8");
+    await chmod(keyPath, 384);
+  } catch (err) {
+    ephemeralKeyCache.set(root, newKey);
+    console.warn(
+      `[glasstrace] Failed to persist anonymous key to ${keyPath}: ${err instanceof Error ? err.message : String(err)}. Using ephemeral key.`
+    );
+  }
+  return newKey;
+}
+
+// src/init-client.ts
+import { readFileSync } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import {
+  SdkInitResponseSchema,
+  SdkCachedConfigSchema,
+  DEFAULT_CAPTURE_CONFIG
+} from "@glasstrace/protocol";
+var GLASSTRACE_DIR2 = ".glasstrace";
+var CONFIG_FILE = "config";
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var INIT_TIMEOUT_MS = 1e4;
+var currentConfig = null;
+var rateLimitBackoff = false;
+function loadCachedConfig(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const configPath = join2(root, GLASSTRACE_DIR2, CONFIG_FILE);
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const cached = SdkCachedConfigSchema.parse(parsed);
+    const age = Date.now() - cached.cachedAt;
+    if (age > TWENTY_FOUR_HOURS_MS) {
+      console.warn(
+        `[glasstrace] Cached config is ${Math.round(age / 36e5)}h old. Will refresh on next init.`
+      );
+    }
+    const result = SdkInitResponseSchema.safeParse(cached.response);
+    if (result.success) {
+      return result.data;
+    }
+    console.warn("[glasstrace] Cached config failed validation. Using defaults.");
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveCachedConfig(response, projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const dirPath = join2(root, GLASSTRACE_DIR2);
+  const configPath = join2(dirPath, CONFIG_FILE);
+  try {
+    await mkdir2(dirPath, { recursive: true });
+    const cached = {
+      response,
+      cachedAt: Date.now()
+    };
+    await writeFile2(configPath, JSON.stringify(cached), "utf-8");
+  } catch (err) {
+    console.warn(
+      `[glasstrace] Failed to cache config to ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function sendInitRequest(config, anonKey, sdkVersion, importGraph, healthReport, diagnostics, signal) {
+  const effectiveKey = config.apiKey ?? anonKey;
+  if (!effectiveKey) {
+    throw new Error("No API key available for init request");
+  }
+  const payload = {
+    apiKey: effectiveKey,
+    sdkVersion
+  };
+  if (config.apiKey && anonKey) {
+    payload.anonKey = anonKey;
+  }
+  if (config.environment) {
+    payload.environment = config.environment;
+  }
+  if (importGraph) {
+    payload.importGraph = importGraph;
+  }
+  if (healthReport) {
+    payload.healthReport = healthReport;
+  }
+  if (diagnostics) {
+    payload.diagnostics = diagnostics;
+  }
+  const url = `${config.endpoint}/v1/sdk/init`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${effectiveKey}`
+    },
+    body: JSON.stringify(payload),
+    signal
+  });
+  if (!response.ok) {
+    const error = new Error(`Init request failed with status ${response.status}`);
+    error.status = response.status;
+    throw error;
+  }
+  const body = await response.json();
+  return SdkInitResponseSchema.parse(body);
+}
+async function performInit(config, anonKey, sdkVersion) {
+  if (rateLimitBackoff) {
+    rateLimitBackoff = false;
+    return;
+  }
+  try {
+    const effectiveKey = config.apiKey ?? anonKey;
+    if (!effectiveKey) {
+      console.warn("[glasstrace] No API key available for init request.");
+      return;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), INIT_TIMEOUT_MS);
+    try {
+      const result = await sendInitRequest(
+        config,
+        anonKey,
+        sdkVersion,
+        void 0,
+        void 0,
+        void 0,
+        controller.signal
+      );
+      clearTimeout(timeoutId);
+      currentConfig = result;
+      await saveCachedConfig(result);
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof DOMException && err.name === "AbortError") {
+        console.warn("[glasstrace] ingestion_unreachable: Init request timed out.");
+        return;
+      }
+      const status = err.status;
+      if (status === 401) {
+        console.warn(
+          "[glasstrace] ingestion_auth_failed: Check your GLASSTRACE_API_KEY."
+        );
+        return;
+      }
+      if (status === 429) {
+        console.warn("[glasstrace] ingestion_rate_limited: Backing off.");
+        rateLimitBackoff = true;
+        return;
+      }
+      if (typeof status === "number" && status >= 400) {
+        console.warn(
+          `[glasstrace] Init request failed with status ${status}. Using cached config.`
+        );
+        return;
+      }
+      if (err instanceof Error && err.name === "ZodError") {
+        console.warn(
+          "[glasstrace] Init response failed validation (schema version mismatch?). Using cached config."
+        );
+        return;
+      }
+      console.warn(
+        `[glasstrace] ingestion_unreachable: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } catch (err) {
+    console.warn(
+      `[glasstrace] Unexpected init error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function getActiveConfig() {
+  if (currentConfig) {
+    return currentConfig.config;
+  }
+  const cached = loadCachedConfig();
+  if (cached) {
+    return cached.config;
+  }
+  return { ...DEFAULT_CAPTURE_CONFIG };
+}
+function _setCurrentConfig(config) {
+  currentConfig = config;
+}
+
+// src/span-processor.ts
+var GlasstraceSpanProcessor = class {
+  wrappedProcessor;
+  /* eslint-disable @typescript-eslint/no-unused-vars -- backward compat signature */
+  constructor(wrappedProcessor, _sessionManager, _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
+import { SpanKind } from "@opentelemetry/api";
+import { GLASSTRACE_ATTRIBUTE_NAMES } from "@glasstrace/protocol";
+var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
+var API_KEY_PENDING = "pending";
+var MAX_PENDING_SPANS = 1024;
+var GlasstraceExporter = class {
+  getApiKey;
+  sessionManager;
+  getConfig;
+  environment;
+  endpointUrl;
+  createDelegateFn;
+  delegate = 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;
+  }
+  export(spans, resultCallback) {
+    const enrichedSpans = spans.map((span) => this.enrichSpan(span));
+    const currentKey = this.getApiKey();
+    if (currentKey === API_KEY_PENDING) {
+      this.bufferSpans(enrichedSpans, resultCallback);
+      return;
+    }
+    const exporter = this.ensureDelegate();
+    if (exporter) {
+      exporter.export(enrichedSpans, resultCallback);
+    } else {
+      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.`
+      );
+      for (const batch of this.pendingBatches) {
+        batch.resultCallback({ code: 0 });
+      }
+      this.pendingBatches = [];
+      this.pendingSpanCount = 0;
+    }
+    if (this.delegate) {
+      return this.delegate.shutdown();
+    }
+  }
+  forceFlush() {
+    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.
+   * Each attribute derivation is wrapped in its own try-catch for partial
+   * enrichment resilience.
+   */
+  enrichSpan(span) {
+    const attrs = span.attributes ?? {};
+    const name = span.name ?? "";
+    const extra = {};
+    try {
+      extra[ATTR.TRACE_TYPE] = "server";
+    } catch {
+    }
+    try {
+      const sessionId = this.sessionManager.getSessionId(this.getApiKey());
+      extra[ATTR.SESSION_ID] = sessionId;
+    } catch {
+    }
+    try {
+      const env = this.environment ?? process.env.GLASSTRACE_ENV;
+      if (env) {
+        extra[ATTR.ENVIRONMENT] = env;
+      }
+    } catch {
+    }
+    try {
+      const existingCid = attrs["glasstrace.correlation.id"];
+      if (typeof existingCid === "string") {
+        extra[ATTR.CORRELATION_ID] = existingCid;
+      }
+    } catch {
+    }
+    try {
+      const route = attrs["http.route"] ?? name;
+      if (route) {
+        extra[ATTR.ROUTE] = route;
+      }
+    } catch {
+    }
+    try {
+      const method = attrs["http.method"] ?? attrs["http.request.method"];
+      if (method) {
+        extra[ATTR.HTTP_METHOD] = method;
+      }
+    } catch {
+    }
+    try {
+      const statusCode = attrs["http.status_code"] ?? attrs["http.response.status_code"];
+      if (statusCode !== void 0) {
+        extra[ATTR.HTTP_STATUS_CODE] = statusCode;
+      }
+    } catch {
+    }
+    try {
+      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;
+        }
+      }
+    } catch {
+    }
+    try {
+      const errorMessage = attrs["exception.message"];
+      if (errorMessage) {
+        extra[ATTR.ERROR_MESSAGE] = errorMessage;
+      }
+    } catch {
+    }
+    try {
+      const errorType = attrs["exception.type"];
+      if (errorType) {
+        extra[ATTR.ERROR_CODE] = errorType;
+        extra[ATTR.ERROR_CATEGORY] = deriveErrorCategory(errorType);
+      }
+    } catch {
+    }
+    try {
+      const errorField = attrs["error.field"];
+      if (errorField) {
+        extra[ATTR.ERROR_FIELD] = errorField;
+      }
+    } catch {
+    }
+    try {
+      const spanAny = span;
+      const instrumentationName = spanAny.instrumentationScope?.name ?? spanAny.instrumentationLibrary?.name ?? "";
+      const ormProvider = deriveOrmProvider(instrumentationName);
+      if (ormProvider) {
+        extra[ATTR.ORM_PROVIDER] = ormProvider;
+        const model = attrs["db.sql.table"] ?? attrs["db.prisma.model"];
+        if (model) {
+          extra[ATTR.ORM_MODEL] = model;
+        }
+        const operation = attrs["db.operation"];
+        if (operation) {
+          extra[ATTR.ORM_OPERATION] = operation;
+        }
+      }
+    } catch {
+    }
+    try {
+      const url = attrs["http.url"] ?? attrs["url.full"];
+      if (url && span.kind === SpanKind.CLIENT) {
+        extra[ATTR.FETCH_TARGET] = classifyFetchTarget(url);
+      }
+    } catch {
+    }
+    return createEnrichedSpan(span, extra);
+  }
+  /**
+   * Lazily creates the delegate OTLP exporter once the API key is resolved.
+   */
+  ensureDelegate() {
+    if (!this.createDelegateFn) return null;
+    if (this.delegate) return this.delegate;
+    const currentKey = this.getApiKey();
+    if (currentKey === API_KEY_PENDING) return null;
+    this.delegate = this.createDelegateFn(this.endpointUrl, {
+      Authorization: `Bearer ${currentKey}`
+    });
+    return this.delegate;
+  }
+  /**
+   * Buffers enriched spans while the API key is pending.
+   * Evicts oldest batches if the buffer exceeds MAX_PENDING_SPANS.
+   */
+  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;
+      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."
+        );
+      }
+    }
+  }
+  /**
+   * Flushes all buffered spans through the delegate exporter.
+   * Called when the API key resolves.
+   */
+  flushPending() {
+    if (this.pendingBatches.length === 0) return;
+    const exporter = this.ensureDelegate();
+    if (!exporter) {
+      for (const batch of this.pendingBatches) {
+        batch.resultCallback({ code: 0 });
+      }
+      this.pendingBatches = [];
+      this.pendingSpanCount = 0;
+      return;
+    }
+    const batches = this.pendingBatches;
+    this.pendingBatches = [];
+    this.pendingSpanCount = 0;
+    for (const batch of batches) {
+      exporter.export(batch.spans, batch.resultCallback);
+    }
+  }
+};
+function createEnrichedSpan(span, extra) {
+  const enrichedAttributes = { ...span.attributes, ...extra };
+  return Object.create(span, {
+    attributes: {
+      value: enrichedAttributes,
+      enumerable: true
+    }
+  });
+}
+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) {
+  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();
+      return new Response(
+        JSON.stringify({ key: anonKey, sessionId }),
+        {
+          status: 200,
+          headers: corsHeaders
+        }
+      );
+    } catch {
+      return new Response(
+        JSON.stringify({ error: "internal_error" }),
+        {
+          status: 500,
+          headers: corsHeaders
+        }
+      );
+    }
+  };
+}
+
+// src/otel-config.ts
+var _resolvedApiKey = API_KEY_PENDING;
+var _activeExporter = null;
+function setResolvedApiKey(key) {
+  _resolvedApiKey = key;
+}
+function getResolvedApiKey() {
+  return _resolvedApiKey;
+}
+function notifyApiKeyResolved() {
+  _activeExporter?.notifyKeyResolved();
+}
+async function tryImport(moduleId) {
+  try {
+    return await Function("id", "return import(id)")(moduleId);
+  } catch {
+    return null;
+  }
+}
+async function configureOtel(config, sessionManager) {
+  const exporterUrl = `${config.endpoint}/v1/traces`;
+  let createOtlpExporter = null;
+  const otlpModule = await tryImport("@opentelemetry/exporter-trace-otlp-http");
+  if (otlpModule && typeof otlpModule.OTLPTraceExporter === "function") {
+    const OTLPTraceExporter = otlpModule.OTLPTraceExporter;
+    createOtlpExporter = (url, headers) => new OTLPTraceExporter({ url, headers });
+  }
+  const glasstraceExporter = new GlasstraceExporter({
+    getApiKey: getResolvedApiKey,
+    sessionManager,
+    getConfig: () => getActiveConfig(),
+    environment: config.environment,
+    endpointUrl: exporterUrl,
+    createDelegate: createOtlpExporter
+  });
+  _activeExporter = glasstraceExporter;
+  const vercelOtel = await tryImport("@vercel/otel");
+  if (vercelOtel && typeof vercelOtel.registerOTel === "function") {
+    if (!createOtlpExporter) {
+      console.warn(
+        "[glasstrace] @opentelemetry/exporter-trace-otlp-http not found for @vercel/otel path. Trace export disabled."
+      );
+    }
+    const otelConfig = {
+      serviceName: "glasstrace-sdk",
+      traceExporter: glasstraceExporter
+    };
+    const prismaModule = await tryImport("@prisma/instrumentation");
+    if (prismaModule) {
+      const PrismaInstrumentation = prismaModule.PrismaInstrumentation;
+      if (PrismaInstrumentation) {
+        otelConfig.instrumentations = [new PrismaInstrumentation()];
+      }
+    }
+    vercelOtel.registerOTel(otelConfig);
+    return;
+  }
+  try {
+    const otelSdk = await import("@opentelemetry/sdk-trace-base");
+    const otelApi = await import("@opentelemetry/api");
+    if (!createOtlpExporter) {
+      const consoleExporter = new otelSdk.ConsoleSpanExporter();
+      const consoleGlasstraceExporter = new GlasstraceExporter({
+        getApiKey: getResolvedApiKey,
+        sessionManager,
+        getConfig: () => getActiveConfig(),
+        environment: config.environment,
+        endpointUrl: exporterUrl,
+        createDelegate: () => consoleExporter
+      });
+      _activeExporter = consoleGlasstraceExporter;
+      console.warn(
+        "[glasstrace] @opentelemetry/exporter-trace-otlp-http not found. Using ConsoleSpanExporter."
+      );
+      const processor2 = new otelSdk.SimpleSpanProcessor(consoleGlasstraceExporter);
+      const provider2 = new otelSdk.BasicTracerProvider({
+        spanProcessors: [processor2]
+      });
+      otelApi.trace.setGlobalTracerProvider(provider2);
+      return;
+    }
+    const processor = new otelSdk.SimpleSpanProcessor(glasstraceExporter);
+    const provider = new otelSdk.BasicTracerProvider({
+      spanProcessors: [processor]
+    });
+    const existingProvider = otelApi.trace.getTracerProvider();
+    if (existingProvider && existingProvider.constructor.name !== "ProxyTracerProvider") {
+      console.warn(
+        "[glasstrace] An existing OpenTelemetry TracerProvider was detected and will be replaced. If you use another tracing tool, configure Glasstrace as an additional exporter instead."
+      );
+    }
+    otelApi.trace.setGlobalTracerProvider(provider);
+  } catch {
+    console.warn(
+      "[glasstrace] Neither @vercel/otel nor @opentelemetry/sdk-trace-base available. Tracing disabled."
+    );
+  }
+}
+
+// src/register.ts
+var discoveryHandler = null;
+var isRegistered = false;
+var registrationGeneration = 0;
+function registerGlasstrace(options) {
+  try {
+    if (isRegistered) {
+      return;
+    }
+    const config = resolveConfig(options);
+    if (config.verbose) {
+      console.info("[glasstrace] Step 1: Config resolved.");
+    }
+    if (isProductionDisabled(config)) {
+      console.warn(
+        "[glasstrace] Disabled in production. Set GLASSTRACE_FORCE_ENABLE=true to override."
+      );
+      return;
+    }
+    if (config.verbose) {
+      console.info("[glasstrace] Step 2: Not production-disabled.");
+    }
+    const anonymous = isAnonymousMode(config);
+    let effectiveKey = config.apiKey;
+    if (effectiveKey) {
+      setResolvedApiKey(effectiveKey);
+    }
+    if (config.verbose) {
+      console.info(
+        `[glasstrace] Step 3: Auth mode = ${anonymous ? "anonymous" : "dev-key"}.`
+      );
+    }
+    const cachedInitResponse = loadCachedConfig();
+    if (cachedInitResponse) {
+      _setCurrentConfig(cachedInitResponse);
+    }
+    if (config.verbose) {
+      console.info(
+        `[glasstrace] Step 4: Cached config ${cachedInitResponse ? "loaded and applied" : "not found"}.`
+      );
+    }
+    const sessionManager = new SessionManager();
+    if (config.verbose) {
+      console.info("[glasstrace] Step 5: SessionManager created.");
+    }
+    isRegistered = true;
+    const currentGeneration = registrationGeneration;
+    void configureOtel(config, sessionManager).then(
+      () => {
+        if (config.verbose) {
+          console.info("[glasstrace] Step 6: 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();
+        discoveryHandler = createDiscoveryHandler(
+          async () => resolvedAnonKey,
+          () => sessionManager.getSessionId(getResolvedApiKey())
+        );
+        if (config.verbose) {
+          console.info("[glasstrace] Step 8: Discovery endpoint registered (key pending).");
+        }
+        void (async () => {
+          try {
+            if (currentGeneration !== registrationGeneration) return;
+            const anonKey = await anonKeyPromise;
+            resolvedAnonKey = anonKey;
+            setResolvedApiKey(anonKey);
+            notifyApiKeyResolved();
+            effectiveKey = anonKey;
+            if (currentGeneration !== registrationGeneration) return;
+            discoveryHandler = createDiscoveryHandler(
+              () => Promise.resolve(anonKey),
+              () => sessionManager.getSessionId(getResolvedApiKey())
+            );
+            if (config.verbose) {
+              console.info("[glasstrace] Step 7: Background init firing.");
+            }
+            await performInit(config, anonKey, "0.1.0");
+          } 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();
+            effectiveKey = anonKey;
+            if (currentGeneration !== registrationGeneration) return;
+            if (config.verbose) {
+              console.info("[glasstrace] Step 7: Background init firing.");
+            }
+            await performInit(config, anonKey, "0.1.0");
+          } 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;
+          if (config.verbose) {
+            console.info("[glasstrace] Step 7: Background init firing.");
+          }
+          await performInit(config, anonKeyForInit, "0.1.0");
+        } catch (err) {
+          console.warn(
+            `[glasstrace] Background init failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      })();
+    }
+    if (config.coverageMapEnabled && config.verbose) {
+      console.info("[glasstrace] Step 9: Import graph building skipped.");
+    }
+  } catch (err) {
+    console.warn(
+      `[glasstrace] Registration failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function getDiscoveryHandler() {
+  return discoveryHandler;
+}
+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/source-map-uploader.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
+import { execSync } from "child_process";
+import {
+  SourceMapUploadResponseSchema
+} from "@glasstrace/protocol";
+async function collectSourceMaps(buildDir) {
+  const results = [];
+  try {
+    await walkDir(buildDir, buildDir, results);
+  } catch {
+    return [];
+  }
+  return results;
+}
+async function walkDir(baseDir, currentDir, results) {
+  let entries;
+  try {
+    entries = await fs.readdir(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(baseDir, fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith(".map")) {
+      try {
+        const content = await fs.readFile(fullPath, "utf-8");
+        const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const compiledPath = relativePath.replace(/\.map$/, "");
+        results.push({ filePath: compiledPath, content });
+      } catch {
+      }
+    }
+  }
+}
+async function computeBuildHash(maps) {
+  try {
+    const sha = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+    if (sha) {
+      return sha;
+    }
+  } catch {
+  }
+  const sortedMaps = [...maps ?? []].sort(
+    (a, b) => a.filePath.localeCompare(b.filePath)
+  );
+  const hashInput = sortedMaps.map((m) => `${m.filePath}
+${m.content.length}
+${m.content}`).join("");
+  const hash = crypto.createHash("sha256").update(hashInput).digest("hex");
+  return hash;
+}
+async function uploadSourceMaps(apiKey, endpoint, buildHash, maps) {
+  const body = {
+    apiKey,
+    buildHash,
+    files: maps.map((m) => ({
+      filePath: m.filePath,
+      sourceMap: m.content
+    }))
+  };
+  const baseUrl = endpoint.replace(/\/+$/, "");
+  const response = await fetch(`${baseUrl}/v1/source-maps`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Source map upload failed: ${String(response.status)} ${response.statusText}`
+    );
+  }
+  const json = await response.json();
+  return SourceMapUploadResponseSchema.parse(json);
+}
+
+// src/config-wrapper.ts
+function withGlasstraceConfig(nextConfig) {
+  const config = nextConfig != null ? { ...nextConfig } : {};
+  const existingExperimental = config.experimental ?? {};
+  config.experimental = { ...existingExperimental, serverSourceMaps: true };
+  const distDir = typeof config.distDir === "string" ? config.distDir : ".next";
+  const existingWebpack = config.webpack;
+  config.webpack = (webpackConfig, context) => {
+    let result = webpackConfig;
+    if (typeof existingWebpack === "function") {
+      result = existingWebpack(webpackConfig, context);
+    }
+    const webpackContext = context;
+    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;
+}
+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 maps = await collectSourceMaps(distDir);
+    if (maps.length === 0) {
+      console.info("[glasstrace] No source map files found. Skipping upload.");
+      return;
+    }
+    const buildHash = await computeBuildHash(maps);
+    await uploadSourceMaps(apiKey, endpoint, buildHash, maps);
+    console.info(
+      `[glasstrace] Uploaded ${String(maps.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.`
+    );
+  }
+}
+export {
+  GlasstraceExporter,
+  GlasstraceSpanProcessor,
+  SdkError,
+  SessionManager,
+  buildImportGraph,
+  classifyFetchTarget,
+  collectSourceMaps,
+  computeBuildHash,
+  createDiscoveryHandler,
+  deriveSessionId,
+  discoverTestFiles,
+  extractImports,
+  getActiveConfig,
+  getDateString,
+  getDiscoveryHandler,
+  getOrCreateAnonKey,
+  getOrigin,
+  isAnonymousMode,
+  isProductionDisabled,
+  loadCachedConfig,
+  performInit,
+  readAnonKey,
+  readEnvVars,
+  registerGlasstrace,
+  resolveConfig,
+  saveCachedConfig,
+  sendInitRequest,
+  uploadSourceMaps,
+  withGlasstraceConfig
+};
+//# sourceMappingURL=index.js.map