@glasstrace/sdk 1.0.1 → 1.1.1

package/dist/node-entry.cjs

@@ -17103,6 +17103,7 @@ function firstToken(value) {
 init_dist();
 var GLASSTRACE_DIR = ".glasstrace";
 var ANON_KEY_FILE = "anon_key";
+var CLAIMED_KEY_FILE = "claimed-key";
 var fsPathCache;
 async function loadFsPath() {
   if (fsPathCache !== void 0) return fsPathCache;
@@ -17139,6 +17140,22 @@ async function readAnonKey(projectRoot) {
   }
   return null;
 }
+async function readClaimedKey(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const modules = await loadFsPath();
+  if (!modules) return null;
+  const keyPath = modules.path.join(root, GLASSTRACE_DIR, CLAIMED_KEY_FILE);
+  try {
+    const content = await modules.fs.readFile(keyPath, "utf-8");
+    const trimmed = content.trim();
+    const parsed = DevApiKeySchema.safeParse(trimmed);
+    if (parsed.success) {
+      return parsed.data;
+    }
+  } catch {
+  }
+  return null;
+}
 async function getOrCreateAnonKey(projectRoot) {
   const root = projectRoot ?? process.cwd();
   const existingKey = await readAnonKey(root);
@@ -17475,8 +17492,259 @@ function sleep(ms, scheduler, signal) {
   });
 }
 
