@glasstrace/sdk 0.2.3 → 0.4.1

package/dist/{chunk-CUFIV225.js → chunk-EC5IINUT.js}

@@ -2,11 +2,9 @@ import {
   __export
 } from "./chunk-PZ5AY32C.js";
 
-// src/import-graph.ts
-import * as fs from "fs/promises";
-import * as fsSync from "fs";
-import * as path from "path";
-import * as crypto2 from "crypto";
+// src/anon-key.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -511,7 +509,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process,
+  process: () => process2,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -775,10 +773,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1161,11 +1159,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -1348,7 +1346,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path2 = []) => {
+  const processError = (error49, path = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1358,7 +1356,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1390,8 +1388,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -10912,7 +10910,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -10949,7 +10947,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11230,14 +11228,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -11494,7 +11492,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json2.maxItems = maximum;
   json2.type = "array";
-  json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
   const json2 = _json;
@@ -11503,7 +11501,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json2.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -11526,7 +11524,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json2.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json2.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11535,7 +11533,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -11547,11 +11545,11 @@ var unionProcessor = (schema, ctx, json2, params) => {
 };
 var intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -11568,11 +11566,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -11612,7 +11610,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -11622,12 +11620,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json2.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json2.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11642,7 +11640,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -11653,20 +11651,20 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -11674,7 +11672,7 @@ var prefaultProcessor = (schema, ctx, json2, params) => {
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -11688,32 +11686,32 @@ var catchProcessor = (schema, ctx, json2, params) => {
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -11765,7 +11763,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -11788,7 +11786,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -11846,7 +11844,7 @@ var JSONSchemaGenerator = class {
    * This must be called before emit().
    */
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
@@ -13368,13 +13366,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path[0] === defsKey) {
+    const key = path[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -13909,175 +13907,62 @@ var DEFAULT_CAPTURE_CONFIG = {
   consoleErrors: false
 };
 
-// src/import-graph.ts
-var MAX_TEST_FILES = 5e3;
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", ".turbo"]);
-var DEFAULT_TEST_PATTERNS = [
-  /\.test\.tsx?$/,
-  /\.spec\.tsx?$/
-];
-function globToRegExp(glob) {
-  const DOUBLE_STAR_PLACEHOLDER = "\0DSTAR\0";
-  const regexStr = glob.replace(/\*\*\//g, DOUBLE_STAR_PLACEHOLDER).replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]+").replace(new RegExp(DOUBLE_STAR_PLACEHOLDER.replace(/\0/g, "\\0"), "g"), "(?:.+/)?");
-  return new RegExp("^" + regexStr + "$");
-}
-function loadCustomTestPatterns(projectRoot) {
-  const configNames = [
-    "vitest.config.ts",
-    "vitest.config.js",
-    "vitest.config.mts",
-    "vitest.config.mjs",
-    "vite.config.ts",
-    "vite.config.js",
-    "vite.config.mts",
-    "vite.config.mjs",
-    "jest.config.ts",
-    "jest.config.js",
-    "jest.config.mts",
-    "jest.config.mjs"
-  ];
-  for (const name of configNames) {
-    const configPath = path.join(projectRoot, name);
-    let content;
-    try {
-      content = fsSync.readFileSync(configPath, "utf-8");
-    } catch {
-      continue;
-    }
-    try {
-      const isJest = name.startsWith("jest.");
-      let includeMatch = null;
-      if (isJest) {
-        includeMatch = /testMatch\s*:\s*\[([^\]]*)\]/s.exec(content);
-      } else {
-        const testBlockMatch = /\btest\s*[:{]\s*/s.exec(content);
-        if (testBlockMatch) {
-          const afterTest = content.slice(testBlockMatch.index, testBlockMatch.index + 500);
-          includeMatch = /include\s*:\s*\[([^\]]*)\]/s.exec(afterTest);
-        }
-      }
-      if (!includeMatch) {
-        continue;
-      }
-      const arrayContent = includeMatch[1];
-      const stringRegex = /['"]([^'"]+)['"]/g;
-      const patterns = [];
-      let match;
-      match = stringRegex.exec(arrayContent);
-      while (match !== null) {
-        patterns.push(globToRegExp(match[1]));
-        match = stringRegex.exec(arrayContent);
-      }
-      if (patterns.length > 0) {
-        return patterns;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return [];
-}
-async function discoverTestFiles(projectRoot) {
-  const customPatterns = loadCustomTestPatterns(projectRoot);
-  const testPatterns = [...DEFAULT_TEST_PATTERNS, ...customPatterns];
-  const results = [];
+// src/anon-key.ts
+var GLASSTRACE_DIR = ".glasstrace";
+var ANON_KEY_FILE = "anon_key";
+var ephemeralKeyCache = /* @__PURE__ */ new Map();
+async function readAnonKey(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const keyPath = join(root, GLASSTRACE_DIR, ANON_KEY_FILE);
   try {
-    await walkForTests(projectRoot, projectRoot, results, testPatterns);
-  } catch {
-    return [];
-  }
-  return results.slice(0, MAX_TEST_FILES);
-}
-async function walkForTests(baseDir, currentDir, results, testPatterns) {
-  if (results.length >= MAX_TEST_FILES) {
-    return;
-  }
-  let entries;
-  try {
-    entries = await fs.readdir(currentDir, { withFileTypes: true });
+    const content = await readFile(keyPath, "utf-8");
+    const result = AnonApiKeySchema.safeParse(content);
+    if (result.success) {
+      return result.data;
+    }
   } catch {
-    return;
   }
-  for (const entry of entries) {
-    if (results.length >= MAX_TEST_FILES) {
-      return;
-    }
-    const fullPath = path.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 = path.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);
-      }
-    }
+  const cached2 = ephemeralKeyCache.get(root);
+  if (cached2 !== void 0) {
+    return cached2;
   }
+  return null;
 }
-function extractImports(fileContent) {
-  const seen = /* @__PURE__ */ new Set();
-  const imports = [];
-  const addUnique = (importPath) => {
-    if (!seen.has(importPath)) {
-      seen.add(importPath);
-      imports.push(importPath);
-    }
-  };
-  const esImportRegex = /import\s+(?:(?:[\w*{}\s,]+)\s+from\s+)?['"]([^'"]+)['"]/g;
-  let match;
-  match = esImportRegex.exec(fileContent);
-  while (match !== null) {
-    addUnique(match[1]);
-    match = esImportRegex.exec(fileContent);
+async function getOrCreateAnonKey(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const dirPath = join(root, GLASSTRACE_DIR);
+  const keyPath = join(dirPath, ANON_KEY_FILE);
+  const existingKey = await readAnonKey(root);
+  if (existingKey !== null) {
+    return existingKey;
   }
-  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  match = requireRegex.exec(fileContent);
-  while (match !== null) {
-    addUnique(match[1]);
-    match = requireRegex.exec(fileContent);
+  const cached2 = ephemeralKeyCache.get(root);
+  if (cached2 !== void 0) {
+    return cached2;
   }
-  const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  match = dynamicImportRegex.exec(fileContent);
-  while (match !== null) {
-    addUnique(match[1]);
-    match = dynamicImportRegex.exec(fileContent);
-  }
-  return imports;
-}
-async function buildImportGraph(projectRoot) {
-  const testFiles = await discoverTestFiles(projectRoot);
-  const graph = {};
-  for (const testFile of testFiles) {
-    const fullPath = path.join(projectRoot, testFile);
-    try {
-      const content = await fs.readFile(fullPath, "utf-8");
-      const imports = extractImports(content);
-      graph[testFile] = imports;
-    } catch {
-      continue;
-    }
+  const newKey = createAnonApiKey();
+  try {
+    await mkdir(dirPath, { recursive: true, mode: 448 });
+    await writeFile(keyPath, newKey, "utf-8");
+    await chmod(keyPath, 384);
+  } catch (err) {
+    ephemeralKeyCache.set(root, newKey);
+    console.warn(
+      `[glasstrace] Failed to persist anonymous key to ${keyPath}: ${err instanceof Error ? err.message : String(err)}. Using ephemeral key.`
+    );
   }
-  const sortedKeys = Object.keys(graph).sort();
-  const serialized = sortedKeys.map((key) => `${key}:${JSON.stringify(graph[key])}`).join("\n");
-  const hashHex = crypto2.createHash("sha256").update(serialized).digest("hex");
-  const buildHash = createBuildHash(hashHex);
-  return { buildHash, graph };
+  return newKey;
 }
 
 export {
-  AnonApiKeySchema,
   SessionIdSchema,
-  createAnonApiKey,
+  createBuildHash,
   SdkCachedConfigSchema,
   SdkInitResponseSchema,
   SourceMapUploadResponseSchema,
   GLASSTRACE_ATTRIBUTE_NAMES,
   DEFAULT_CAPTURE_CONFIG,
-  discoverTestFiles,
-  extractImports,
-  buildImportGraph
+  readAnonKey,
+  getOrCreateAnonKey
 };
-//# sourceMappingURL=chunk-CUFIV225.js.map
+//# sourceMappingURL=chunk-EC5IINUT.js.map