@glasstrace/sdk 0.14.2 → 0.16.0

package/dist/chunk-5C2TJFLB.js

@@ -0,0 +1,851 @@
+import {
+  DEFAULT_CAPTURE_CONFIG,
+  SdkCachedConfigSchema,
+  SdkInitResponseSchema,
+  createBuildHash
+} from "./chunk-7JBKXSBU.js";
+import {
+  __require
+} from "./chunk-NSBPE2FW.js";
+
+// src/health-collector.ts
+var tracesExported = 0;
+var tracesDropped = 0;
+var initFailures = 0;
+var lastConfigSyncAt = null;
+function recordSpansExported(count) {
+  if (!Number.isFinite(count) || count < 0 || !Number.isInteger(count)) return;
+  tracesExported += count;
+}
+function recordSpansDropped(count) {
+  if (!Number.isFinite(count) || count < 0 || !Number.isInteger(count)) return;
+  tracesDropped += count;
+}
+function recordInitFailure() {
+  try {
+    initFailures += 1;
+  } catch {
+  }
+}
+function recordConfigSync(timestamp) {
+  try {
+    lastConfigSyncAt = timestamp;
+  } catch {
+  }
+}
+function collectHealthReport(sdkVersion) {
+  try {
+    const now = Date.now();
+    const configAge = lastConfigSyncAt !== null ? Math.max(0, now - lastConfigSyncAt) : 0;
+    return {
+      tracesExportedSinceLastInit: tracesExported,
+      tracesDropped,
+      initFailures,
+      configAge: Math.round(configAge),
+      sdkVersion
+    };
+  } catch {
+    return null;
+  }
+}
+function acknowledgeHealthReport(report) {
+  const exp = Math.max(0, report.tracesExportedSinceLastInit);
+  const expVal = tracesExported - exp;
+  tracesExported = Number.isFinite(expVal) ? Math.max(0, expVal) : tracesExported;
+  const drop = Math.max(0, report.tracesDropped);
+  const dropVal = tracesDropped - drop;
+  tracesDropped = Number.isFinite(dropVal) ? Math.max(0, dropVal) : tracesDropped;
+  const fail = Math.max(0, report.initFailures);
+  const failVal = initFailures - fail;
+  initFailures = Number.isFinite(failVal) ? Math.max(0, failVal) : initFailures;
+}
+
+// src/https-transport.ts
+import {
+  request as httpsRequest
+} from "node:https";
+import {
+  request as httpRequest
+} from "node:http";
+import { URL } from "node:url";
+var HttpsTransportError = class extends Error {
+  kind = "transport";
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "HttpsTransportError";
+    this.cause = cause;
+  }
+};
+var HttpsStatusError = class extends Error {
+  kind = "status";
+  status;
+  /** Raw response body text (may be truncated by caller if large). */
+  body;
+  constructor(status, body) {
+    super(`Server returned HTTP ${status}`);
+    this.name = "HttpsStatusError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var HttpsBodyParseError = class extends Error {
+  kind = "parse";
+  status;
+  cause;
+  constructor(status, cause) {
+    super(`Server returned malformed response (HTTP ${status})`);
+    this.name = "HttpsBodyParseError";
+    this.status = status;
+    this.cause = cause;
+  }
+};
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_RETRY_DELAYS_MS = [500, 1500];
+var DEFAULT_TOTAL_DEADLINE_MS = 2e4;
+async function httpsPostJson(url, jsonBody, options) {
+  const parsed = new URL(url);
+  const isHttps = parsed.protocol === "https:";
+  const isHttp = parsed.protocol === "http:";
+  if (!isHttps && !isHttp) {
+    throw new HttpsTransportError(
+      `Unsupported protocol: ${parsed.protocol} (expected http: or https:)`
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxAttempts = options.maxAttempts ?? 3;
+  const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const totalDeadlineMs = options.totalDeadlineMs ?? DEFAULT_TOTAL_DEADLINE_MS;
+  const scheduler = options.scheduler ?? ((fn, ms) => setTimeout(fn, ms));
+  const requestImpl = isHttps ? options.requestImpl ?? httpsRequest : options.httpRequestImpl ?? httpRequest;
+  let payload;
+  try {
+    payload = JSON.stringify(jsonBody);
+  } catch (err) {
+    throw new HttpsTransportError(
+      `Failed to serialize request body: ${err instanceof Error ? err.message : String(err)}`,
+      err
+    );
+  }
+  const payloadBuffer = Buffer.from(payload, "utf-8");
+  const startedAt = Date.now();
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    if (options.signal?.aborted) {
+      throw new HttpsTransportError("Request aborted");
+    }
+    const elapsed = Date.now() - startedAt;
+    if (elapsed >= totalDeadlineMs) {
+      break;
+    }
+    const remainingBudget = totalDeadlineMs - elapsed;
+    const attemptTimeoutMs = Math.min(timeoutMs, remainingBudget);
+    try {
+      return await sendSingleRequest(
+        parsed,
+        payloadBuffer,
+        options.headers,
+        attemptTimeoutMs,
+        options.signal,
+        requestImpl
+      );
+    } catch (err) {
+      lastError = err;
+      if (err instanceof HttpsStatusError || err instanceof HttpsBodyParseError) {
+        throw err;
+      }
+      const isLast = attempt === maxAttempts - 1;
+      if (isLast) break;
+      const delayMs = retryDelaysMs[attempt] ?? retryDelaysMs[retryDelaysMs.length - 1] ?? 0;
+      const elapsedBeforeSleep = Date.now() - startedAt;
+      const remaining = totalDeadlineMs - elapsedBeforeSleep;
+      if (remaining <= 0) break;
+      const actualDelayMs = Math.min(delayMs, remaining);
+      await sleep(actualDelayMs, scheduler, options.signal);
+    }
+  }
+  if (lastError instanceof HttpsTransportError) throw lastError;
+  throw new HttpsTransportError(
+    lastError instanceof Error ? lastError.message : "Request failed",
+    lastError
+  );
+}
+function sendSingleRequest(url, payload, headers, timeoutMs, signal, requestImpl) {
+  return new Promise((resolve, reject) => {
+    const finalHeaders = {
+      ...headers,
+      "Content-Length": payload.byteLength
+    };
+    const reqOptions = {
+      method: "POST",
+      hostname: url.hostname,
+      port: url.port === "" ? void 0 : Number(url.port),
+      path: `${url.pathname}${url.search}`,
+      headers: finalHeaders,
+      // Explicit timeout at the socket level. Still complemented by a
+      // manual timer below because `timeout` only fires when the socket
+      // is idle — it does not cover "TLS handshake hangs forever".
+      timeout: timeoutMs
+    };
+    let settled = false;
+    let cleanup = () => {
+    };
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+    const req = requestImpl(reqOptions, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf-8") : chunk);
+      });
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        const status = res.statusCode ?? 0;
+        if (status < 200 || status >= 300) {
+          settle(() => reject(new HttpsStatusError(status, raw)));
+          return;
+        }
+        if (status === 204 || raw.length === 0) {
+          settle(() => resolve({ status, body: void 0, raw }));
+          return;
+        }
+        try {
+          const parsed = JSON.parse(raw);
+          settle(() => resolve({ status, body: parsed, raw }));
+        } catch (err) {
+          settle(() => reject(new HttpsBodyParseError(status, err)));
+        }
+      });
+      res.on("error", (err) => {
+        settle(() => reject(new HttpsTransportError(`Response stream error: ${err.message}`, err)));
+      });
+    });
+    const timer = setTimeout(() => {
+      settle(() => {
+        req.destroy(new Error("Request timed out"));
+        reject(new HttpsTransportError(`Request timed out after ${timeoutMs}ms`));
+      });
+    }, timeoutMs);
+    if (typeof timer.unref === "function") timer.unref();
+    const onAbort = () => {
+      settle(() => {
+        req.destroy(new Error("Aborted"));
+        reject(new HttpsTransportError("Request aborted"));
+      });
+    };
+    cleanup = () => {
+      clearTimeout(timer);
+      if (signal !== void 0) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    };
+    req.on("error", (err) => {
+      settle(() => reject(new HttpsTransportError(`fetch failed: ${err.message}`, err)));
+    });
+    req.on("timeout", () => {
+      settle(() => {
+        req.destroy(new Error("Request timed out"));
+        reject(new HttpsTransportError(`Request timed out after ${timeoutMs}ms`));
+      });
+    });
+    if (signal !== void 0) {
+      if (signal.aborted) {
+        req.destroy(new Error("Aborted"));
+        settle(() => reject(new HttpsTransportError("Request aborted")));
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    req.end(payload);
+  });
+}
+function sleep(ms, scheduler, signal) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let cleanup = () => {
+    };
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+    const onAbort = () => {
+      settle(() => reject(new HttpsTransportError("Request aborted")));
+    };
+    const timer = scheduler(() => {
+      settle(resolve);
+    }, ms);
+    if (typeof timer.unref === "function") timer.unref();
+    cleanup = () => {
+      clearTimeout(timer);
+      if (signal !== void 0) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    };
+    if (signal !== void 0) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+// src/init-client.ts
+var GLASSTRACE_DIR = ".glasstrace";
+var CONFIG_FILE = "config";
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var INIT_TIMEOUT_MS = 1e4;
+var fsPathAsyncCache;
+async function loadFsPathAsync() {
+  if (fsPathAsyncCache !== void 0) return fsPathAsyncCache;
+  try {
+    const [fs2, path2] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:path")
+    ]);
+    fsPathAsyncCache = { fs: fs2, path: path2 };
+    return fsPathAsyncCache;
+  } catch {
+    fsPathAsyncCache = null;
+    return null;
+  }
+}
+function loadFsSyncOrNull() {
+  try {
+    const fs2 = __require("node:fs");
+    const path2 = __require("node:path");
+    return { readFileSync: fs2.readFileSync, join: path2.join };
+  } catch {
+    return null;
+  }
+}
+var transportOverride = null;
+var currentConfig = null;
+var configCacheChecked = false;
+var rateLimitBackoff = false;
+var lastInitSucceeded = false;
+function loadCachedConfig(projectRoot) {
+  const modules = loadFsSyncOrNull();
+  if (!modules) return null;
+  const root = projectRoot ?? process.cwd();
+  const configPath = modules.join(root, GLASSTRACE_DIR, CONFIG_FILE);
+  try {
+    const content = modules.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) {
+      recordConfigSync(cached.cachedAt);
+      return result.data;
+    }
+    console.warn("[glasstrace] Cached config failed validation. Using defaults.");
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveCachedConfig(response, projectRoot) {
+  const modules = await loadFsPathAsync();
+  if (!modules) return;
+  const root = projectRoot ?? process.cwd();
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+  const configPath = modules.path.join(dirPath, CONFIG_FILE);
+  const tmpPath = `${configPath}.tmp`;
+  try {
+    await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+    await modules.fs.chmod(dirPath, 448);
+    const cached = {
+      response,
+      cachedAt: Date.now()
+    };
+    await modules.fs.writeFile(tmpPath, JSON.stringify(cached), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    try {
+      await modules.fs.chmod(tmpPath, 384);
+      await modules.fs.rename(tmpPath, configPath);
+    } catch (renameErr) {
+      try {
+        await modules.fs.unlink(tmpPath);
+      } catch {
+      }
+      throw renameErr;
+    }
+    await modules.fs.chmod(configPath, 384);
+  } 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 = {
+    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 transport = transportOverride ?? httpsPostJson;
+  let result;
+  try {
+    result = await transport(url, payload, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${effectiveKey}`
+      },
+      timeoutMs: INIT_TIMEOUT_MS,
+      signal
+    });
+  } catch (err) {
+    if (err instanceof HttpsStatusError) {
+      const error = new Error(`Init request failed with status ${err.status}`);
+      error.status = err.status;
+      throw error;
+    }
+    if (err instanceof HttpsBodyParseError) {
+      const cause = err.cause;
+      if (cause instanceof SyntaxError) throw cause;
+      throw err;
+    }
+    if (err instanceof HttpsTransportError) {
+      throw err;
+    }
+    throw err;
+  }
+  return SdkInitResponseSchema.parse(result.body);
+}
+async function writeClaimedKey(newApiKey, projectRoot) {
+  const modules = await loadFsPathAsync();
+  if (modules) {
+    const root = projectRoot ?? process.cwd();
+    const envLocalPath = modules.path.join(root, ".env.local");
+    let envLocalWritten = false;
+    try {
+      let content;
+      try {
+        content = await modules.fs.readFile(envLocalPath, "utf-8");
+        if (/^GLASSTRACE_API_KEY=.*/m.test(content)) {
+          content = content.replace(
+            /^GLASSTRACE_API_KEY=.*$/gm,
+            `GLASSTRACE_API_KEY=${newApiKey}`
+          );
+        } else {
+          if (content.length > 0 && !content.endsWith("\n")) {
+            content += "\n";
+          }
+          content += `GLASSTRACE_API_KEY=${newApiKey}
+`;
+        }
+      } catch (readErr) {
+        const code = readErr instanceof Error ? readErr.code : void 0;
+        if (code !== "ENOENT") {
+          throw readErr;
+        }
+        content = `GLASSTRACE_API_KEY=${newApiKey}
+`;
+      }
+      await modules.fs.writeFile(envLocalPath, content, { encoding: "utf-8", mode: 384 });
+      await modules.fs.chmod(envLocalPath, 384);
+      envLocalWritten = true;
+    } catch {
+    }
+    if (envLocalWritten) {
+      try {
+        process.stderr.write(
+          "[glasstrace] Account claimed! API key written to .env.local. Restart your dev server to use it.\n"
+        );
+      } catch {
+      }
+      return;
+    }
+    let claimedKeyWritten = false;
+    try {
+      const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+      await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+      await modules.fs.chmod(dirPath, 448);
+      const claimedKeyPath = modules.path.join(dirPath, "claimed-key");
+      await modules.fs.writeFile(claimedKeyPath, newApiKey, {
+        encoding: "utf-8",
+        mode: 384
+      });
+      await modules.fs.chmod(claimedKeyPath, 384);
+      claimedKeyWritten = true;
+    } catch {
+    }
+    if (claimedKeyWritten) {
+      try {
+        process.stderr.write(
+          "[glasstrace] Account claimed! API key written to .glasstrace/claimed-key. Copy it to your .env.local file.\n"
+        );
+      } catch {
+      }
+      return;
+    }
+  }
+  try {
+    process.stderr.write(
+      "[glasstrace] Account claimed but could not write key to disk. Visit your dashboard settings to rotate and retrieve a new API key.\n"
+    );
+  } catch {
+  }
+}
+async function performInit(config, anonKey, sdkVersion, healthReport) {
+  lastInitSucceeded = false;
+  if (rateLimitBackoff) {
+    rateLimitBackoff = false;
+    return null;
+  }
+  try {
+    const effectiveKey = config.apiKey || anonKey;
+    if (!effectiveKey) {
+      console.warn("[glasstrace] No API key available for init request.");
+      return null;
+    }
+    try {
+      const result = await sendInitRequest(
+        config,
+        anonKey,
+        sdkVersion,
+        void 0,
+        healthReport ?? void 0,
+        void 0
+      );
+      currentConfig = result;
+      recordConfigSync(Date.now());
+      if (healthReport) {
+        acknowledgeHealthReport(healthReport);
+      }
+      lastInitSucceeded = true;
+      await saveCachedConfig(result);
+      if (result.claimResult) {
+        try {
+          await writeClaimedKey(result.claimResult.newApiKey);
+        } catch {
+        }
+        return { claimResult: result.claimResult };
+      }
+      return null;
+    } catch (err) {
+      recordInitFailure();
+      if (err instanceof HttpsTransportError) {
+        if (/timed out|aborted/i.test(err.message)) {
+          console.warn("[glasstrace] ingestion_unreachable: Init request timed out.");
+        } else {
+          console.warn(`[glasstrace] ingestion_unreachable: ${err.message}`);
+        }
+        return null;
+      }
+      const status = err.status;
+      if (status === 401) {
+        console.warn(
+          "[glasstrace] ingestion_auth_failed: Check your GLASSTRACE_API_KEY."
+        );
+        return null;
+      }
+      if (status === 429) {
+        console.warn("[glasstrace] ingestion_rate_limited: Backing off.");
+        rateLimitBackoff = true;
+        return null;
+      }
+      if (typeof status === "number" && status >= 400) {
+        console.warn(
+          `[glasstrace] Init request failed with status ${status}. Using cached config.`
+        );
+        return null;
+      }
+      if (err instanceof Error && err.name === "ZodError") {
+        console.warn(
+          "[glasstrace] Init response failed validation (schema version mismatch?). Using cached config."
+        );
+        return null;
+      }
+      console.warn(
+        `[glasstrace] ingestion_unreachable: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return null;
+    }
+  } catch (err) {
+    console.warn(
+      `[glasstrace] Unexpected init error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return null;
+}
+function getActiveConfig() {
+  if (currentConfig) {
+    return currentConfig.config;
+  }
+  if (!configCacheChecked) {
+    configCacheChecked = true;
+    const cached = loadCachedConfig();
+    if (cached) {
+      currentConfig = cached;
+      return cached.config;
+    }
+  }
+  return { ...DEFAULT_CAPTURE_CONFIG };
+}
+function getLinkedAccountId() {
+  return currentConfig?.linkedAccountId;
+}
+function getClaimResult() {
+  return currentConfig?.claimResult;
+}
+function _setCurrentConfig(config) {
+  currentConfig = config;
+}
+function consumeRateLimitFlag() {
+  if (rateLimitBackoff) {
+    rateLimitBackoff = false;
+    return true;
+  }
+  return false;
+}
+function didLastInitSucceed() {
+  return lastInitSucceeded;
+}
+async function verifyInitReachable(config, anonKey, sdkVersion) {
+  try {
+    const response = await sendInitRequest(config, anonKey, sdkVersion);
+    return { ok: true, response };
+  } catch (err) {
+    const status = err.status;
+    if (typeof status === "number") {
+      return {
+        ok: false,
+        reason: "rejected",
+        status,
+        detail: `server returned HTTP ${status}`
+      };
+    }
+    if (err instanceof Error && (err.name === "ZodError" || err.name === "SyntaxError")) {
+      return {
+        ok: false,
+        reason: "malformed",
+        detail: "server returned malformed response"
+      };
+    }
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const detail = rawMessage.startsWith("fetch failed: ") ? rawMessage.slice("fetch failed: ".length) : rawMessage;
+    return { ok: false, reason: "transport", detail };
+  }
+}
+
+// src/import-graph.ts
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+var MAX_TEST_FILES = 5e3;
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", ".turbo"]);
+var DEFAULT_TEST_PATTERNS = [
+  /\.test\.tsx?$/,
+  /\.spec\.tsx?$/
+];
+function globToRegExp(glob) {
+  const DOUBLE_STAR_PLACEHOLDER = "\0DSTAR\0";
+  const regexStr = glob.replace(/\*\*\//g, DOUBLE_STAR_PLACEHOLDER).replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]+").replace(new RegExp(DOUBLE_STAR_PLACEHOLDER.replace(/\0/g, "\\0"), "g"), "(?:.+/)?");
+  return new RegExp("^" + regexStr + "$");
+}
+function loadCustomTestPatterns(projectRoot) {
+  const configNames = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mts",
+    "vitest.config.mjs",
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mts",
+    "vite.config.mjs",
+    "jest.config.ts",
+    "jest.config.js",
+    "jest.config.mts",
+    "jest.config.mjs"
+  ];
+  for (const name of configNames) {
+    const configPath = path.join(projectRoot, name);
+    let content;
+    try {
+      content = fsSync.readFileSync(configPath, "utf-8");
+    } catch {
+      continue;
+    }
+    try {
+      const isJest = name.startsWith("jest.");
+      let includeMatch = null;
+      if (isJest) {
+        includeMatch = /testMatch\s*:\s*\[([^\]]*)\]/s.exec(content);
+      } else {
+        const testBlockMatch = /\btest\s*[:{]\s*/s.exec(content);
+        if (testBlockMatch) {
+          const afterTest = content.slice(testBlockMatch.index, testBlockMatch.index + 500);
+          includeMatch = /include\s*:\s*\[([^\]]*)\]/s.exec(afterTest);
+        }
+      }
+      if (!includeMatch) {
+        continue;
+      }
+      const arrayContent = includeMatch[1];
+      const stringRegex = /['"]([^'"]+)['"]/g;
+      const patterns = [];
+      let match;
+      match = stringRegex.exec(arrayContent);
+      while (match !== null) {
+        patterns.push(globToRegExp(match[1]));
+        match = stringRegex.exec(arrayContent);
+      }
+      if (patterns.length > 0) {
+        return patterns;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [];
+}
+async function discoverTestFiles(projectRoot) {
+  const customPatterns = loadCustomTestPatterns(projectRoot);
+  const testPatterns = [...DEFAULT_TEST_PATTERNS, ...customPatterns];
+  const results = [];
+  try {
+    await walkForTests(projectRoot, projectRoot, results, testPatterns);
+  } catch {
+    return [];
+  }
+  return results.slice(0, MAX_TEST_FILES);
+}
+async function walkForTests(baseDir, currentDir, results, testPatterns) {
+  if (results.length >= MAX_TEST_FILES) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await fs.readdir(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= MAX_TEST_FILES) {
+      return;
+    }
+    const fullPath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+      await walkForTests(baseDir, fullPath, results, testPatterns);
+    } else if (entry.isFile()) {
+      const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+      const isTestFile = testPatterns.some((p) => p.test(entry.name) || p.test(relativePath)) || relativePath.includes("__tests__");
+      if (isTestFile && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+        results.push(relativePath);
+      }
+    }
+  }
+}
+function extractImports(fileContent) {
+  const seen = /* @__PURE__ */ new Set();
+  const imports = [];
+  const addUnique = (importPath) => {
+    if (!seen.has(importPath)) {
+      seen.add(importPath);
+      imports.push(importPath);
+    }
+  };
+  const esFromImportRegex = /\bimport\b[^'"]+\bfrom\s+['"]([^'"]+)['"]/g;
+  const esSideEffectRegex = /\bimport\s+['"]([^'"]+)['"]/g;
+  let match;
+  match = esFromImportRegex.exec(fileContent);
+  while (match !== null) {
+    addUnique(match[1]);
+    match = esFromImportRegex.exec(fileContent);
+  }
+  match = esSideEffectRegex.exec(fileContent);
+  while (match !== null) {
+    addUnique(match[1]);
+    match = esSideEffectRegex.exec(fileContent);
+  }
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  match = requireRegex.exec(fileContent);
+  while (match !== null) {
+    addUnique(match[1]);
+    match = requireRegex.exec(fileContent);
+  }
+  const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  match = dynamicImportRegex.exec(fileContent);
+  while (match !== null) {
+    addUnique(match[1]);
+    match = dynamicImportRegex.exec(fileContent);
+  }
+  return imports;
+}
+async function buildImportGraph(projectRoot) {
+  const testFiles = await discoverTestFiles(projectRoot);
+  const graph = {};
+  for (const testFile of testFiles) {
+    const fullPath = path.join(projectRoot, testFile);
+    try {
+      const content = await fs.readFile(fullPath, "utf-8");
+      const imports = extractImports(content);
+      graph[testFile] = imports;
+    } catch {
+      continue;
+    }
+  }
+  const sortedKeys = Object.keys(graph).sort();
+  const serialized = sortedKeys.map((key) => `${key}:${JSON.stringify(graph[key])}`).join("\n");
+  const hashHex = crypto.createHash("sha256").update(serialized).digest("hex");
+  const buildHash = createBuildHash(hashHex);
+  return { buildHash, graph };
+}
+
+export {
+  recordSpansExported,
+  recordSpansDropped,
+  collectHealthReport,
+  loadCachedConfig,
+  saveCachedConfig,
+  sendInitRequest,
+  performInit,
+  getActiveConfig,
+  getLinkedAccountId,
+  getClaimResult,
+  _setCurrentConfig,
+  consumeRateLimitFlag,
+  didLastInitSucceed,
+  verifyInitReachable,
+  discoverTestFiles,
+  extractImports,
+  buildImportGraph
+};
+//# sourceMappingURL=chunk-5C2TJFLB.js.map