-// src/init-client.ts
+// src/mcp-runtime.ts
+var import_node_crypto = require("node:crypto");
+init_dist();
+var MCP_ENDPOINT = "https://api.glasstrace.dev/mcp";
+var fsPathCache2;
+async function loadFsPath2() {
+  if (fsPathCache2 !== void 0) return fsPathCache2;
+  try {
+    const [fs4, path4] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:path")
+    ]);
+    fsPathCache2 = { fs: fs4, path: path4 };
+    return fsPathCache2;
+  } catch {
+    fsPathCache2 = null;
+    return null;
+  }
+}
+function identityFingerprint(token) {
+  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(token).digest("hex")}`;
+}
+function mcpConfigMatches(existingContent, expectedContent) {
+  const trimmedExpected = expectedContent.trim();
+  try {
+    const existingParsed = JSON.parse(existingContent);
+    const expectedParsed = JSON.parse(trimmedExpected);
+    return JSON.stringify(canonicalize(existingParsed)) === JSON.stringify(canonicalize(expectedParsed));
+  } catch {
+  }
+  return existingContent.trim() === trimmedExpected;
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value !== null && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = canonicalize(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function readEnvLocalApiKey(content) {
+  let last = null;
+  const regex = /^\s*GLASSTRACE_API_KEY\s*=\s*(.*)$/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const raw = match[1].trim();
+    if (raw === "") continue;
+    const unquoted = raw.replace(/^(['"])(.*)\1$/, "$2");
+    if (unquoted === "" || unquoted === "your_key_here") continue;
+    last = unquoted;
+  }
+  return last;
+}
+async function resolveEffectiveMcpCredential(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const warnings = [];
+  const envLocalKey = await readEnvLocalDevKey(root, warnings);
+  const claimedKey = envLocalKey === null ? await readClaimedKey(root) : null;
+  const anonKey = await readAnonKey(root);
+  let effective = null;
+  if (envLocalKey !== null) {
+    effective = { source: "env-local", key: envLocalKey };
+  } else if (claimedKey !== null) {
+    effective = { source: "claimed-key", key: claimedKey };
+    warnings.push("claimed-key-only");
+  } else if (anonKey !== null) {
+    effective = { source: "anon", key: anonKey };
+  }
+  return { effective, anonKey, warnings };
+}
+async function readEnvLocalDevKey(root, warnings) {
+  const modules = await loadFsPath2();
+  if (!modules) return null;
+  const envPath = modules.path.join(root, ".env.local");
+  let content;
+  try {
+    content = await modules.fs.readFile(envPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const raw = readEnvLocalApiKey(content);
+  if (raw === null) return null;
+  const parsed = DevApiKeySchema.safeParse(raw);
+  if (!parsed.success) {
+    warnings.push("malformed-env-local");
+    return null;
+  }
+  return parsed.data;
+}
+var MCP_MARKER_FILE = "mcp-connected";
 var GLASSTRACE_DIR2 = ".glasstrace";
+async function readMcpMarker(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const modules = await loadFsPath2();
+  if (!modules) return { status: "absent" };
+  const markerPath = modules.path.join(root, GLASSTRACE_DIR2, MCP_MARKER_FILE);
+  let content;
+  try {
+    content = await modules.fs.readFile(markerPath, "utf-8");
+  } catch {
+    return { status: "absent" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { status: "corrupted" };
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return { status: "corrupted" };
+  }
+  const obj = parsed;
+  const version2 = obj["version"];
+  if (version2 === void 0) {
+    const keyHash = obj["keyHash"];
+    if (typeof keyHash !== "string" || keyHash === "") {
+      return { status: "corrupted" };
+    }
+    return {
+      status: "valid",
+      credentialSource: "anon",
+      credentialHash: keyHash
+    };
+  }
+  if (version2 === 2) {
+    const source = obj["credentialSource"];
+    const hash2 = obj["credentialHash"];
+    if (source !== "env-local" && source !== "claimed-key" && source !== "anon" || typeof hash2 !== "string" || hash2 === "") {
+      return { status: "corrupted" };
+    }
+    return {
+      status: "valid",
+      credentialSource: source,
+      credentialHash: hash2
+    };
+  }
+  if (typeof version2 === "number" && version2 > 2) {
+    return { status: "unknown-version" };
+  }
+  return { status: "corrupted" };
+}
+async function writeMcpMarker(projectRoot, target) {
+  const modules = await loadFsPath2();
+  if (!modules) return false;
+  const dirPath = modules.path.join(projectRoot, GLASSTRACE_DIR2);
+  const markerPath = modules.path.join(dirPath, MCP_MARKER_FILE);
+  const state = await readMcpMarker(projectRoot);
+  if (state.status === "valid" && state.credentialSource === target.credentialSource && state.credentialHash === target.credentialHash) {
+    return false;
+  }
+  await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
+  const body = JSON.stringify(
+    {
+      version: 2,
+      credentialSource: target.credentialSource,
+      credentialHash: target.credentialHash,
+      configuredAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    null,
+    2
+  );
+  await modules.fs.writeFile(markerPath, body, { mode: 384 });
+  await modules.fs.chmod(markerPath, 384);
+  return true;
+}
+var MCP_CONFIG_FILE = "mcp.json";
+var refreshNudgeEmitted = false;
+function emitRefreshNudge(persistedSource) {
+  if (refreshNudgeEmitted) return;
+  refreshNudgeEmitted = true;
+  try {
+    if (persistedSource === "claimed-key") {
+      process.stderr.write(
+        "[glasstrace] MCP config refreshed for the new credential. Copy .glasstrace/claimed-key into .env.local so Codex can pick it up on next restart.\n"
+      );
+    } else {
+      process.stderr.write(
+        "[glasstrace] MCP config refreshed for the new credential.\n"
+      );
+    }
+  } catch {
+  }
+}
+function genericMcpConfigContent(endpoint, bearer) {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        glasstrace: {
+          url: endpoint,
+          headers: {
+            Authorization: `Bearer ${bearer}`
+          }
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+async function refreshGenericMcpConfigAtRuntime(projectRoot, effective, anonKeyOnDisk) {
+  if (effective === null || effective.source === "anon") {
+    return { action: "skipped-anon-source" };
+  }
+  if (anonKeyOnDisk === null) {
+    return { action: "absent" };
+  }
+  const modules = await loadFsPath2();
+  if (!modules) return { action: "absent" };
+  const dirPath = modules.path.join(projectRoot, GLASSTRACE_DIR2);
+  const configPath = modules.path.join(dirPath, MCP_CONFIG_FILE);
+  const tmpPath = configPath + ".tmp";
+  let existing;
+  try {
+    existing = await modules.fs.readFile(configPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return { action: "absent" };
+    }
+    return { action: "preserved" };
+  }
+  const expectedAnon = genericMcpConfigContent(MCP_ENDPOINT, anonKeyOnDisk);
+  if (!mcpConfigMatches(existing, expectedAnon)) {
+    return { action: "preserved" };
+  }
+  const replacement = genericMcpConfigContent(MCP_ENDPOINT, effective.key);
+  try {
+    await modules.fs.writeFile(tmpPath, replacement, { mode: 384 });
+    await modules.fs.chmod(tmpPath, 384);
+    await modules.fs.rename(tmpPath, configPath);
+    await writeMcpMarker(projectRoot, {
+      credentialSource: effective.source,
+      credentialHash: identityFingerprint(effective.key)
+    });
+  } catch {
+    try {
+      await modules.fs.unlink(tmpPath);
+    } catch {
+    }
+    return { action: "preserved" };
+  }
+  emitRefreshNudge(effective.source);
+  return { action: "rewrote" };
+}
+
+// src/init-client.ts
+var GLASSTRACE_DIR3 = ".glasstrace";
 var CONFIG_FILE = "config";
 var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
 var INIT_TIMEOUT_MS = 1e4;
@@ -17513,7 +17781,7 @@ function loadCachedConfig(projectRoot) {
   const modules = loadFsSyncOrNull();
   if (!modules) return null;
   const root = projectRoot ?? process.cwd();
-  const configPath = modules.join(root, GLASSTRACE_DIR2, CONFIG_FILE);
+  const configPath = modules.join(root, GLASSTRACE_DIR3, CONFIG_FILE);
   try {
     const content = modules.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -17539,7 +17807,7 @@ async function saveCachedConfig(response, projectRoot) {
   const modules = await loadFsPathAsync();
   if (!modules) return;
   const root = projectRoot ?? process.cwd();
-  const dirPath = modules.path.join(root, GLASSTRACE_DIR2);
+  const dirPath = modules.path.join(root, GLASSTRACE_DIR3);
   const configPath = modules.path.join(dirPath, CONFIG_FILE);
   const tmpPath = `${configPath}.tmp`;
   try {
@@ -17665,11 +17933,11 @@ async function writeClaimedKey(newApiKey, projectRoot) {
         );
       } catch {
       }
-      return;
+      return { persisted: "env-local" };
     }
     let claimedKeyWritten = false;
     try {
-      const dirPath = modules.path.join(root, GLASSTRACE_DIR2);
+      const dirPath = modules.path.join(root, GLASSTRACE_DIR3);
       await modules.fs.mkdir(dirPath, { recursive: true, mode: 448 });
       await modules.fs.chmod(dirPath, 448);
       const claimedKeyPath = modules.path.join(dirPath, "claimed-key");
@@ -17688,7 +17956,7 @@ async function writeClaimedKey(newApiKey, projectRoot) {
         );
       } catch {
       }
-      return;
+      return { persisted: "claimed-key" };
     }
   }
   try {
@@ -17697,6 +17965,7 @@ async function writeClaimedKey(newApiKey, projectRoot) {
     );
   } catch {
   }
+  return { persisted: "none" };
 }
 async function performInit(config2, anonKey, sdkVersion, healthReport) {
   lastInitSucceeded = false;
@@ -17728,10 +17997,23 @@ async function performInit(config2, anonKey, sdkVersion, healthReport) {
       lastInitSucceeded = true;
       await saveCachedConfig(result);
       if (result.claimResult) {
+        let persisted = "none";
         try {
-          await writeClaimedKey(result.claimResult.newApiKey);
+          const w = await writeClaimedKey(result.claimResult.newApiKey);
+          persisted = w.persisted;
         } catch {
         }
+        if (persisted !== "none") {
+          try {
+            const resolved = await resolveEffectiveMcpCredential();
+            await refreshGenericMcpConfigAtRuntime(
+              process.cwd(),
+              resolved.effective,
+              resolved.anonKey
+            );
+          } catch {
+          }
+        }
         return { claimResult: result.claimResult };
       }
       return null;
@@ -18608,7 +18890,7 @@ function getStringFromEnv(key) {
 }
 
 // ../../node_modules/@opentelemetry/core/build/esm/version.js
-var VERSION2 = "2.6.1";
+var VERSION2 = "2.7.0";
 
 // ../../node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
 var ATTR_EXCEPTION_MESSAGE = "exception.message";
@@ -18772,6 +19054,9 @@ function mergeTwoObjects(one, two, level = 0, objects) {
       const keys = Object.keys(two);
       for (let i = 0, j = keys.length; i < j; i++) {
         const key = keys[i];
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          continue;
+        }
         result[key] = takeValue(two[key]);
       }
     }
@@ -18784,6 +19069,9 @@ function mergeTwoObjects(one, two, level = 0, objects) {
       const keys = Object.keys(two);
       for (let i = 0, j = keys.length; i < j; i++) {
         const key = keys[i];
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          continue;
+        }
         const twoValue = two[key];
         if (isPrimitive(twoValue)) {
           if (typeof twoValue === "undefined") {
@@ -18995,95 +19283,6 @@ function createOtlpExportDelegate(components, settings) {
   return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
 }
 
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
-function createResource(resource, encoder) {
-  const result = {
-    attributes: toAttributes(resource.attributes, encoder),
-    droppedAttributesCount: 0
-  };
-  const schemaUrl = resource.schemaUrl;
-  if (schemaUrl && schemaUrl !== "")
-    result.schemaUrl = schemaUrl;
-  return result;
-}
-function createInstrumentationScope(scope) {
-  return {
-    name: scope.name,
-    version: scope.version
-  };
-}
-function toAttributes(attributes, encoder) {
-  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
-}
-function toKeyValue(key, value, encoder) {
-  return {
-    key,
-    value: toAnyValue(value, encoder)
-  };
-}
-function toAnyValue(value, encoder) {
-  const t = typeof value;
-  if (t === "string")
-    return { stringValue: value };
-  if (t === "number") {
-    if (!Number.isInteger(value))
-      return { doubleValue: value };
-    return { intValue: value };
-  }
-  if (t === "boolean")
-    return { boolValue: value };
-  if (value instanceof Uint8Array)
-    return { bytesValue: encoder.encodeUint8Array(value) };
-  if (Array.isArray(value)) {
-    const values = new Array(value.length);
-    for (let i = 0; i < value.length; i++) {
-      values[i] = toAnyValue(value[i], encoder);
-    }
-    return { arrayValue: { values } };
-  }
-  if (t === "object" && value != null) {
-    const keys = Object.keys(value);
-    const values = new Array(keys.length);
-    for (let i = 0; i < keys.length; i++) {
-      values[i] = {
-        key: keys[i],
-        value: toAnyValue(value[keys[i]], encoder)
-      };
-    }
-    return { kvlistValue: { values } };
-  }
-  return {};
-}
-
-// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
-function hrTimeToNanos(hrTime2) {
-  const NANOSECONDS = BigInt(1e9);
-  return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1]));
-}
-function encodeAsString(hrTime2) {
-  const nanos = hrTimeToNanos(hrTime2);
-  return nanos.toString();
-}
-var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
-function identity(value) {
-  return value;
-}
-var JSON_ENCODER = {
-  encodeHrTime: encodeTimestamp,
-  encodeSpanContext: identity,
-  encodeOptionalSpanContext: identity,
-  encodeUint8Array: (bytes) => {
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(bytes).toString("base64");
-    }
-    const chars = new Array(bytes.length);
-    for (let i = 0; i < bytes.length; i++) {
-      chars[i] = String.fromCharCode(bytes[i]);
-    }
-    return btoa(chars.join(""));
-  }
-};
-
 // ../../node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
 init_esm();
 
@@ -19228,6 +19427,95 @@ function mergeSchemaUrl(old, updating) {
   return void 0;
 }
 
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
+function createResource(resource, encoder) {
+  const result = {
+    attributes: toAttributes(resource.attributes, encoder),
+    droppedAttributesCount: 0
+  };
+  const schemaUrl = resource.schemaUrl;
+  if (schemaUrl && schemaUrl !== "")
+    result.schemaUrl = schemaUrl;
+  return result;
+}
+function createInstrumentationScope(scope) {
+  return {
+    name: scope.name,
+    version: scope.version
+  };
+}
+function toAttributes(attributes, encoder) {
+  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
+}
+function toKeyValue(key, value, encoder) {
+  return {
+    key,
+    value: toAnyValue(value, encoder)
+  };
+}
+function toAnyValue(value, encoder) {
+  const t = typeof value;
+  if (t === "string")
+    return { stringValue: value };
+  if (t === "number") {
+    if (!Number.isInteger(value))
+      return { doubleValue: value };
+    return { intValue: value };
+  }
+  if (t === "boolean")
+    return { boolValue: value };
+  if (value instanceof Uint8Array)
+    return { bytesValue: encoder.encodeUint8Array(value) };
+  if (Array.isArray(value)) {
+    const values = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      values[i] = toAnyValue(value[i], encoder);
+    }
+    return { arrayValue: { values } };
+  }
+  if (t === "object" && value != null) {
+    const keys = Object.keys(value);
+    const values = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      values[i] = {
+        key: keys[i],
+        value: toAnyValue(value[keys[i]], encoder)
+      };
+    }
+    return { kvlistValue: { values } };
+  }
+  return {};
+}
+
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+function hrTimeToNanos(hrTime2) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1]));
+}
+function encodeAsString(hrTime2) {
+  const nanos = hrTimeToNanos(hrTime2);
+  return nanos.toString();
+}
+var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
+function identity(value) {
+  return value;
+}
+var JSON_ENCODER = {
+  encodeHrTime: encodeTimestamp,
+  encodeSpanContext: identity,
+  encodeOptionalSpanContext: identity,
+  encodeUint8Array: (bytes) => {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(bytes).toString("base64");
+    }
+    const chars = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      chars[i] = String.fromCharCode(bytes[i]);
+    }
+    return btoa(chars.join(""));
+  }
+};
+
 // ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
 var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
 var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
@@ -19342,6 +19630,7 @@ function spanRecordsToResourceSpans(readableSpans, encoder) {
 }
 
 // ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
+init_esm();
 var JsonTraceSerializer = {
   serializeRequest: (arg) => {
     const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
@@ -19353,7 +19642,12 @@ var JsonTraceSerializer = {
       return {};
     }
     const decoder = new TextDecoder();
-    return JSON.parse(decoder.decode(arg));
+    try {
+      return JSON.parse(decoder.decode(arg));
+    } catch (err) {
+      diag2.warn(`Failed to parse trace export response: ${err.message}. Returning empty response`);
+      return {};
+    }
   }
 };
 
@@ -19464,10 +19758,11 @@ function parseRetryAfterToMills(retryAfter) {
 }
 
 // ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js
-var VERSION3 = "0.214.0";
+var VERSION3 = "0.215.0";
 
 // ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
 var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION3}`;
