@glasstrace/sdk 1.1.0 → 1.1.1

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

@@ -1,51 +1,426 @@
+import {
+  NEXT_CONFIG_NAMES
+} from "./chunk-7SZQN6IU.js";
 import {
   isDevApiKey,
   readEnvLocalApiKey
-} from "./chunk-O63DJKIJ.js";
+} from "./chunk-P22UQ2OJ.js";
 import {
   AnonApiKeySchema
-} from "./chunk-TQ54WLCZ.js";
-import {
-  NEXT_CONFIG_NAMES
-} from "./chunk-DXRZKKSO.js";
+} from "./chunk-X5MAXP5T.js";
 
 // src/cli/uninit.ts
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
-// src/cli/discovery-file.ts
+// src/cli/scaffolder.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: path.join(projectRoot, "static"),
+      absolutePath: path2.join(projectRoot, "static"),
       layout: "static"
     };
   }
   return {
-    absolutePath: path.join(projectRoot, "public"),
+    absolutePath: path2.join(projectRoot, "public"),
     layout: "public"
   };
 }
 function isSvelteKitProject(projectRoot) {
-  const pkgPath = path.join(projectRoot, "package.json");
+  const pkgPath = path2.join(projectRoot, "package.json");
   let isEsm = false;
   try {
-    const pkgContent = fs.readFileSync(pkgPath, "utf-8");
+    const pkgContent = fs2.readFileSync(pkgPath, "utf-8");
     const parsed = JSON.parse(pkgContent);
     isEsm = parsed.type === "module";
   } catch {
     return false;
   }
   if (!isEsm) return false;
-  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);
+  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);
 }
 function relativeDiscoveryPath(layout) {
   const rootDir = layout === "static" ? "static" : "public";
@@ -54,7 +429,7 @@ function relativeDiscoveryPath(layout) {
 function readExistingDiscoveryFile(filePath) {
   let raw;
   try {
-    raw = fs.readFileSync(filePath, "utf-8");
+    raw = fs2.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -93,11 +468,11 @@ function serializeDiscoveryPayload(key, extras) {
 }
 function writeDiscoveryFile(projectRoot, anonKey) {
   const { absolutePath: staticRoot, layout } = resolveStaticRoot(projectRoot);
-  const wellKnownDir = path.join(staticRoot, ".well-known");
-  const filePath = path.join(wellKnownDir, "glasstrace.json");
+  const wellKnownDir = path2.join(staticRoot, ".well-known");
+  const filePath = path2.join(wellKnownDir, "glasstrace.json");
   let existingAction;
   let extras = {};
-  if (fs.existsSync(filePath)) {
+  if (fs2.existsSync(filePath)) {
     const existing = readExistingDiscoveryFile(filePath);
     if (existing === null) {
       existingAction = "skipped-foreign";
@@ -115,35 +490,35 @@ function writeDiscoveryFile(projectRoot, anonKey) {
     existingAction = "created";
   }
   const tmpPath = `${filePath}.tmp-${process.pid}`;
-  const needsWindowsReplace = process.platform === "win32" && fs.existsSync(filePath);
+  const needsWindowsReplace = process.platform === "win32" && fs2.existsSync(filePath);
   const backupPath = needsWindowsReplace ? `${filePath}.bak-${process.pid}` : null;
   try {
-    fs.mkdirSync(wellKnownDir, { recursive: true });
+    fs2.mkdirSync(wellKnownDir, { recursive: true });
     const payload = serializeDiscoveryPayload(anonKey, extras);
-    fs.writeFileSync(tmpPath, payload, { encoding: "utf-8" });
+    fs2.writeFileSync(tmpPath, payload, { encoding: "utf-8" });
     if (backupPath !== null) {
-      fs.renameSync(filePath, backupPath);
+      fs2.renameSync(filePath, backupPath);
       try {
-        fs.renameSync(tmpPath, filePath);
+        fs2.renameSync(tmpPath, filePath);
       } catch (renameErr) {
         try {
-          fs.renameSync(backupPath, filePath);
+          fs2.renameSync(backupPath, filePath);
         } catch {
         }
         throw renameErr;
       }
       try {
-        fs.unlinkSync(backupPath);
+        fs2.unlinkSync(backupPath);
       } catch {
       }
     } else {
-      fs.renameSync(tmpPath, filePath);
+      fs2.renameSync(tmpPath, filePath);
     }
     return { action: existingAction, filePath, layout };
   } catch (err) {
     try {
-      if (fs.existsSync(tmpPath)) {
-        fs.unlinkSync(tmpPath);
+      if (fs2.existsSync(tmpPath)) {
+        fs2.unlinkSync(tmpPath);
       }
     } catch {
     }
@@ -160,13 +535,13 @@ function removeDiscoveryFile(projectRoot) {
   const layouts = ["public", "static"];
   const outcomes = [];
   for (const layout of layouts) {
-    const staticRoot = path.join(projectRoot, layout);
-    const wellKnownDir = path.join(staticRoot, ".well-known");
-    const filePath = path.join(wellKnownDir, "glasstrace.json");
+    const staticRoot = path2.join(projectRoot, layout);
+    const wellKnownDir = path2.join(staticRoot, ".well-known");
+    const filePath = path2.join(wellKnownDir, "glasstrace.json");
     let removed = false;
     try {
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
+      if (fs2.existsSync(filePath)) {
+        fs2.unlinkSync(filePath);
         removed = true;
       }
     } catch (err) {
@@ -181,10 +556,10 @@ function removeDiscoveryFile(projectRoot) {
     let directoryRemoved = false;
     if (removed) {
       try {
-        if (fs.existsSync(wellKnownDir)) {
-          const entries = fs.readdirSync(wellKnownDir);
+        if (fs2.existsSync(wellKnownDir)) {
+          const entries = fs2.readdirSync(wellKnownDir);
           if (entries.length === 0) {
-            fs.rmdirSync(wellKnownDir);
+            fs2.rmdirSync(wellKnownDir);
             directoryRemoved = true;
           }
         }
@@ -517,24 +892,24 @@ function processTomlMcpConfig(content) {
   return { action: "removed-section", content: result + "\n" };
 }
 function writeShutdownMarker(projectRoot) {
-  const dirPath = path2.join(projectRoot, ".glasstrace");
-  if (!fs2.existsSync(dirPath)) {
+  const dirPath = path3.join(projectRoot, ".glasstrace");
+  if (!fs3.existsSync(dirPath)) {
     return false;
   }
-  const markerPath = path2.join(dirPath, "shutdown-requested");
+  const markerPath = path3.join(dirPath, "shutdown-requested");
   const tmpPath = `${markerPath}.tmp`;
   const body = JSON.stringify({ requestedAt: (/* @__PURE__ */ new Date()).toISOString() });
   try {
-    fs2.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    fs3.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
     try {
-      fs2.chmodSync(tmpPath, 384);
+      fs3.chmodSync(tmpPath, 384);
     } catch {
     }
-    fs2.renameSync(tmpPath, markerPath);
+    fs3.renameSync(tmpPath, markerPath);
     return true;
   } catch {
     try {
-      fs2.unlinkSync(tmpPath);
+      fs3.unlinkSync(tmpPath);
     } catch {
     }
     return false;
@@ -575,8 +950,8 @@ async function runUninit(options) {
         summary.push("Wrote .glasstrace/shutdown-requested marker");
       }
     } else {
-      const dirPath = path2.join(projectRoot, ".glasstrace");
-      if (fs2.existsSync(dirPath)) {
+      const dirPath = path3.join(projectRoot, ".glasstrace");
+      if (fs3.existsSync(dirPath)) {
         summary.push(`${prefix}Would write .glasstrace/shutdown-requested marker`);
       }
     }
@@ -588,11 +963,11 @@ async function runUninit(options) {
   try {
     let configHandled = false;
     for (const name of NEXT_CONFIG_NAMES) {
-      const configPath = path2.join(projectRoot, name);
-      if (!fs2.existsSync(configPath)) {
+      const configPath = path3.join(projectRoot, name);
+      if (!fs3.existsSync(configPath)) {
         continue;
       }
-      const content = fs2.readFileSync(configPath, "utf-8");
+      const content = fs3.readFileSync(configPath, "utf-8");
       if (!content.includes("withGlasstraceConfig")) {
         continue;
       }
@@ -602,7 +977,7 @@ async function runUninit(options) {
         const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
         const final = cleanLeadingBlankLines(cleaned);
         if (!dryRun) {
-          fs2.writeFileSync(configPath, final, "utf-8");
+          fs3.writeFileSync(configPath, final, "utf-8");
         }
         summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
         configHandled = true;
@@ -623,20 +998,20 @@ async function runUninit(options) {
     );
   }
   try {
-    const instrPath = path2.join(projectRoot, "instrumentation.ts");
-    if (fs2.existsSync(instrPath)) {
-      const content = fs2.readFileSync(instrPath, "utf-8");
+    const instrPath = path3.join(projectRoot, "instrumentation.ts");
+    if (fs3.existsSync(instrPath)) {
+      const content = fs3.readFileSync(instrPath, "utf-8");
       if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
         if (isInitCreatedInstrumentation(content)) {
           if (!dryRun) {
-            fs2.unlinkSync(instrPath);
+            fs3.unlinkSync(instrPath);
           }
           summary.push(`${prefix}Deleted instrumentation.ts (init-created)`);
         } else {
           const cleaned = removeRegisterGlasstrace(content);
           if (cleaned !== content) {
             if (!dryRun) {
-              fs2.writeFileSync(instrPath, cleaned, "utf-8");
+              fs3.writeFileSync(instrPath, cleaned, "utf-8");
             }
             summary.push(
               `${prefix}Removed registerGlasstrace() from instrumentation.ts`
@@ -651,10 +1026,10 @@ async function runUninit(options) {
     );
   }
   try {
-    const glasstraceDir = path2.join(projectRoot, ".glasstrace");
-    if (fs2.existsSync(glasstraceDir)) {
+    const glasstraceDir = path3.join(projectRoot, ".glasstrace");
+    if (fs3.existsSync(glasstraceDir)) {
       if (!dryRun) {
-        fs2.rmSync(glasstraceDir, { recursive: true, force: true });
+        fs3.rmSync(glasstraceDir, { recursive: true, force: true });
       }
       summary.push(`${prefix}Removed .glasstrace/ directory`);
     }
@@ -667,8 +1042,8 @@ async function runUninit(options) {
     if (dryRun) {
       for (const previewLayout of ["public", "static"]) {
         const relPath = relativeDiscoveryPath(previewLayout);
-        const absPath = path2.join(projectRoot, relPath);
-        if (fs2.existsSync(absPath)) {
+        const absPath = path3.join(projectRoot, relPath);
+        if (fs3.existsSync(absPath)) {
           summary.push(`${prefix}Would remove ${relPath}`);
         }
       }
@@ -693,9 +1068,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const envPath = path2.join(projectRoot, ".env.local");
-    if (fs2.existsSync(envPath)) {
-      const content = fs2.readFileSync(envPath, "utf-8");
+    const envPath = path3.join(projectRoot, ".env.local");
+    if (fs3.existsSync(envPath)) {
+      const content = fs3.readFileSync(envPath, "utf-8");
       const existingKey = readEnvLocalApiKey(content);
       const hasDevKey = isDevApiKey(existingKey);
       let proceed = true;
@@ -728,12 +1103,12 @@ async function runUninit(options) {
           const result = filtered.join("\n");
           if (result.trim().length === 0) {
             if (!dryRun) {
-              fs2.unlinkSync(envPath);
+              fs3.unlinkSync(envPath);
             }
             summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
           } else {
             if (!dryRun) {
-              fs2.writeFileSync(envPath, result, "utf-8");
+              fs3.writeFileSync(envPath, result, "utf-8");
             }
             let devKeyAnnotation = "";
             if (devKeyPath === "interactive-confirmed") {
@@ -756,9 +1131,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const gitignorePath = path2.join(projectRoot, ".gitignore");
-    if (fs2.existsSync(gitignorePath)) {
-      const content = fs2.readFileSync(gitignorePath, "utf-8");
+    const gitignorePath = path3.join(projectRoot, ".gitignore");
+    if (fs3.existsSync(gitignorePath)) {
+      const content = fs3.readFileSync(gitignorePath, "utf-8");
       const lines = content.split("\n");
       const mcpGitignoreEntries = /* @__PURE__ */ new Set([
         ".glasstrace/",
@@ -774,12 +1149,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs2.unlinkSync(gitignorePath);
+            fs3.unlinkSync(gitignorePath);
           }
           summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs2.writeFileSync(gitignorePath, result, "utf-8");
+            fs3.writeFileSync(gitignorePath, result, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
         }
@@ -792,63 +1167,63 @@ async function runUninit(options) {
   }
   try {
     for (const configFile of MCP_CONFIG_FILES) {
-      const configPath = path2.join(projectRoot, configFile);
-      if (!fs2.existsSync(configPath)) {
+      const configPath = path3.join(projectRoot, configFile);
+      if (!fs3.existsSync(configPath)) {
         continue;
       }
-      const content = fs2.readFileSync(configPath, "utf-8");
+      const content = fs3.readFileSync(configPath, "utf-8");
       const result = processJsonMcpConfig(content);
       if (result.action === "deleted") {
         if (!dryRun) {
-          fs2.unlinkSync(configPath);
+          fs3.unlinkSync(configPath);
         }
         summary.push(`${prefix}Deleted ${configFile}`);
       } else if (result.action === "removed-key" && result.content !== void 0) {
         if (!dryRun) {
-          fs2.writeFileSync(configPath, result.content, "utf-8");
+          fs3.writeFileSync(configPath, result.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from ${configFile}`);
       }
     }
-    const codexConfigPath = path2.join(projectRoot, ".codex", "config.toml");
-    if (fs2.existsSync(codexConfigPath)) {
-      const content = fs2.readFileSync(codexConfigPath, "utf-8");
+    const codexConfigPath = path3.join(projectRoot, ".codex", "config.toml");
+    if (fs3.existsSync(codexConfigPath)) {
+      const content = fs3.readFileSync(codexConfigPath, "utf-8");
       const tomlResult = processTomlMcpConfig(content);
       if (tomlResult.action === "deleted") {
         if (!dryRun) {
-          fs2.unlinkSync(codexConfigPath);
+          fs3.unlinkSync(codexConfigPath);
         }
         summary.push(`${prefix}Deleted .codex/config.toml`);
       } else if (tomlResult.action === "removed-section" && tomlResult.content !== void 0) {
         if (!dryRun) {
-          fs2.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
+          fs3.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
       }
     }
-    const hasWindsurfMarkers = fs2.existsSync(path2.join(projectRoot, ".windsurfrules")) || fs2.existsSync(path2.join(projectRoot, ".windsurf"));
+    const hasWindsurfMarkers = fs3.existsSync(path3.join(projectRoot, ".windsurfrules")) || fs3.existsSync(path3.join(projectRoot, ".windsurf"));
     if (hasWindsurfMarkers) {
-      const windsurfConfigPath = path2.join(
+      const windsurfConfigPath = path3.join(
         os.homedir(),
         ".codeium",
         "windsurf",
         "mcp_config.json"
       );
-      if (fs2.existsSync(windsurfConfigPath)) {
-        const content = fs2.readFileSync(windsurfConfigPath, "utf-8");
+      if (fs3.existsSync(windsurfConfigPath)) {
+        const content = fs3.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) {
-            fs2.unlinkSync(windsurfConfigPath);
+            fs3.unlinkSync(windsurfConfigPath);
           }
           summary.push(
             `${prefix}Deleted global Windsurf config (${displayPath})`
           );
         } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
           if (!dryRun) {
-            fs2.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+            fs3.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
           }
           summary.push(
             `${prefix}Removed glasstrace from global Windsurf config (${displayPath})`
@@ -863,21 +1238,21 @@ async function runUninit(options) {
   }
   try {
     for (const infoFile of AGENT_INFO_FILES) {
-      const filePath = path2.join(projectRoot, infoFile);
-      if (!fs2.existsSync(filePath)) {
+      const filePath = path3.join(projectRoot, infoFile);
+      if (!fs3.existsSync(filePath)) {
         continue;
       }
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const content = fs3.readFileSync(filePath, "utf-8");
       const result = removeMarkerSection(content);
       if (result.removed) {
         if (result.content.trim().length === 0) {
           if (!dryRun) {
-            fs2.unlinkSync(filePath);
+            fs3.unlinkSync(filePath);
           }
           summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
         } else {
           if (!dryRun) {
-            fs2.writeFileSync(filePath, result.content, "utf-8");
+            fs3.writeFileSync(filePath, result.content, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
         }
@@ -895,6 +1270,12 @@ async function runUninit(options) {
 }
 
 export {
+  resolveInstrumentationTarget,
+  scaffoldInstrumentation,
+  scaffoldNextConfig,
+  scaffoldEnvLocal,
+  addCoverageMapEnv,
+  scaffoldGitignore,
   resolveStaticRoot,
   relativeDiscoveryPath,
   writeDiscoveryFile,
@@ -913,4 +1294,4 @@ export {
   writeShutdownMarker,
   runUninit
 };
-//# sourceMappingURL=chunk-LU3PPAOQ.js.map
+//# sourceMappingURL=chunk-ZRDQ6ZKI.js.map