@glasstrace/sdk 1.3.9 → 1.5.0

package/dist/node-entry.cjs

@@ -339,10 +339,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -654,11 +654,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -901,7 +901,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path4 = []) => {
+  const processError = (error49, path5 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -911,7 +911,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -943,8 +943,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13708,13 +13708,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14594,7 +14594,18 @@ var init_dist = __esm({
       fullConsoleOutput: external_exports.boolean(),
       importGraph: external_exports.boolean(),
       consoleErrors: external_exports.boolean().optional().default(false),
-      errorResponseBodies: external_exports.boolean().optional().default(false)
+      errorResponseBodies: external_exports.boolean().optional().default(false),
+      /**
+       * Account opt-in for side-effect evidence emission (SDK-049).
+       *
+       * When `false` (default), `recordSideEffect()` is a silent no-op:
+       * no allowlist evaluation runs and no `glasstrace.side_effect.*`
+       * attribute reaches the wire. When `true`, allowlisted side-effect
+       * metadata is attached to the active OTel span subject to the
+       * client-side allowlist enforcement layered with the product's
+       * storage-time filter as defense-in-depth.
+       */
+      sideEffectEvidence: external_exports.boolean().optional().default(false)
     });
     SdkCachedConfigSchema = external_exports.object({
       response: external_exports.record(external_exports.string(), external_exports.unknown()),
@@ -14654,7 +14665,37 @@ var init_dist = __esm({
       TRIGGER_TYPE: "glasstrace.trigger.type",
       ELEMENT_FINGERPRINT: "glasstrace.element.fingerprint",
       ELEMENT_CONFIDENCE: "glasstrace.element.confidence",
-      TAB_ID: "glasstrace.tab.id"
+      TAB_ID: "glasstrace.tab.id",
+      // Side-effect evidence (SDK-049 / SCHEMA-036).
+      // Top-level operation attributes attached to the active span when a
+      // side-effect is recorded via `recordSideEffect()`. The wire-string
+      // set aligns verbatim with the product-side filter in
+      // `packages/ingestion/src/services/trace-writer.ts`.
+      SIDE_EFFECT_KIND: "glasstrace.side_effect.kind",
+      SIDE_EFFECT_OPERATION: "glasstrace.side_effect.operation",
+      SIDE_EFFECT_STATUS: "glasstrace.side_effect.status",
+      SIDE_EFFECT_PHASE: "glasstrace.side_effect.phase",
+      // Allowlisted semantic field attributes — one per allowlisted key.
+      // Wire keys are camelCase to match the SCHEMA-036 enum members
+      // exactly; the SDK constant names are SCREAMING_SNAKE per the rest
+      // of GLASSTRACE_ATTRIBUTE_NAMES.
+      SIDE_EFFECT_FIELD_TEMPLATE_KEY: "glasstrace.side_effect.field.templateKey",
+      SIDE_EFFECT_FIELD_PROVIDER_OPERATION: "glasstrace.side_effect.field.providerOperation",
+      SIDE_EFFECT_FIELD_ROLE: "glasstrace.side_effect.field.role",
+      SIDE_EFFECT_FIELD_LOCALE: "glasstrace.side_effect.field.locale",
+      SIDE_EFFECT_FIELD_TIMEZONE: "glasstrace.side_effect.field.timezone",
+      SIDE_EFFECT_FIELD_STATUS: "glasstrace.side_effect.field.status",
+      SIDE_EFFECT_FIELD_PHASE: "glasstrace.side_effect.field.phase",
+      // Omission reason attributes — one per allowlisted reason. The
+      // attribute value carries an integer count; the rejected value is
+      // never echoed.
+      SIDE_EFFECT_OMITTED_PII: "glasstrace.side_effect.omitted.pii",
+      SIDE_EFFECT_OMITTED_SECRET: "glasstrace.side_effect.omitted.secret",
+      SIDE_EFFECT_OMITTED_RAW_PAYLOAD: "glasstrace.side_effect.omitted.raw_payload",
+      SIDE_EFFECT_OMITTED_UNSUPPORTED_KEY: "glasstrace.side_effect.omitted.unsupported_key",
+      SIDE_EFFECT_OMITTED_VALUE_TOO_LONG: "glasstrace.side_effect.omitted.value_too_long",
+      SIDE_EFFECT_OMITTED_NOT_EMITTED: "glasstrace.side_effect.omitted.not_emitted",
+      SIDE_EFFECT_OMITTED_CAPTURE_DISABLED: "glasstrace.side_effect.omitted.capture_disabled"
     };
     DEFAULT_CAPTURE_CONFIG = {
       requestBodies: false,
@@ -14663,7 +14704,8 @@ var init_dist = __esm({
       fullConsoleOutput: false,
       importGraph: false,
       consoleErrors: false,
-      errorResponseBodies: false
+      errorResponseBodies: false,
+      sideEffectEvidence: false
     };
     MAX_SOURCE_MAP_FILE_PATH_LENGTH = 512;
     MAX_SOURCE_MAP_FILE_SIZE = 50 * 1024 * 1024;
@@ -16443,10 +16485,10 @@ function sanitize(input) {
 }
 function markerFileExists() {
   try {
-    const fs4 = require("node:fs");
-    const path4 = require("node:path");
-    const markerPath = path4.join(process.cwd(), ".glasstrace", "mcp-connected");
-    return fs4.existsSync(markerPath);
+    const fs5 = require("node:fs");
+    const path5 = require("node:path");
+    const markerPath = path5.join(process.cwd(), ".glasstrace", "mcp-connected");
+    return fs5.existsSync(markerPath);
   } catch {
     return false;
   }
@@ -16595,7 +16637,7 @@ __export(source_map_uploader_exports, {
   uploadToBlob: () => uploadToBlob
 });
 async function discoverSourceMapFiles(buildDir) {
-  const resolvedDir = path2.resolve(buildDir);
+  const resolvedDir = path3.resolve(buildDir);
   const results = [];
   try {
     await walkDirMetadata(resolvedDir, resolvedDir, results);
@@ -16616,18 +16658,18 @@ async function discoverSourceMapFiles(buildDir) {
 async function walkDirMetadata(baseDir, currentDir, results) {
   let entries;
   try {
-    entries = await fs2.readdir(currentDir, { withFileTypes: true });
+    entries = await fs3.readdir(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path2.join(currentDir, entry.name);
+    const fullPath = path3.join(currentDir, entry.name);
     if (entry.isDirectory()) {
       await walkDirMetadata(baseDir, fullPath, results);
     } else if (entry.isFile() && entry.name.endsWith(".map")) {
       try {
-        const stat2 = await fs2.stat(fullPath);
-        const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const stat2 = await fs3.stat(fullPath);
+        const relativePath = path3.relative(baseDir, fullPath).replace(/\\/g, "/");
         const compiledPath = relativePath.replace(/\.map$/, "");
         results.push({
           filePath: compiledPath,
@@ -16640,7 +16682,7 @@ async function walkDirMetadata(baseDir, currentDir, results) {
   }
 }
 async function readSourceMapContent(absolutePath) {
-  return fs2.readFile(absolutePath, "utf-8");
+  return fs3.readFile(absolutePath, "utf-8");
 }
 async function collectSourceMaps(buildDir) {
   const fileInfos = await discoverSourceMapFiles(buildDir);
@@ -16895,12 +16937,12 @@ async function uploadSourceMapsAuto(apiKey, endpoint, buildHash, maps, options)
   );
   return uploadSourceMaps(apiKey, endpoint, buildHash, maps);
 }
-var fs2, path2, crypto2, import_node_child_process, LARGE_FILE_WARNING_BYTES, PRESIGNED_THRESHOLD_BYTES, _blobClientLoader;
+var fs3, path3, crypto2, import_node_child_process, LARGE_FILE_WARNING_BYTES, PRESIGNED_THRESHOLD_BYTES, _blobClientLoader;
 var init_source_map_uploader = __esm({
   "src/source-map-uploader.ts"() {
     "use strict";
-    fs2 = __toESM(require("node:fs/promises"), 1);
-    path2 = __toESM(require("node:path"), 1);
+    fs3 = __toESM(require("node:fs/promises"), 1);
+    path3 = __toESM(require("node:path"), 1);
     crypto2 = __toESM(require("node:crypto"), 1);
     import_node_child_process = require("node:child_process");
     init_console_capture();
@@ -17149,11 +17191,11 @@ var fsPathCache;
 async function loadFsPath() {
   if (fsPathCache !== void 0) return fsPathCache;
   try {
-    const [fs4, path4] = await Promise.all([
+    const [fs5, path5] = await Promise.all([
       import("node:fs/promises"),
       import("node:path")
     ]);
-    fsPathCache = { fs: fs4, path: path4 };
+    fsPathCache = { fs: fs5, path: path5 };
     return fsPathCache;
   } catch {
     fsPathCache = null;
@@ -17674,35 +17716,35 @@ function atomicWriteFileSync(targetPath, payload, options = {}) {
 function atomicWriteFileSyncWithTmp(targetPath, tmpPath, payload, options = {}) {
   const mode = options.mode ?? 384;
   const encoding = options.encoding ?? "utf-8";
-  const fs4 = loadFsSync();
+  const fs5 = loadFsSync();
   let fd = null;
   try {
     if (typeof payload === "string") {
-      fs4.writeFileSync(tmpPath, payload, { encoding, mode });
+      fs5.writeFileSync(tmpPath, payload, { encoding, mode });
     } else {
-      fs4.writeFileSync(tmpPath, payload, { mode });
+      fs5.writeFileSync(tmpPath, payload, { mode });
     }
-    fs4.chmodSync(tmpPath, mode);
-    fd = fs4.openSync(tmpPath, "r");
-    fs4.fsyncSync(fd);
-    fs4.closeSync(fd);
+    fs5.chmodSync(tmpPath, mode);
+    fd = fs5.openSync(tmpPath, "r");
+    fs5.fsyncSync(fd);
+    fs5.closeSync(fd);
     fd = null;
-    fs4.renameSync(tmpPath, targetPath);
+    fs5.renameSync(tmpPath, targetPath);
   } catch (err) {
     if (fd !== null) {
       try {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       } catch {
       }
     }
-    removeTmpResidueSync(fs4, tmpPath);
+    removeTmpResidueSync(fs5, tmpPath);
     throw err;
   }
-  fsyncParentDirSyncWithFs(targetPath, fs4);
+  fsyncParentDirSyncWithFs(targetPath, fs5);
 }
-function removeTmpResidueSync(fs4, tmpPath) {
+function removeTmpResidueSync(fs5, tmpPath) {
   try {
-    fs4.unlinkSync(tmpPath);
+    fs5.unlinkSync(tmpPath);
     return;
   } catch (err) {
     const code = errnoCodeOf(err);
@@ -17711,16 +17753,16 @@ function removeTmpResidueSync(fs4, tmpPath) {
     }
   }
   try {
-    fs4.rmdirSync(tmpPath);
+    fs5.rmdirSync(tmpPath);
   } catch {
   }
 }
-function fsyncParentDirSyncWithFs(targetPath, fs4) {
+function fsyncParentDirSyncWithFs(targetPath, fs5) {
   const parent = parentDir(targetPath);
   let fd = null;
   try {
-    fd = fs4.openSync(parent, "r");
-    fs4.fsyncSync(fd);
+    fd = fs5.openSync(parent, "r");
+    fs5.fsyncSync(fd);
   } catch (err) {
     const code = errnoCodeOf(err);
     if (code !== void 0 && PARENT_FSYNC_SWALLOWED_CODES.has(code)) {
@@ -17730,7 +17772,7 @@ function fsyncParentDirSyncWithFs(targetPath, fs4) {
   } finally {
     if (fd !== null) {
       try {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       } catch {
       }
     }
@@ -17751,11 +17793,11 @@ var fsPathCache2;
 async function loadFsPath2() {
   if (fsPathCache2 !== void 0) return fsPathCache2;
   try {
-    const [fs4, path4] = await Promise.all([
+    const [fs5, path5] = await Promise.all([
       import("node:fs/promises"),
       import("node:path")
     ]);
-    fsPathCache2 = { fs: fs4, path: path4 };
+    fsPathCache2 = { fs: fs5, path: path5 };
     return fsPathCache2;
   } catch {
     fsPathCache2 = null;
@@ -18041,11 +18083,11 @@ var fsPathAsyncCache;
 async function loadFsPathAsync() {
   if (fsPathAsyncCache !== void 0) return fsPathAsyncCache;
   try {
-    const [fs4, path4] = await Promise.all([
+    const [fs5, path5] = await Promise.all([
       import("node:fs/promises"),
       import("node:path")
     ]);
-    fsPathAsyncCache = { fs: fs4, path: path4 };
+    fsPathAsyncCache = { fs: fs5, path: path5 };
     return fsPathAsyncCache;
   } catch {
     fsPathAsyncCache = null;
@@ -18054,9 +18096,9 @@ async function loadFsPathAsync() {
 }
 function loadFsSyncOrNull() {
   try {
-    const fs4 = require("node:fs");
-    const path4 = require("node:path");
-    return { readFileSync: fs4.readFileSync, join: path4.join };
+    const fs5 = require("node:fs");
+    const path5 = require("node:path");
+    return { readFileSync: fs5.readFileSync, join: path5.join };
   } catch {
     return null;
   }
@@ -20503,7 +20545,7 @@ function appendRootPathToUrlIfNeeded(url2) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url2, path4) {
+function appendResourcePathToUrl(url2, path5) {
   try {
     new URL(url2);
   } catch {
@@ -20513,11 +20555,11 @@ function appendResourcePathToUrl(url2, path4) {
   if (!url2.endsWith("/")) {
     url2 = url2 + "/";
   }
-  url2 += path4;
+  url2 += path5;
   try {
     new URL(url2);
   } catch {
-    diag2.warn(`Configuration: Provided URL appended with '${path4}' is not a valid URL, using 'undefined' instead of '${url2}'`);
+    diag2.warn(`Configuration: Provided URL appended with '${path5}' is not a valid URL, using 'undefined' instead of '${url2}'`);
     return void 0;
   }
   return url2;
@@ -22723,6 +22765,171 @@ function writeStateNow() {
   }
 }
 
+// src/agent-detection/upgrade-notice.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var path2 = __toESM(require("node:path"), 1);
+
+// src/agent-detection/inject.ts
+var HTML_START_RE = /^<!--\s*glasstrace:mcp:start(?:\s+v=([^\s>]+))?\s*-->$/;
+var HTML_END = "<!-- glasstrace:mcp:end -->";
+var HASH_START_RE = /^#\s*glasstrace:mcp:start(?:\s+v=(\S+))?$/;
+var HASH_END = "# glasstrace:mcp:end";
+function parseStartMarkerLine(line) {
+  const trimmed = line.trim();
+  const html = HTML_START_RE.exec(trimmed);
+  if (html !== null) {
+    return { kind: "html", stamp: html[1] ?? null };
+  }
+  const hash2 = HASH_START_RE.exec(trimmed);
+  if (hash2 !== null) {
+    return { kind: "hash", stamp: hash2[1] ?? null };
+  }
+  return null;
+}
+function isEndMarker(line) {
+  const trimmed = line.trim();
+  return trimmed === HTML_END || trimmed === HASH_END;
+}
+function isEndMarkerLine(line) {
+  return isEndMarker(line);
+}
+
+// src/agent-detection/upgrade-notice.ts
+var warningEmitted = false;
+var AGENT_INSTRUCTION_FILES = [
+  "CLAUDE.md",
+  "codex.md",
+  ".cursorrules"
+];
+function parseSemver(input) {
+  const plusIdx = input.indexOf("+");
+  const core = plusIdx === -1 ? input : input.slice(0, plusIdx);
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(core);
+  if (m === null) return null;
+  return {
+    major: Number(m[1]),
+    minor: Number(m[2]),
+    patch: Number(m[3]),
+    prerelease: m[4] ?? null
+  };
+}
+function comparePrerelease(a, b) {
+  const ap = a.split(".");
+  const bp = b.split(".");
+  const len = Math.min(ap.length, bp.length);
+  for (let i = 0; i < len; i++) {
+    const x = ap[i];
+    const y = bp[i];
+    const xNumeric = /^\d+$/.test(x);
+    const yNumeric = /^\d+$/.test(y);
+    if (xNumeric && yNumeric) {
+      const xv = Number(x);
+      const yv = Number(y);
+      if (xv !== yv) return xv < yv ? -1 : 1;
+    } else if (xNumeric) {
+      return -1;
+    } else if (yNumeric) {
+      return 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return ap.length - bp.length;
+}
+function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (pa === null || pb === null) return null;
+  if (pa.major !== pb.major) return pa.major - pb.major;
+  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
+  if (pa.patch !== pb.patch) return pa.patch - pb.patch;
+  if (pa.prerelease === null && pb.prerelease === null) return 0;
+  if (pa.prerelease === null) return 1;
+  if (pb.prerelease === null) return -1;
+  return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+function isOptedOut() {
+  const raw = process.env.GLASSTRACE_DISABLE_UPGRADE_NOTICE;
+  if (typeof raw !== "string") return false;
+  const trimmed = raw.trim().toLowerCase();
+  return trimmed === "1" || trimmed === "true" || trimmed === "yes";
+}
+function isQuietCiContext() {
+  const stderrIsTty = process.stderr.isTTY === true;
+  if (stderrIsTty) return false;
+  return process.env.CI === "true";
+}
+var MAX_AGENT_FILE_BYTES = 5 * 1024 * 1024;
+function inspectFile(filePath, runningSdkVersion) {
+  let content;
+  try {
+    const stat2 = fs2.statSync(filePath);
+    if (!stat2.isFile()) return "absent";
+    if (stat2.size > MAX_AGENT_FILE_BYTES) return "absent";
+    content = fs2.readFileSync(filePath, "utf-8");
+  } catch {
+    return "absent";
+  }
+  const lines = content.split("\n");
+  let lastStart = null;
+  let foundEnd = false;
+  for (const line of lines) {
+    const parsed = parseStartMarkerLine(line);
+    if (parsed !== null) {
+      lastStart = parsed;
+      continue;
+    }
+    if (lastStart !== null && isEndMarkerLine(line)) {
+      foundEnd = true;
+      break;
+    }
+  }
+  if (lastStart === null || !foundEnd) {
+    return "no-section";
+  }
+  if (lastStart.stamp === null) {
+    return "no-stamp";
+  }
+  const cmp = compareSemver(lastStart.stamp, runningSdkVersion);
+  if (cmp === null) {
+    return "unknown-stamp";
+  }
+  return cmp < 0 ? "stale" : "current";
+}
+function maybeWarnStaleAgentInstructions(options) {
+  try {
+    if (warningEmitted) return;
+    if (typeof process === "undefined" || typeof process.versions?.node !== "string" || typeof process.env !== "object" || process.env === null) {
+      return;
+    }
+    if (isOptedOut()) return;
+    if (isQuietCiContext()) return;
+    if (parseSemver(options.sdkVersion) === null) return;
+    const staleFiles = [];
+    for (const fileName of AGENT_INSTRUCTION_FILES) {
+      const fullPath = path2.join(options.projectRoot, fileName);
+      const state = inspectFile(fullPath, options.sdkVersion);
+      if (state === "stale") {
+        staleFiles.push(fileName);
+      }
+    }
+    if (staleFiles.length === 0) return;
+    const fileList = staleFiles.join(", ");
+    const message = `[glasstrace] Glasstrace managed MCP section in ${fileList} was rendered by an older @glasstrace/sdk; run \`npx glasstrace upgrade-instructions\` to refresh (silence with GLASSTRACE_DISABLE_UPGRADE_NOTICE=1).
+`;
+    warningEmitted = true;
+    if (options.stderrWrite !== void 0) {
+      options.stderrWrite(message);
+      return;
+    }
+    try {
+      process.stderr.write(message);
+    } catch {
+    }
+  } catch {
+  }
+}
+
 // src/register.ts
 function maskKey(key) {
   if (key.length <= 12) return key.slice(0, 4) + "...";
@@ -22751,9 +22958,13 @@ function registerGlasstrace(options) {
       return;
     }
     setCoreState(CoreState.REGISTERING);
+    maybeWarnStaleAgentInstructions({
+      projectRoot: process.cwd(),
+      sdkVersion: "1.5.0"
+    });
     startRuntimeStateWriter({
       projectRoot: process.cwd(),
-      sdkVersion: "1.3.9"
+      sdkVersion: "1.5.0"
     });
     const config2 = resolveConfig(options);
     if (config2.verbose) {
@@ -22920,8 +23131,8 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const healthReport = collectHealthReport("1.3.9");
-  const initResult = await performInit(config2, anonKeyForInit, "1.3.9", healthReport);
+  const healthReport = collectHealthReport("1.5.0");
+  const initResult = await performInit(config2, anonKeyForInit, "1.5.0", healthReport);
   if (generation !== registrationGeneration) return;
   const currentState = getCoreState();
   if (currentState === CoreState.SHUTTING_DOWN || currentState === CoreState.SHUTDOWN) {
@@ -22944,7 +23155,7 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   }
   maybeInstallConsoleCapture();
   if (didLastInitSucceed()) {
-    startHeartbeat(config2, anonKeyForInit, "1.3.9", generation, (newApiKey, accountId) => {
+    startHeartbeat(config2, anonKeyForInit, "1.5.0", generation, (newApiKey, accountId) => {
       setAuthState(AuthState.CLAIMING);
       emitLifecycleEvent("auth:claim_started", { accountId });
       setResolvedApiKey(newApiKey);
@@ -23178,9 +23389,9 @@ function captureError(error48) {
 init_source_map_uploader();
 
 // src/import-graph.ts
-var fs3 = __toESM(require("node:fs/promises"), 1);
+var fs4 = __toESM(require("node:fs/promises"), 1);
 var fsSync2 = __toESM(require("node:fs"), 1);
-var path3 = __toESM(require("node:path"), 1);
+var path4 = __toESM(require("node:path"), 1);
 var crypto3 = __toESM(require("node:crypto"), 1);
 init_dist();
 var MAX_TEST_FILES = 5e3;
@@ -23210,7 +23421,7 @@ function loadCustomTestPatterns(projectRoot) {
     "jest.config.mjs"
   ];
   for (const name of configNames) {
-    const configPath = path3.join(projectRoot, name);
+    const configPath = path4.join(projectRoot, name);
     let content;
     try {
       content = fsSync2.readFileSync(configPath, "utf-8");
@@ -23267,7 +23478,7 @@ async function walkForTests(baseDir, currentDir, results, testPatterns) {
   }
   let entries;
   try {
-    entries = await fs3.readdir(currentDir, { withFileTypes: true });
+    entries = await fs4.readdir(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -23275,14 +23486,14 @@ async function walkForTests(baseDir, currentDir, results, testPatterns) {
     if (results.length >= MAX_TEST_FILES) {
       return;
     }
-    const fullPath = path3.join(currentDir, entry.name);
+    const fullPath = path4.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 = path3.relative(baseDir, fullPath).replace(/\\/g, "/");
+      const relativePath = path4.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);
@@ -23330,9 +23541,9 @@ async function buildImportGraph(projectRoot) {
   const testFiles = await discoverTestFiles(projectRoot);
   const graph = {};
   for (const testFile of testFiles) {
-    const fullPath = path3.join(projectRoot, testFile);
+    const fullPath = path4.join(projectRoot, testFile);
     try {
-      const content = await fs3.readFile(fullPath, "utf-8");
+      const content = await fs4.readFile(fullPath, "utf-8");
       const imports = extractImports(content);
       graph[testFile] = imports;
     } catch {