+var MAX_RESPONSE_BODY_SIZE = 4 * 1024 * 1024;
 function sendWithHttp(request, url2, headers, compression, userAgent, agent, data, timeoutMillis) {
   return new Promise((resolve3) => {
     const parsedUrl = new URL(url2);
@@ -19486,7 +19781,17 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
     };
     const req = request(options, (res) => {
       const responseData = [];
-      res.on("data", (chunk) => responseData.push(chunk));
+      let responseSize = 0;
+      res.on("data", (chunk) => {
+        responseSize += chunk.length;
+        if (responseSize > MAX_RESPONSE_BODY_SIZE) {
+          const sizeError = new Error(`OTLP export response body exceeded size limit of ${MAX_RESPONSE_BODY_SIZE} bytes`);
+          resolve3({ status: "failure", error: sizeError });
+          res.destroy();
+          return;
+        }
+        responseData.push(chunk);
+      });
       res.on("end", () => {
         if (res.statusCode && res.statusCode <= 299) {
           resolve3({
@@ -20689,7 +20994,7 @@ function samplingDecisionToString(decision) {
 }
 
 // ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/version.js
-var VERSION4 = "2.6.1";
+var VERSION4 = "2.7.0";
 
 // ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
 var Tracer = class {
@@ -21456,24 +21761,24 @@ function detectSentry() {
 }
 
 // src/otel-config.ts
-var _resolvedApiKey = API_KEY_PENDING;
-var _activeExporter = null;
-var _additionalExporters = [];
-var _injectedProcessor = null;
+var resolvedApiKey = API_KEY_PENDING;
+var activeExporter = null;
+var additionalExporters = [];
+var injectedProcessor = null;
 function setResolvedApiKey(key) {
-  _resolvedApiKey = key;
+  resolvedApiKey = key;
 }
 function getResolvedApiKey() {
-  return _resolvedApiKey;
+  return resolvedApiKey;
 }
 function notifyApiKeyResolved() {
-  _activeExporter?.notifyKeyResolved();
-  for (const exporter of _additionalExporters) {
+  activeExporter?.notifyKeyResolved();
+  for (const exporter of additionalExporters) {
     exporter.notifyKeyResolved();
   }
 }
 function registerExporterForKeyNotification(exporter) {
-  _additionalExporters.push(exporter);
+  additionalExporters.push(exporter);
 }
 async function tryImport(moduleId) {
   try {
@@ -21516,7 +21821,7 @@ async function runCoexistencePath(existingProvider, config2) {
     return;
   }
   if (result !== null) {
-    _injectedProcessor = result.processor;
+    injectedProcessor = result.processor;
     if (config2.verbose) {
       sdkLog(
         "info",
@@ -21527,8 +21832,8 @@ async function runCoexistencePath(existingProvider, config2) {
       name: "coexistence-flush",
       priority: 5,
       fn: async () => {
-        if (_injectedProcessor) {
-          await _injectedProcessor.forceFlush();
+        if (injectedProcessor) {
+          await injectedProcessor.forceFlush();
         }
       }
     });
@@ -21564,7 +21869,7 @@ async function runRegistrationPath(config2, sessionManager) {
     createDelegate: createOtlpExporter,
     verbose: config2.verbose
   });
-  _activeExporter = glasstraceExporter;
+  activeExporter = glasstraceExporter;
   const vercelOtel = await tryImport("@vercel/otel");
   if (vercelOtel && typeof vercelOtel.registerOTel === "function") {
     const otelConfig = {
@@ -21897,7 +22202,7 @@ function registerGlasstrace(options) {
     setCoreState(CoreState.REGISTERING);
     startRuntimeStateWriter({
       projectRoot: process.cwd(),
-      sdkVersion: "1.0.1"
+      sdkVersion: "1.1.1"
     });
     const config2 = resolveConfig(options);
     if (config2.verbose) {
@@ -22063,8 +22368,8 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   if (config2.verbose) {
     console.info("[glasstrace] Background init firing.");
   }
-  const healthReport = collectHealthReport("1.0.1");
-  const initResult = await performInit(config2, anonKeyForInit, "1.0.1", healthReport);
+  const healthReport = collectHealthReport("1.1.1");
+  const initResult = await performInit(config2, anonKeyForInit, "1.1.1", healthReport);
   if (generation !== registrationGeneration) return;
   const currentState = getCoreState();
   if (currentState === CoreState.SHUTTING_DOWN || currentState === CoreState.SHUTDOWN) {
@@ -22087,7 +22392,7 @@ async function backgroundInit(config2, anonKeyForInit, generation) {
   }
   maybeInstallConsoleCapture();
   if (didLastInitSucceed()) {
-    startHeartbeat(config2, anonKeyForInit, "1.0.1", generation, (newApiKey, accountId) => {
+    startHeartbeat(config2, anonKeyForInit, "1.1.1", generation, (newApiKey, accountId) => {
       setAuthState(AuthState.CLAIMING);
       emitLifecycleEvent("auth:claim_started", { accountId });
       setResolvedApiKey(newApiKey);