@glasstrace/sdk 1.1.1 → 1.1.3

package/dist/{chunk-ZRDQ6ZKI.js → chunk-TWHCJKRS.js}

@@ -1,426 +1,55 @@
 import {
-  NEXT_CONFIG_NAMES
-} from "./chunk-7SZQN6IU.js";
-import {
+  atomicWriteFileSync,
+  atomicWriteFileSyncWithTmp,
+  fsyncParentDirSync,
   isDevApiKey,
-  readEnvLocalApiKey
-} from "./chunk-P22UQ2OJ.js";
+  readEnvLocalApiKey,
+  writeAndFsyncTempSync
+} from "./chunk-TWTWRJ25.js";
 import {
   AnonApiKeySchema
 } from "./chunk-X5MAXP5T.js";
+import {
+  NEXT_CONFIG_NAMES
+} from "./chunk-NB7GJE4S.js";
 
 // src/cli/uninit.ts
-import * as fs3 from "node:fs";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 
-// src/cli/scaffolder.ts
+// src/cli/discovery-file.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
-function hasRegisterGlasstraceCall(content) {
-  return content.split("\n").some((line) => {
-    const uncommented = line.replace(/\/\/.*$/, "");
-    return /\bregisterGlasstrace\s*\(/.test(uncommented);
-  });
-}
-function injectRegisterGlasstrace(content) {
-  if (hasRegisterGlasstraceCall(content)) {
-    return { injected: false, content };
-  }
-  const registerFnRegex = /export\s+(?:async\s+)?function\s+register\s*\([^)]*\)\s*\{/;
-  const match = registerFnRegex.exec(content);
-  if (!match) {
-    return { injected: false, content };
-  }
-  const afterBrace = content.slice(match.index + match[0].length);
-  const indentMatch = /\n([ \t]+)/.exec(afterBrace);
-  const indent = indentMatch ? indentMatch[1] : "  ";
-  const importLine = 'import { registerGlasstrace } from "@glasstrace/sdk";\n';
-  const hasGlasstraceImport = content.includes("@glasstrace/sdk");
-  const insertPoint = match.index + match[0].length;
-  const callInjection = `
-${indent}// Glasstrace must be registered before other instrumentation
-${indent}registerGlasstrace();
-`;
-  let modified;
-  if (hasGlasstraceImport) {
-    const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']@glasstrace\/sdk["']/;
-    const importMatch = importRegex.exec(content);
-    if (importMatch) {
-      const specifiers = importMatch[1];
-      const alreadyImported = specifiers.split(",").some((s) => s.trim() === "registerGlasstrace");
-      if (alreadyImported) {
-        modified = content.slice(0, insertPoint) + callInjection + content.slice(insertPoint);
-      } else {
-        const existingImports = specifiers.trimEnd();
-        const separator = existingImports.endsWith(",") ? " " : ", ";
-        const updatedImport = `import { ${existingImports.trim()}${separator}registerGlasstrace } from "@glasstrace/sdk"`;
-        modified = content.replace(importMatch[0], updatedImport);
-        const newMatch = registerFnRegex.exec(modified);
-        if (newMatch) {
-          const newInsertPoint = newMatch.index + newMatch[0].length;
-          modified = modified.slice(0, newInsertPoint) + callInjection + modified.slice(newInsertPoint);
-        }
-      }
-    } else {
-      modified = importLine + content;
-      const newMatch = registerFnRegex.exec(modified);
-      if (newMatch) {
-        const newInsertPoint = newMatch.index + newMatch[0].length;
-        modified = modified.slice(0, newInsertPoint) + callInjection + modified.slice(newInsertPoint);
-      }
-    }
-  } else {
-    modified = importLine + content.slice(0, insertPoint) + callInjection + content.slice(insertPoint);
-  }
-  return { injected: true, content: modified };
-}
-var INSTRUMENTATION_FILENAMES = [
-  "instrumentation.ts",
-  "instrumentation.js",
-  "instrumentation.mjs"
-];
-function resolveInstrumentationTarget(projectRoot) {
-  const rootExisting = [];
-  const srcExisting = [];
-  for (const name of INSTRUMENTATION_FILENAMES) {
-    const rootPath = path.join(projectRoot, name);
-    if (isRegularFile(rootPath)) {
-      rootExisting.push(rootPath);
-    }
-    const srcPath = path.join(projectRoot, "src", name);
-    if (isRegularFile(srcPath)) {
-      srcExisting.push(srcPath);
-    }
-  }
-  const existing = [...rootExisting, ...srcExisting];
-  if (rootExisting.length > 0 && srcExisting.length > 0) {
-    return {
-      target: null,
-      layout: null,
-      existing,
-      rootExisting,
-      srcExisting,
-      conflict: true
-    };
-  }
-  if (srcExisting.length > 0) {
-    return {
-      target: srcExisting[0],
-      layout: "src",
-      existing,
-      rootExisting,
-      srcExisting,
-      conflict: false
-    };
-  }
-  if (rootExisting.length > 0) {
-    return {
-      target: rootExisting[0],
-      layout: "root",
-      existing,
-      rootExisting,
-      srcExisting,
-      conflict: false
-    };
-  }
-  const srcDir = path.join(projectRoot, "src");
-  const layout = isDirectory(srcDir) ? "src" : "root";
-  const target = layout === "src" ? path.join(projectRoot, "src", "instrumentation.ts") : path.join(projectRoot, "instrumentation.ts");
-  return {
-    target,
-    layout,
-    existing,
-    rootExisting,
-    srcExisting,
-    conflict: false
-  };
-}
-function isDirectory(p) {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isRegularFile(p) {
-  try {
-    const stat = fs.lstatSync(p);
-    if (stat.isSymbolicLink()) {
-      return fs.statSync(p).isFile();
-    }
-    return stat.isFile();
-  } catch {
-    return false;
-  }
-}
-function appendRegisterFunction(content) {
-  const importLine = 'import { registerGlasstrace } from "@glasstrace/sdk";\n';
-  const functionBlock = "\nexport async function register() {\n  // Glasstrace must be registered before Prisma instrumentation\n  // to ensure all ORM spans are captured correctly.\n  // If you use @prisma/instrumentation, import it after this call.\n  registerGlasstrace();\n}\n";
-  let withImport = content;
-  const hasGlasstraceImport = content.includes("@glasstrace/sdk");
-  if (!hasGlasstraceImport) {
-    withImport = importLine + content;
-  } else {
-    const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']@glasstrace\/sdk["']/;
-    const importMatch = importRegex.exec(content);
-    if (importMatch) {
-      const specifiers = importMatch[1];
-      const alreadyImported = specifiers.split(",").some((s) => s.trim() === "registerGlasstrace");
-      if (!alreadyImported) {
-        const existingImports = specifiers.trimEnd();
-        const separator = existingImports.endsWith(",") ? " " : ", ";
-        const updatedImport = `import { ${existingImports.trim()}${separator}registerGlasstrace } from "@glasstrace/sdk"`;
-        withImport = content.replace(importMatch[0], updatedImport);
-      }
-    } else {
-      withImport = importLine + content;
-    }
-  }
-  const trailingNewline = withImport.endsWith("\n") ? "" : "\n";
-  return withImport + trailingNewline + functionBlock;
-}
-async function defaultInstrumentationPrompt(question, defaultValue) {
-  if (!process.stdin.isTTY) return defaultValue;
-  const readline = await import("node:readline");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
-    rl.question(question + suffix, (answer) => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      if (trimmed === "") {
-        resolve(defaultValue);
-        return;
-      }
-      resolve(trimmed === "y" || trimmed === "yes");
-    });
-  });
-}
-async function scaffoldInstrumentation(projectRoot, options = {}) {
-  const target = resolveInstrumentationTarget(projectRoot);
-  if (target.conflict) {
-    return {
-      action: "conflict",
-      // Point the user at the `src/` variant — modern Next.js apps with a
-      // `src/` directory load from there, so that's the merge target. The
-      // competing path is reported separately for the error message.
-      filePath: target.srcExisting[0],
-      conflictingPath: target.rootExisting[0]
-    };
-  }
-  const filePath = target.target;
-  const layout = target.layout;
-  if (filePath === null || layout === null) {
-    return { action: "unrecognized" };
-  }
-  const force = options.force === true;
-  const prompt = options.prompt ?? defaultInstrumentationPrompt;
-  if (!fs.existsSync(filePath)) {
-    const content = `import { registerGlasstrace } from "@glasstrace/sdk";
-
-export async function register() {
-  // Glasstrace must be registered before Prisma instrumentation
-  // to ensure all ORM spans are captured correctly.
-  // If you use @prisma/instrumentation, import it after this call.
-  registerGlasstrace();
-}
-`;
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content, "utf-8");
-    return { action: "created", filePath, layout };
-  }
-  const existing = fs.readFileSync(filePath, "utf-8");
-  if (hasRegisterGlasstraceCall(existing)) {
-    return { action: "already-registered", filePath, layout };
-  }
-  if (!force) {
-    const approved = await prompt(
-      `Merge registerGlasstrace() into ${path.relative(projectRoot, filePath)}?`,
-      false
-    );
-    if (!approved) {
-      return { action: "skipped", filePath, layout };
-    }
-  }
-  const injectResult = injectRegisterGlasstrace(existing);
-  if (injectResult.injected) {
-    fs.writeFileSync(filePath, injectResult.content, "utf-8");
-    return { action: "injected", filePath, layout };
-  }
-  const appended = appendRegisterFunction(existing);
-  fs.writeFileSync(filePath, appended, "utf-8");
-  return { action: "appended", filePath, layout };
-}
-async function scaffoldNextConfig(projectRoot) {
-  let configPath;
-  let configName;
-  for (const name of NEXT_CONFIG_NAMES) {
-    const candidate = path.join(projectRoot, name);
-    if (fs.existsSync(candidate)) {
-      configPath = candidate;
-      configName = name;
-      break;
-    }
-  }
-  if (configPath === void 0 || configName === void 0) {
-    return null;
-  }
-  const existing = fs.readFileSync(configPath, "utf-8");
-  if (existing.trim().length === 0) {
-    return { modified: false, reason: "empty-file" };
-  }
-  if (existing.includes("withGlasstraceConfig")) {
-    return { modified: false, reason: "already-wrapped" };
-  }
-  const isESM = configName.endsWith(".ts") || configName.endsWith(".mjs");
-  if (isESM) {
-    const importLine = 'import { withGlasstraceConfig } from "@glasstrace/sdk";\n';
-    const wrapResult2 = wrapExport(existing);
-    if (!wrapResult2.wrapped) {
-      return { modified: false, reason: "no-export" };
-    }
-    const modified2 = importLine + "\n" + wrapResult2.content;
-    fs.writeFileSync(configPath, modified2, "utf-8");
-    return { modified: true };
-  }
-  const requireLine = 'const { withGlasstraceConfig } = require("@glasstrace/sdk");\n';
-  const wrapResult = wrapCJSExport(existing);
-  if (!wrapResult.wrapped) {
-    return { modified: false, reason: "no-export" };
-  }
-  const modified = requireLine + "\n" + wrapResult.content;
-  fs.writeFileSync(configPath, modified, "utf-8");
-  return { modified: true };
-}
-function wrapExport(content) {
-  const marker = "export default";
-  const idx = content.lastIndexOf(marker);
-  if (idx === -1) {
-    return { content, wrapped: false };
-  }
-  const preamble = content.slice(0, idx);
-  const exprRaw = content.slice(idx + marker.length);
-  const expr = exprRaw.trim().replace(/;?\s*$/, "");
-  if (expr.length === 0) {
-    return { content, wrapped: false };
-  }
-  return {
-    content: preamble + `export default withGlasstraceConfig(${expr});
-`,
-    wrapped: true
-  };
-}
-function wrapCJSExport(content) {
-  const cjsMarker = "module.exports";
-  const cjsIdx = content.lastIndexOf(cjsMarker);
-  if (cjsIdx === -1) {
-    return { content, wrapped: false };
-  }
-  const preamble = content.slice(0, cjsIdx);
-  const afterMarker = content.slice(cjsIdx + cjsMarker.length);
-  const eqMatch = /^\s*=\s*/.exec(afterMarker);
-  if (!eqMatch) {
-    return { content, wrapped: false };
-  }
-  const exprRaw = afterMarker.slice(eqMatch[0].length);
-  const expr = exprRaw.trim().replace(/;?\s*$/, "");
-  if (expr.length === 0) {
-    return { content, wrapped: false };
-  }
-  return {
-    content: preamble + `module.exports = withGlasstraceConfig(${expr});
-`,
-    wrapped: true
-  };
-}
-async function scaffoldEnvLocal(projectRoot) {
-  const filePath = path.join(projectRoot, ".env.local");
-  if (fs.existsSync(filePath)) {
-    const existing = fs.readFileSync(filePath, "utf-8");
-    if (/^\s*#?\s*GLASSTRACE_API_KEY\s*=/m.test(existing)) {
-      return false;
-    }
-    const separator = existing.endsWith("\n") ? "" : "\n";
-    fs.writeFileSync(filePath, existing + separator + "# GLASSTRACE_API_KEY=your_key_here\n", "utf-8");
-    return true;
-  }
-  fs.writeFileSync(filePath, "# GLASSTRACE_API_KEY=your_key_here\n", "utf-8");
-  return true;
-}
-async function addCoverageMapEnv(projectRoot) {
-  const filePath = path.join(projectRoot, ".env.local");
-  if (!fs.existsSync(filePath)) {
-    fs.writeFileSync(filePath, "GLASSTRACE_COVERAGE_MAP=true\n", "utf-8");
-    return true;
-  }
-  const existing = fs.readFileSync(filePath, "utf-8");
-  const keyRegex = /^(\s*GLASSTRACE_COVERAGE_MAP\s*=\s*)(.*)$/m;
-  const keyMatch = keyRegex.exec(existing);
-  if (keyMatch) {
-    const currentValue = keyMatch[2].trim();
-    if (currentValue === "true") {
-      return false;
-    }
-    const updated = existing.replace(keyRegex, `${keyMatch[1]}true`);
-    fs.writeFileSync(filePath, updated, "utf-8");
-    return true;
-  }
-  const separator = existing.endsWith("\n") ? "" : "\n";
-  fs.writeFileSync(filePath, existing + separator + "GLASSTRACE_COVERAGE_MAP=true\n", "utf-8");
-  return true;
-}
-async function scaffoldGitignore(projectRoot) {
-  const filePath = path.join(projectRoot, ".gitignore");
-  if (fs.existsSync(filePath)) {
-    const existing = fs.readFileSync(filePath, "utf-8");
-    const lines = existing.split("\n").map((l) => l.trim());
-    if (lines.includes(".glasstrace/")) {
-      return false;
-    }
-    const separator = existing.endsWith("\n") ? "" : "\n";
-    fs.writeFileSync(filePath, existing + separator + ".glasstrace/\n", "utf-8");
-    return true;
-  }
-  fs.writeFileSync(filePath, ".glasstrace/\n", "utf-8");
-  return true;
-}
-
-// src/cli/discovery-file.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
 var WELL_KNOWN_GLASSTRACE_PATH = ".well-known/glasstrace.json";
 var DISCOVERY_FILE_VERSION = 1;
 function resolveStaticRoot(projectRoot) {
   if (isSvelteKitProject(projectRoot)) {
     return {
-      absolutePath: path2.join(projectRoot, "static"),
+      absolutePath: path.join(projectRoot, "static"),
       layout: "static"
     };
   }
   return {
-    absolutePath: path2.join(projectRoot, "public"),
+    absolutePath: path.join(projectRoot, "public"),
     layout: "public"
   };
 }
 function isSvelteKitProject(projectRoot) {
-  const pkgPath = path2.join(projectRoot, "package.json");
+  const pkgPath = path.join(projectRoot, "package.json");
   let isEsm = false;
   try {
-    const pkgContent = fs2.readFileSync(pkgPath, "utf-8");
+    const pkgContent = fs.readFileSync(pkgPath, "utf-8");
     const parsed = JSON.parse(pkgContent);
     isEsm = parsed.type === "module";
   } catch {
     return false;
   }
   if (!isEsm) return false;
-  const svelteConfigJs = path2.join(projectRoot, "svelte.config.js");
-  const svelteConfigTs = path2.join(projectRoot, "svelte.config.ts");
-  const appHtml = path2.join(projectRoot, "src", "app.html");
-  return fs2.existsSync(svelteConfigJs) || fs2.existsSync(svelteConfigTs) || fs2.existsSync(appHtml);
+  const svelteConfigJs = path.join(projectRoot, "svelte.config.js");
+  const svelteConfigTs = path.join(projectRoot, "svelte.config.ts");
+  const appHtml = path.join(projectRoot, "src", "app.html");
+  return fs.existsSync(svelteConfigJs) || fs.existsSync(svelteConfigTs) || fs.existsSync(appHtml);
 }
 function relativeDiscoveryPath(layout) {
   const rootDir = layout === "static" ? "static" : "public";
@@ -429,7 +58,7 @@ function relativeDiscoveryPath(layout) {
 function readExistingDiscoveryFile(filePath) {
   let raw;
   try {
-    raw = fs2.readFileSync(filePath, "utf-8");
+    raw = fs.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -468,11 +97,11 @@ function serializeDiscoveryPayload(key, extras) {
 }
 function writeDiscoveryFile(projectRoot, anonKey) {
   const { absolutePath: staticRoot, layout } = resolveStaticRoot(projectRoot);
-  const wellKnownDir = path2.join(staticRoot, ".well-known");
-  const filePath = path2.join(wellKnownDir, "glasstrace.json");
+  const wellKnownDir = path.join(staticRoot, ".well-known");
+  const filePath = path.join(wellKnownDir, "glasstrace.json");
   let existingAction;
   let extras = {};
-  if (fs2.existsSync(filePath)) {
+  if (fs.existsSync(filePath)) {
     const existing = readExistingDiscoveryFile(filePath);
     if (existing === null) {
       existingAction = "skipped-foreign";
@@ -490,35 +119,42 @@ function writeDiscoveryFile(projectRoot, anonKey) {
     existingAction = "created";
   }
   const tmpPath = `${filePath}.tmp-${process.pid}`;
-  const needsWindowsReplace = process.platform === "win32" && fs2.existsSync(filePath);
+  const needsWindowsReplace = process.platform === "win32" && fs.existsSync(filePath);
   const backupPath = needsWindowsReplace ? `${filePath}.bak-${process.pid}` : null;
   try {
-    fs2.mkdirSync(wellKnownDir, { recursive: true });
+    fs.mkdirSync(wellKnownDir, { recursive: true });
     const payload = serializeDiscoveryPayload(anonKey, extras);
-    fs2.writeFileSync(tmpPath, payload, { encoding: "utf-8" });
     if (backupPath !== null) {
-      fs2.renameSync(filePath, backupPath);
+      writeAndFsyncTempSync(tmpPath, payload, {
+        encoding: "utf-8",
+        mode: 420
+      });
+      fs.renameSync(filePath, backupPath);
       try {
-        fs2.renameSync(tmpPath, filePath);
+        fs.renameSync(tmpPath, filePath);
       } catch (renameErr) {
         try {
-          fs2.renameSync(backupPath, filePath);
+          fs.renameSync(backupPath, filePath);
         } catch {
         }
         throw renameErr;
       }
+      fsyncParentDirSync(filePath);
       try {
-        fs2.unlinkSync(backupPath);
+        fs.unlinkSync(backupPath);
       } catch {
       }
     } else {
-      fs2.renameSync(tmpPath, filePath);
+      atomicWriteFileSyncWithTmp(filePath, tmpPath, payload, {
+        encoding: "utf-8",
+        mode: 420
+      });
     }
     return { action: existingAction, filePath, layout };
   } catch (err) {
     try {
-      if (fs2.existsSync(tmpPath)) {
-        fs2.unlinkSync(tmpPath);
+      if (fs.existsSync(tmpPath)) {
+        fs.unlinkSync(tmpPath);
       }
     } catch {
     }
@@ -535,13 +171,13 @@ function removeDiscoveryFile(projectRoot) {
   const layouts = ["public", "static"];
   const outcomes = [];
   for (const layout of layouts) {
-    const staticRoot = path2.join(projectRoot, layout);
-    const wellKnownDir = path2.join(staticRoot, ".well-known");
-    const filePath = path2.join(wellKnownDir, "glasstrace.json");
+    const staticRoot = path.join(projectRoot, layout);
+    const wellKnownDir = path.join(staticRoot, ".well-known");
+    const filePath = path.join(wellKnownDir, "glasstrace.json");
     let removed = false;
     try {
-      if (fs2.existsSync(filePath)) {
-        fs2.unlinkSync(filePath);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
         removed = true;
       }
     } catch (err) {
@@ -556,10 +192,10 @@ function removeDiscoveryFile(projectRoot) {
     let directoryRemoved = false;
     if (removed) {
       try {
-        if (fs2.existsSync(wellKnownDir)) {
-          const entries = fs2.readdirSync(wellKnownDir);
+        if (fs.existsSync(wellKnownDir)) {
+          const entries = fs.readdirSync(wellKnownDir);
           if (entries.length === 0) {
-            fs2.rmdirSync(wellKnownDir);
+            fs.rmdirSync(wellKnownDir);
             directoryRemoved = true;
           }
         }
@@ -892,26 +528,16 @@ function processTomlMcpConfig(content) {
   return { action: "removed-section", content: result + "\n" };
 }
 function writeShutdownMarker(projectRoot) {
-  const dirPath = path3.join(projectRoot, ".glasstrace");
-  if (!fs3.existsSync(dirPath)) {
+  const dirPath = path2.join(projectRoot, ".glasstrace");
+  if (!fs2.existsSync(dirPath)) {
     return false;
   }
-  const markerPath = path3.join(dirPath, "shutdown-requested");
-  const tmpPath = `${markerPath}.tmp`;
+  const markerPath = path2.join(dirPath, "shutdown-requested");
   const body = JSON.stringify({ requestedAt: (/* @__PURE__ */ new Date()).toISOString() });
   try {
-    fs3.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
-    try {
-      fs3.chmodSync(tmpPath, 384);
-    } catch {
-    }
-    fs3.renameSync(tmpPath, markerPath);
+    atomicWriteFileSync(markerPath, body, { encoding: "utf-8", mode: 384 });
     return true;
   } catch {
-    try {
-      fs3.unlinkSync(tmpPath);
-    } catch {
-    }
     return false;
   }
 }
@@ -950,8 +576,8 @@ async function runUninit(options) {
         summary.push("Wrote .glasstrace/shutdown-requested marker");
       }
     } else {
-      const dirPath = path3.join(projectRoot, ".glasstrace");
-      if (fs3.existsSync(dirPath)) {
+      const dirPath = path2.join(projectRoot, ".glasstrace");
+      if (fs2.existsSync(dirPath)) {
         summary.push(`${prefix}Would write .glasstrace/shutdown-requested marker`);
       }
     }
@@ -963,11 +589,11 @@ async function runUninit(options) {
   try {
     let configHandled = false;
     for (const name of NEXT_CONFIG_NAMES) {
-      const configPath = path3.join(projectRoot, name);
-      if (!fs3.existsSync(configPath)) {
+      const configPath = path2.join(projectRoot, name);
+      if (!fs2.existsSync(configPath)) {
         continue;
       }
-      const content = fs3.readFileSync(configPath, "utf-8");
+      const content = fs2.readFileSync(configPath, "utf-8");
       if (!content.includes("withGlasstraceConfig")) {
         continue;
       }
@@ -977,7 +603,7 @@ async function runUninit(options) {
         const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
         const final = cleanLeadingBlankLines(cleaned);
         if (!dryRun) {
-          fs3.writeFileSync(configPath, final, "utf-8");
+          fs2.writeFileSync(configPath, final, "utf-8");
         }
         summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
         configHandled = true;
@@ -998,20 +624,20 @@ async function runUninit(options) {
     );
   }
   try {
-    const instrPath = path3.join(projectRoot, "instrumentation.ts");
-    if (fs3.existsSync(instrPath)) {
-      const content = fs3.readFileSync(instrPath, "utf-8");
+    const instrPath = path2.join(projectRoot, "instrumentation.ts");
+    if (fs2.existsSync(instrPath)) {
+      const content = fs2.readFileSync(instrPath, "utf-8");
       if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
         if (isInitCreatedInstrumentation(content)) {
           if (!dryRun) {
-            fs3.unlinkSync(instrPath);
+            fs2.unlinkSync(instrPath);
           }
           summary.push(`${prefix}Deleted instrumentation.ts (init-created)`);
         } else {
           const cleaned = removeRegisterGlasstrace(content);
           if (cleaned !== content) {
             if (!dryRun) {
-              fs3.writeFileSync(instrPath, cleaned, "utf-8");
+              fs2.writeFileSync(instrPath, cleaned, "utf-8");
             }
             summary.push(
               `${prefix}Removed registerGlasstrace() from instrumentation.ts`
@@ -1026,10 +652,10 @@ async function runUninit(options) {
     );
   }
   try {
-    const glasstraceDir = path3.join(projectRoot, ".glasstrace");
-    if (fs3.existsSync(glasstraceDir)) {
+    const glasstraceDir = path2.join(projectRoot, ".glasstrace");
+    if (fs2.existsSync(glasstraceDir)) {
       if (!dryRun) {
-        fs3.rmSync(glasstraceDir, { recursive: true, force: true });
+        fs2.rmSync(glasstraceDir, { recursive: true, force: true });
       }
       summary.push(`${prefix}Removed .glasstrace/ directory`);
     }
@@ -1042,8 +668,8 @@ async function runUninit(options) {
     if (dryRun) {
       for (const previewLayout of ["public", "static"]) {
         const relPath = relativeDiscoveryPath(previewLayout);
-        const absPath = path3.join(projectRoot, relPath);
-        if (fs3.existsSync(absPath)) {
+        const absPath = path2.join(projectRoot, relPath);
+        if (fs2.existsSync(absPath)) {
           summary.push(`${prefix}Would remove ${relPath}`);
         }
       }
@@ -1068,9 +694,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const envPath = path3.join(projectRoot, ".env.local");
-    if (fs3.existsSync(envPath)) {
-      const content = fs3.readFileSync(envPath, "utf-8");
+    const envPath = path2.join(projectRoot, ".env.local");
+    if (fs2.existsSync(envPath)) {
+      const content = fs2.readFileSync(envPath, "utf-8");
       const existingKey = readEnvLocalApiKey(content);
       const hasDevKey = isDevApiKey(existingKey);
       let proceed = true;
@@ -1103,12 +729,12 @@ async function runUninit(options) {
           const result = filtered.join("\n");
           if (result.trim().length === 0) {
             if (!dryRun) {
-              fs3.unlinkSync(envPath);
+              fs2.unlinkSync(envPath);
             }
             summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
           } else {
             if (!dryRun) {
-              fs3.writeFileSync(envPath, result, "utf-8");
+              fs2.writeFileSync(envPath, result, "utf-8");
             }
             let devKeyAnnotation = "";
             if (devKeyPath === "interactive-confirmed") {
@@ -1131,9 +757,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const gitignorePath = path3.join(projectRoot, ".gitignore");
-    if (fs3.existsSync(gitignorePath)) {
-      const content = fs3.readFileSync(gitignorePath, "utf-8");
+    const gitignorePath = path2.join(projectRoot, ".gitignore");
+    if (fs2.existsSync(gitignorePath)) {
+      const content = fs2.readFileSync(gitignorePath, "utf-8");
       const lines = content.split("\n");
       const mcpGitignoreEntries = /* @__PURE__ */ new Set([
         ".glasstrace/",
@@ -1149,12 +775,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs3.unlinkSync(gitignorePath);
+            fs2.unlinkSync(gitignorePath);
           }
           summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs3.writeFileSync(gitignorePath, result, "utf-8");
+            fs2.writeFileSync(gitignorePath, result, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
         }
@@ -1167,63 +793,63 @@ async function runUninit(options) {
   }
   try {
     for (const configFile of MCP_CONFIG_FILES) {
-      const configPath = path3.join(projectRoot, configFile);
-      if (!fs3.existsSync(configPath)) {
+      const configPath = path2.join(projectRoot, configFile);
+      if (!fs2.existsSync(configPath)) {
         continue;
       }
-      const content = fs3.readFileSync(configPath, "utf-8");
+      const content = fs2.readFileSync(configPath, "utf-8");
       const result = processJsonMcpConfig(content);
       if (result.action === "deleted") {
         if (!dryRun) {
-          fs3.unlinkSync(configPath);
+          fs2.unlinkSync(configPath);
         }
         summary.push(`${prefix}Deleted ${configFile}`);
       } else if (result.action === "removed-key" && result.content !== void 0) {
         if (!dryRun) {
-          fs3.writeFileSync(configPath, result.content, "utf-8");
+          fs2.writeFileSync(configPath, result.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from ${configFile}`);
       }
     }
-    const codexConfigPath = path3.join(projectRoot, ".codex", "config.toml");
-    if (fs3.existsSync(codexConfigPath)) {
-      const content = fs3.readFileSync(codexConfigPath, "utf-8");
+    const codexConfigPath = path2.join(projectRoot, ".codex", "config.toml");
+    if (fs2.existsSync(codexConfigPath)) {
+      const content = fs2.readFileSync(codexConfigPath, "utf-8");
       const tomlResult = processTomlMcpConfig(content);
       if (tomlResult.action === "deleted") {
         if (!dryRun) {
-          fs3.unlinkSync(codexConfigPath);
+          fs2.unlinkSync(codexConfigPath);
         }
         summary.push(`${prefix}Deleted .codex/config.toml`);
       } else if (tomlResult.action === "removed-section" && tomlResult.content !== void 0) {
         if (!dryRun) {
-          fs3.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
+          fs2.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
       }
     }
-    const hasWindsurfMarkers = fs3.existsSync(path3.join(projectRoot, ".windsurfrules")) || fs3.existsSync(path3.join(projectRoot, ".windsurf"));
+    const hasWindsurfMarkers = fs2.existsSync(path2.join(projectRoot, ".windsurfrules")) || fs2.existsSync(path2.join(projectRoot, ".windsurf"));
     if (hasWindsurfMarkers) {
-      const windsurfConfigPath = path3.join(
+      const windsurfConfigPath = path2.join(
         os.homedir(),
         ".codeium",
         "windsurf",
         "mcp_config.json"
       );
-      if (fs3.existsSync(windsurfConfigPath)) {
-        const content = fs3.readFileSync(windsurfConfigPath, "utf-8");
+      if (fs2.existsSync(windsurfConfigPath)) {
+        const content = fs2.readFileSync(windsurfConfigPath, "utf-8");
         const windsurfResult = processJsonMcpConfig(content);
         const home = os.homedir();
         const displayPath = windsurfConfigPath.startsWith(home) ? "~" + windsurfConfigPath.slice(home.length) : windsurfConfigPath;
         if (windsurfResult.action === "deleted") {
           if (!dryRun) {
-            fs3.unlinkSync(windsurfConfigPath);
+            fs2.unlinkSync(windsurfConfigPath);
           }
           summary.push(
             `${prefix}Deleted global Windsurf config (${displayPath})`
           );
         } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
           if (!dryRun) {
-            fs3.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+            fs2.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
           }
           summary.push(
             `${prefix}Removed glasstrace from global Windsurf config (${displayPath})`
@@ -1238,21 +864,21 @@ async function runUninit(options) {
   }
   try {
     for (const infoFile of AGENT_INFO_FILES) {
-      const filePath = path3.join(projectRoot, infoFile);
-      if (!fs3.existsSync(filePath)) {
+      const filePath = path2.join(projectRoot, infoFile);
+      if (!fs2.existsSync(filePath)) {
         continue;
       }
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs2.readFileSync(filePath, "utf-8");
       const result = removeMarkerSection(content);
       if (result.removed) {
         if (result.content.trim().length === 0) {
           if (!dryRun) {
-            fs3.unlinkSync(filePath);
+            fs2.unlinkSync(filePath);
           }
           summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
         } else {
           if (!dryRun) {
-            fs3.writeFileSync(filePath, result.content, "utf-8");
+            fs2.writeFileSync(filePath, result.content, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
         }
@@ -1270,12 +896,6 @@ async function runUninit(options) {
 }
 
 export {
-  resolveInstrumentationTarget,
-  scaffoldInstrumentation,
-  scaffoldNextConfig,
-  scaffoldEnvLocal,
-  addCoverageMapEnv,
-  scaffoldGitignore,
   resolveStaticRoot,
   relativeDiscoveryPath,
   writeDiscoveryFile,
@@ -1294,4 +914,4 @@ export {
   writeShutdownMarker,
   runUninit
 };
-//# sourceMappingURL=chunk-ZRDQ6ZKI.js.map
+//# sourceMappingURL=chunk-TWHCJKRS.js.map