@glasstrace/sdk 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -16252,6 +16252,16 @@ var init_esm = __esm({
 function sanitize(input) {
   return input.replace(/[\x00-\x1f\x7f]/g, "");
 }
+function markerFileExists() {
+  try {
+    const fs4 = require("fs");
+    const path4 = require("path");
+    const markerPath = path4.join(process.cwd(), ".glasstrace", "mcp-connected");
+    return fs4.existsSync(markerPath);
+  } catch {
+    return false;
+  }
+}
 function maybeShowMcpNudge(errorSummary) {
   if (hasFired) {
     return;
@@ -16261,14 +16271,7 @@ function maybeShowMcpNudge(errorSummary) {
     hasFired = true;
     return;
   }
-  let markerExists = false;
-  try {
-    const markerPath = (0, import_node_path3.join)(process.cwd(), ".glasstrace", "mcp-connected");
-    markerExists = (0, import_node_fs2.existsSync)(markerPath);
-  } catch {
-    markerExists = false;
-  }
-  if (markerExists) {
+  if (markerFileExists()) {
     hasFired = true;
     return;
   }
@@ -16281,12 +16284,10 @@ function maybeShowMcpNudge(errorSummary) {
 `
   );
 }
-var import_node_fs2, import_node_path3, hasFired;
+var hasFired;
 var init_error_nudge = __esm({
   "src/nudge/error-nudge.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
-    import_node_path3 = require("path");
     init_env_detection();
     hasFired = false;
   }
@@ -16374,6 +16375,7 @@ __export(source_map_uploader_exports, {
   PRESIGNED_THRESHOLD_BYTES: () => PRESIGNED_THRESHOLD_BYTES,
   collectSourceMaps: () => collectSourceMaps,
   computeBuildHash: () => computeBuildHash,
+  discoverSourceMapFiles: () => discoverSourceMapFiles,
   requestPresignedTokens: () => requestPresignedTokens,
   submitManifest: () => submitManifest,
   uploadSourceMaps: () => uploadSourceMaps,
@@ -16381,16 +16383,26 @@ __export(source_map_uploader_exports, {
   uploadSourceMapsPresigned: () => uploadSourceMapsPresigned,
   uploadToBlob: () => uploadToBlob
 });
-async function collectSourceMaps(buildDir) {
+async function discoverSourceMapFiles(buildDir) {
+  const resolvedDir = path2.resolve(buildDir);
   const results = [];
   try {
-    await walkDir(buildDir, buildDir, results);
+    await walkDirMetadata(resolvedDir, resolvedDir, results);
   } catch {
     return [];
   }
+  for (const file2 of results) {
+    if (file2.sizeBytes >= LARGE_FILE_WARNING_BYTES) {
+      const sizeMB = (file2.sizeBytes / (1024 * 1024)).toFixed(1);
+      sdkLog(
+        "warn",
+        `[glasstrace] Large source map detected: ${file2.filePath} (${sizeMB}MB). Consider enabling source map compression.`
+      );
+    }
+  }
   return results;
 }
-async function walkDir(baseDir, currentDir, results) {
+async function walkDirMetadata(baseDir, currentDir, results) {
   let entries;
   try {
     entries = await fs2.readdir(currentDir, { withFileTypes: true });
@@ -16400,18 +16412,37 @@ async function walkDir(baseDir, currentDir, results) {
   for (const entry of entries) {
     const fullPath = path2.join(currentDir, entry.name);
     if (entry.isDirectory()) {
-      await walkDir(baseDir, fullPath, results);
+      await walkDirMetadata(baseDir, fullPath, results);
     } else if (entry.isFile() && entry.name.endsWith(".map")) {
       try {
-        const content = await fs2.readFile(fullPath, "utf-8");
+        const stat2 = await fs2.stat(fullPath);
         const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
         const compiledPath = relativePath.replace(/\.map$/, "");
-        results.push({ filePath: compiledPath, content });
+        results.push({
+          filePath: compiledPath,
+          absolutePath: fullPath,
+          sizeBytes: stat2.size
+        });
       } catch {
       }
     }
   }
 }
+async function readSourceMapContent(absolutePath) {
+  return fs2.readFile(absolutePath, "utf-8");
+}
+async function collectSourceMaps(buildDir) {
+  const fileInfos = await discoverSourceMapFiles(buildDir);
+  const results = [];
+  for (const info of fileInfos) {
+    try {
+      const content = await readSourceMapContent(info.absolutePath);
+      results.push({ filePath: info.filePath, content });
+    } catch {
+    }
+  }
+  return results;
+}
 async function computeBuildHash(maps) {
   try {
     const sha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf-8" }).trim();
@@ -16423,20 +16454,38 @@ async function computeBuildHash(maps) {
   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 hash2 = crypto2.createHash("sha256").update(hashInput).digest("hex");
-  return hash2;
+  const hash2 = crypto2.createHash("sha256");
+  for (const m of sortedMaps) {
+    let content;
+    if ("content" in m) {
+      content = m.content;
+    } else {
+      try {
+        content = await readSourceMapContent(m.absolutePath);
+      } catch {
+        continue;
+      }
+    }
+    hash2.update(`${m.filePath}
+${content.length}
+${content}`);
+  }
+  return hash2.digest("hex");
 }
 async function uploadSourceMaps(apiKey, endpoint, buildHash, maps) {
+  const files = [];
+  for (const m of maps) {
+    try {
+      const content = "content" in m ? m.content : await readSourceMapContent(m.absolutePath);
+      files.push({ filePath: m.filePath, sourceMap: content });
+    } catch {
+      sdkLog("warn", `[glasstrace] Skipping unreadable source map: ${m.filePath}`);
+    }
+  }
   const body = {
     apiKey,
     buildHash,
-    files: maps.map((m) => ({
-      filePath: m.filePath,
-      sourceMap: m.content
-    }))
+    files
   };
   const baseUrl = stripTrailingSlashes(endpoint);
   const response = await fetch(`${baseUrl}/v1/source-maps`, {
@@ -16533,14 +16582,15 @@ async function uploadSourceMapsPresigned(apiKey, endpoint, buildHash, maps, blob
   if (maps.length === 0) {
     throw new Error("No source maps to upload");
   }
+  const fileMetadata = maps.map((m) => ({
+    filePath: m.filePath,
+    sizeBytes: "content" in m ? Buffer.byteLength(m.content, "utf-8") : m.sizeBytes
+  }));
   const presigned = await requestPresignedTokens(
     apiKey,
     endpoint,
     buildHash,
-    maps.map((m) => ({
-      filePath: m.filePath,
-      sizeBytes: Buffer.byteLength(m.content, "utf-8")
-    }))
+    fileMetadata
   );
   const mapsByPath = new Map(maps.map((m) => [m.filePath, m]));
   if (mapsByPath.size !== maps.length) {
@@ -16560,7 +16610,18 @@ async function uploadSourceMapsPresigned(apiKey, endpoint, buildHash, maps, blob
     const chunkResults = await Promise.all(
       chunk.map(async (token) => {
         const entry = mapsByPath.get(token.filePath);
-        const result = await blobUploader(token.clientToken, token.pathname, entry.content);
+        let content;
+        if ("content" in entry) {
+          content = entry.content;
+        } else {
+          try {
+            content = await readSourceMapContent(entry.absolutePath);
+          } catch {
+            sdkLog("warn", `[glasstrace] Skipping unreadable source map: ${token.filePath}`);
+            return null;
+          }
+        }
+        const result = await blobUploader(token.clientToken, token.pathname, content);
         return {
           filePath: token.filePath,
           sizeBytes: result.size,
@@ -16568,7 +16629,11 @@ async function uploadSourceMapsPresigned(apiKey, endpoint, buildHash, maps, blob
         };
       })
     );
-    uploadResults.push(...chunkResults);
+    for (const r of chunkResults) {
+      if (r !== null) {
+        uploadResults.push(r);
+      }
+    }
   }
   return submitManifest(apiKey, endpoint, presigned.uploadId, buildHash, uploadResults);
 }
@@ -16577,7 +16642,10 @@ async function uploadSourceMapsAuto(apiKey, endpoint, buildHash, maps, options)
     throw new Error("No source maps to upload");
   }
   const totalBytes = maps.reduce(
-    (sum, m) => sum + Buffer.byteLength(m.content, "utf-8"),
+    (sum, m) => {
+      const bytes = "content" in m ? Buffer.byteLength(m.content, "utf-8") : m.sizeBytes;
+      return sum + bytes;
+    },
     0
   );
   if (totalBytes < PRESIGNED_THRESHOLD_BYTES) {
@@ -16603,11 +16671,11 @@ async function uploadSourceMapsAuto(apiKey, endpoint, buildHash, maps, options)
   }
   sdkLog(
     "warn",
-    `[glasstrace] Build exceeds 4.5MB (${totalBytes} bytes). Install @vercel/blob for presigned uploads to avoid serverless body size limits. Falling back to legacy upload.`
+    `[glasstrace] Build exceeds 4.5MB (${String(totalBytes)} bytes). Install @vercel/blob for presigned uploads to avoid serverless body size limits. Falling back to legacy upload.`
   );
   return uploadSourceMaps(apiKey, endpoint, buildHash, maps);
 }
-var fs2, path2, crypto2, import_node_child_process, PRESIGNED_THRESHOLD_BYTES;
+var fs2, path2, crypto2, import_node_child_process, LARGE_FILE_WARNING_BYTES, PRESIGNED_THRESHOLD_BYTES;
 var init_source_map_uploader = __esm({
   "src/source-map-uploader.ts"() {
     "use strict";
@@ -16617,6 +16685,7 @@ var init_source_map_uploader = __esm({
     import_node_child_process = require("child_process");
     init_console_capture();
     init_dist();
+    LARGE_FILE_WARNING_BYTES = 50 * 1024 * 1024;
     PRESIGNED_THRESHOLD_BYTES = 45e5;
   }
 });
@@ -16636,6 +16705,7 @@ __export(src_exports, {
   computeBuildHash: () => computeBuildHash,
   createDiscoveryHandler: () => createDiscoveryHandler,
   deriveSessionId: () => deriveSessionId,
+  discoverSourceMapFiles: () => discoverSourceMapFiles,
   discoverTestFiles: () => discoverTestFiles,
   extractImports: () => extractImports,
   getActiveConfig: () => getActiveConfig,
@@ -16675,14 +16745,37 @@ var SdkError = class extends Error {
 init_env_detection();
 
 // src/session.ts
-var import_node_crypto = require("crypto");
 init_dist();
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
+var hashFn = null;
+function fnv1aHash(input) {
+  let hash2 = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash2 ^= input.charCodeAt(i);
+    hash2 = Math.imul(hash2, 16777619);
+    hash2 >>>= 0;
+  }
+  return hash2.toString(16).padStart(8, "0");
+}
+function getHashFn() {
+  if (hashFn) return hashFn;
+  try {
+    const { createHash: createHash3 } = require("crypto");
+    hashFn = (input) => createHash3("sha256").update(input).digest("hex").slice(0, 16);
+  } catch {
+    hashFn = (input) => {
+      const h1 = fnv1aHash(input);
+      const h2 = fnv1aHash(input + "\0");
+      return (h1 + h2).slice(0, 16);
+    };
+  }
+  return hashFn;
+}
 var cachedGlasstraceEnv = process.env.GLASSTRACE_ENV;
 var cachedPort = process.env.PORT ?? "3000";
 function deriveSessionId(apiKey, origin, date5, windowIndex) {
   const input = JSON.stringify([apiKey, origin, date5, windowIndex]);
-  const hash2 = (0, import_node_crypto.createHash)("sha256").update(input).digest("hex").slice(0, 16);
+  const hash2 = getHashFn()(input);
   return SessionIdSchema.parse(hash2);
 }
 function getOrigin() {
@@ -16768,22 +16861,38 @@ function classifyFetchTarget(url2) {
 }
 
 // src/anon-key.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
 init_dist();
 var GLASSTRACE_DIR = ".glasstrace";
 var ANON_KEY_FILE = "anon_key";
+var fsPathCache;
+async function loadFsPath() {
+  if (fsPathCache !== void 0) return fsPathCache;
+  try {
+    const [fs4, path4] = await Promise.all([
+      import("fs/promises"),
+      import("path")
+    ]);
+    fsPathCache = { fs: fs4, path: path4 };
+    return fsPathCache;
+  } catch {
+    fsPathCache = null;
+    return null;
+  }
+}
 var ephemeralKeyCache = /* @__PURE__ */ new Map();
 async function readAnonKey(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const keyPath = (0, import_node_path.join)(root, GLASSTRACE_DIR, ANON_KEY_FILE);
-  try {
-    const content = await (0, import_promises.readFile)(keyPath, "utf-8");
-    const result = AnonApiKeySchema.safeParse(content);
-    if (result.success) {
-      return result.data;
+  const modules = await loadFsPath();
+  if (modules) {
+    const keyPath = modules.path.join(root, GLASSTRACE_DIR, ANON_KEY_FILE);
+    try {
+      const content = await modules.fs.readFile(keyPath, "utf-8");
+      const result = AnonApiKeySchema.safeParse(content);
+      if (result.success) {
+        return result.data;
+      }
+    } catch {
     }
-  } catch {
   }
   const cached2 = ephemeralKeyCache.get(root);
   if (cached2 !== void 0) {
@@ -16793,8 +16902,6 @@ async function readAnonKey(projectRoot) {
 }
 async function getOrCreateAnonKey(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const dirPath = (0, import_node_path.join)(root, GLASSTRACE_DIR);
-  const keyPath = (0, import_node_path.join)(dirPath, ANON_KEY_FILE);
   const existingKey = await readAnonKey(root);
   if (existingKey !== null) {
     return existingKey;
@@ -16804,9 +16911,16 @@ async function getOrCreateAnonKey(projectRoot) {
     return cached2;
   }
   const newKey = createAnonApiKey();
+  const modules = await loadFsPath();
+  if (!modules) {
+    ephemeralKeyCache.set(root, newKey);
+    return newKey;
+  }
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR);
+  const keyPath = modules.path.join(dirPath, ANON_KEY_FILE);
   try {
-    await (0, import_promises.mkdir)(dirPath, { recursive: true, mode: 448 });
-    await (0, import_promises.writeFile)(keyPath, newKey, { flag: "wx", mode: 384 });
+    await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+    await modules.fs.writeFile(keyPath, newKey, { flag: "wx", mode: 384 });
     return newKey;
   } catch (err) {
     const code = err.code;
@@ -16817,12 +16931,12 @@ async function getOrCreateAnonKey(projectRoot) {
           return winnerKey;
         }
         if (attempt < 2) {
-          await new Promise((resolve2) => setTimeout(resolve2, 50));
+          await new Promise((resolve3) => setTimeout(resolve3, 50));
         }
       }
       try {
-        await (0, import_promises.writeFile)(keyPath, newKey, { mode: 384 });
-        await (0, import_promises.chmod)(keyPath, 384);
+        await modules.fs.writeFile(keyPath, newKey, { mode: 384 });
+        await modules.fs.chmod(keyPath, 384);
         return newKey;
       } catch {
       }
@@ -16836,22 +16950,45 @@ async function getOrCreateAnonKey(projectRoot) {
 }
 
 // src/init-client.ts
-var import_node_fs = require("fs");
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
 init_dist();
 var GLASSTRACE_DIR2 = ".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 [fs4, path4] = await Promise.all([
+      import("fs/promises"),
+      import("path")
+    ]);
+    fsPathAsyncCache = { fs: fs4, path: path4 };
+    return fsPathAsyncCache;
+  } catch {
+    fsPathAsyncCache = null;
+    return null;
+  }
+}
+function loadFsSyncOrNull() {
+  try {
+    const fs4 = require("fs");
+    const path4 = require("path");
+    return { readFileSync: fs4.readFileSync, join: path4.join };
+  } catch {
+    return null;
+  }
+}
 var currentConfig = null;
 var configCacheChecked = false;
 var rateLimitBackoff = false;
 function loadCachedConfig(projectRoot) {
+  const modules = loadFsSyncOrNull();
+  if (!modules) return null;
   const root = projectRoot ?? process.cwd();
-  const configPath = (0, import_node_path2.join)(root, GLASSTRACE_DIR2, CONFIG_FILE);
+  const configPath = modules.join(root, GLASSTRACE_DIR2, CONFIG_FILE);
   try {
-    const content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    const content = modules.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(content);
     const cached2 = SdkCachedConfigSchema.parse(parsed);
     const age = Date.now() - cached2.cachedAt;
@@ -16871,18 +17008,20 @@ function loadCachedConfig(projectRoot) {
   }
 }
 async function saveCachedConfig(response, projectRoot) {
+  const modules = await loadFsPathAsync();
+  if (!modules) return;
   const root = projectRoot ?? process.cwd();
-  const dirPath = (0, import_node_path2.join)(root, GLASSTRACE_DIR2);
-  const configPath = (0, import_node_path2.join)(dirPath, CONFIG_FILE);
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR2);
+  const configPath = modules.path.join(dirPath, CONFIG_FILE);
   try {
-    await (0, import_promises2.mkdir)(dirPath, { recursive: true, mode: 448 });
-    await (0, import_promises2.chmod)(dirPath, 448);
+    await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+    await modules.fs.chmod(dirPath, 448);
     const cached2 = {
       response,
       cachedAt: Date.now()
     };
-    await (0, import_promises2.writeFile)(configPath, JSON.stringify(cached2), { encoding: "utf-8", mode: 384 });
-    await (0, import_promises2.chmod)(configPath, 384);
+    await modules.fs.writeFile(configPath, JSON.stringify(cached2), { encoding: "utf-8", mode: 384 });
+    await modules.fs.chmod(configPath, 384);
   } catch (err) {
     console.warn(
       `[glasstrace] Failed to cache config to ${configPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -16936,69 +17075,72 @@ async function sendInitRequest(config2, anonKey, sdkVersion, importGraph, health
   return SdkInitResponseSchema.parse(body);
 }
 async function writeClaimedKey(newApiKey, projectRoot) {
-  const root = projectRoot ?? process.cwd();
-  const envLocalPath = (0, import_node_path2.join)(root, ".env.local");
-  let envLocalWritten = false;
-  try {
-    let content;
+  const modules = await loadFsPathAsync();
+  if (modules) {
+    const root = projectRoot ?? process.cwd();
+    const envLocalPath = modules.path.join(root, ".env.local");
+    let envLocalWritten = false;
     try {
-      content = await (0, import_promises2.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";
+      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}
+        content = `GLASSTRACE_API_KEY=${newApiKey}
 `;
       }
-    } catch (readErr) {
-      const code = readErr instanceof Error ? readErr.code : void 0;
-      if (code !== "ENOENT") {
-        throw readErr;
+      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 {
       }
-      content = `GLASSTRACE_API_KEY=${newApiKey}
-`;
+      return;
     }
-    await (0, import_promises2.writeFile)(envLocalPath, content, { encoding: "utf-8", mode: 384 });
-    await (0, import_promises2.chmod)(envLocalPath, 384);
-    envLocalWritten = true;
-  } catch {
-  }
-  if (envLocalWritten) {
+    let claimedKeyWritten = false;
     try {
-      process.stderr.write(
-        "[glasstrace] Account claimed! API key written to .env.local. Restart your dev server to use it.\n"
-      );
+      const dirPath = modules.path.join(root, GLASSTRACE_DIR2);
+      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 {
     }
-    return;
-  }
-  let claimedKeyWritten = false;
-  try {
-    const dirPath = (0, import_node_path2.join)(root, GLASSTRACE_DIR2);
-    await (0, import_promises2.mkdir)(dirPath, { recursive: true, mode: 448 });
-    await (0, import_promises2.chmod)(dirPath, 448);
-    const claimedKeyPath = (0, import_node_path2.join)(dirPath, "claimed-key");
-    await (0, import_promises2.writeFile)(claimedKeyPath, newApiKey, {
-      encoding: "utf-8",
-      mode: 384
-    });
-    await (0, import_promises2.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 {
+    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;
     }
-    return;
   }
   try {
     process.stderr.write(
@@ -18017,8 +18159,8 @@ var Deferred = class {
   _resolve;
   _reject;
   constructor() {
-    this._promise = new Promise((resolve2, reject) => {
-      this._resolve = resolve2;
+    this._promise = new Promise((resolve3, reject) => {
+      this._resolve = resolve3;
       this._reject = reject;
     });
   }
@@ -18636,7 +18778,7 @@ var VERSION3 = "0.214.0";
 // ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
 var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION3}`;
 function sendWithHttp(request, url2, headers, compression, userAgent, agent, data, timeoutMillis) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const parsedUrl = new URL(url2);
     if (userAgent) {
       headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`;
@@ -18656,18 +18798,18 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
       res.on("data", (chunk) => responseData.push(chunk));
       res.on("end", () => {
         if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
+          resolve3({
             status: "success",
             data: Buffer.concat(responseData)
           });
         } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
+          resolve3({
             status: "retryable",
             retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
           });
         } else {
           const error48 = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
-          resolve2({
+          resolve3({
             status: "failure",
             error: error48
           });
@@ -18675,17 +18817,17 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
       });
       res.on("error", (error48) => {
         if (res.statusCode && res.statusCode <= 299) {
-          resolve2({
+          resolve3({
             status: "success"
           });
         } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve2({
+          resolve3({
             status: "retryable",
             error: error48,
             retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
           });
         } else {
-          resolve2({
+          resolve3({
             status: "failure",
             error: error48
           });
@@ -18694,26 +18836,26 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
     });
     req.setTimeout(timeoutMillis, () => {
       req.destroy();
-      resolve2({
+      resolve3({
         status: "retryable",
         error: new Error("Request timed out")
       });
     });
     req.on("error", (error48) => {
       if (isHttpTransportNetworkErrorRetryable(error48)) {
-        resolve2({
+        resolve3({
           status: "retryable",
           error: error48
         });
       } else {
-        resolve2({
+        resolve3({
           status: "failure",
           error: error48
         });
       }
     });
     compressAndSend(req, compression, data, (error48) => {
-      resolve2({
+      resolve3({
         status: "failure",
         error: error48
       });
@@ -18803,9 +18945,9 @@ var RetryingTransport = class {
     this._transport = transport;
   }
   retry(data, timeoutMillis, inMillis) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       setTimeout(() => {
-        this._transport.send(data, timeoutMillis).then(resolve2, reject);
+        this._transport.send(data, timeoutMillis).then(resolve3, reject);
       }, inMillis);
     });
   }
@@ -19669,14 +19811,14 @@ var BatchSpanProcessorBase = class {
    * for all other cases _flush should be used
    * */
   _flushAll() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, 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();
+        resolve3();
       }).catch(reject);
     });
   }
@@ -19685,7 +19827,7 @@ var BatchSpanProcessorBase = class {
     if (this._finishedSpans.length === 0) {
       return Promise.resolve();
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         reject(new Error("Timeout"));
       }, this._exportTimeoutMillis);
@@ -19700,7 +19842,7 @@ var BatchSpanProcessorBase = class {
         const doExport = () => this._exporter.export(spans, (result) => {
           clearTimeout(timer);
           if (result.code === ExportResultCode.SUCCESS) {
-            resolve2();
+            resolve3();
           } else {
             reject(result.error ?? new Error("BatchSpanProcessor: span export failed"));
           }
@@ -19987,12 +20129,12 @@ var MultiSpanProcessor = class {
     for (const spanProcessor of this._spanProcessors) {
       promises.push(spanProcessor.forceFlush());
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       Promise.all(promises).then(() => {
-        resolve2();
+        resolve3();
       }).catch((error48) => {
         globalErrorHandler(error48 || new Error("MultiSpanProcessor: forceFlush failed"));
-        resolve2();
+        resolve3();
       });
     });
   }
@@ -20018,9 +20160,9 @@ var MultiSpanProcessor = class {
     for (const spanProcessor of this._spanProcessors) {
       promises.push(spanProcessor.shutdown());
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       Promise.all(promises).then(() => {
-        resolve2();
+        resolve3();
       }, reject);
     });
   }
@@ -20061,32 +20203,32 @@ var BasicTracerProvider = class {
   forceFlush() {
     const timeout = this._config.forceFlushTimeoutMillis;
     const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
-      return new Promise((resolve2) => {
+      return new Promise((resolve3) => {
         let state;
         const timeoutInterval = setTimeout(() => {
-          resolve2(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+          resolve3(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);
+            resolve3(state);
           }
         }).catch((error48) => {
           clearTimeout(timeoutInterval);
           state = ForceFlushState.error;
-          resolve2(error48);
+          resolve3(error48);
         });
       });
     });
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       Promise.all(promises).then((results) => {
         const errors = results.filter((result) => result !== ForceFlushState.resolved);
         if (errors.length > 0) {
           reject(errors);
         } else {
-          resolve2();
+          resolve3();
         }
       }).catch((error48) => reject([error48]));
     });
@@ -20343,7 +20485,7 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const initResult = await performInit(config2, anonKeyForInit, "0.11.0");
+  const initResult = await performInit(config2, anonKeyForInit, "0.12.0");
   if (generation !== registrationGeneration) return;
   if (initResult?.claimResult) {
     setResolvedApiKey(initResult.claimResult.newApiKey);
@@ -20417,16 +20559,16 @@ async function handleSourceMapUpload(distDir) {
       );
       return;
     }
-    const { collectSourceMaps: collectSourceMaps2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await Promise.resolve().then(() => (init_source_map_uploader(), source_map_uploader_exports));
-    const maps = await collectSourceMaps2(distDir);
-    if (maps.length === 0) {
+    const { discoverSourceMapFiles: discoverSourceMapFiles2, computeBuildHash: computeBuildHash2, uploadSourceMaps: uploadSourceMaps2 } = await Promise.resolve().then(() => (init_source_map_uploader(), source_map_uploader_exports));
+    const files = await discoverSourceMapFiles2(distDir);
+    if (files.length === 0) {
       console.info("[glasstrace] No source map files found. Skipping upload.");
       return;
     }
-    const buildHash = await computeBuildHash2(maps);
-    await uploadSourceMaps2(apiKey, endpoint, buildHash, maps);
+    const buildHash = await computeBuildHash2(files);
+    await uploadSourceMaps2(apiKey, endpoint, buildHash, files);
     console.info(
-      `[glasstrace] Uploaded ${String(maps.length)} source map(s) for build ${buildHash}.`
+      `[glasstrace] Uploaded ${String(files.length)} source map(s) for build ${buildHash}.`
     );
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : "Unknown error";
@@ -20643,6 +20785,7 @@ async function buildImportGraph(projectRoot) {
   computeBuildHash,
   createDiscoveryHandler,
   deriveSessionId,
+  discoverSourceMapFiles,
   discoverTestFiles,
   extractImports,
   getActiveConfig,