@sentry/api 0.423.0 → 0.424.0

package/README.md

@@ -124,6 +124,43 @@ Each `ApiOperation` records the actual exported `functionName`, original OpenAPI
 
 The catalog is generated from the same schema and SDK output as each release. Consumers own search, grouping, ranking, and command aliases; the catalog does not fetch a live schema or infer undocumented API behavior.
 
+### Build-time source analysis
+
+`@sentry/api/source-analysis` follows references in supplied TypeScript source to discover calls to catalog operations. Install TypeScript only when using this optional build tool; the analyzer is tested with TypeScript 5.9. Its optional peer uses a wildcard so it does not constrain the compiler used by applications that only import the client.
+
+```bash
+npm install --save-dev @sentry/api typescript@^5.9
+```
+
+```ts
+import { operations } from "@sentry/api/operations";
+import { analyzeSourceApiUsage } from "@sentry/api/source-analysis";
+
+const sources = new Map([
+  ["features/logs.ts", `
+    import { listOrganizationEvents } from "@sentry/api";
+    export const readLogs = () =>
+      listOrganizationEvents({
+        path: { organization_id_or_slug: "example-org" },
+        query: { dataset: "logs", field: ["message"] },
+      });
+  `],
+]);
+const analysis = analyzeSourceApiUsage(sources, operations, {
+  queryParameters: ["dataset"],
+});
+console.log(analysis.exports.get("features/logs.ts")?.get("readLogs")?.operations);
+// Includes listOrganizationEvents with known query context { dataset: "logs" }.
+```
+
+The analyzer parses source without executing it, following local imports, re-exports, aliases, and references. Supply sources together with the operation catalog from the installed SDK version. Run it during the consumer's build: command-to-operation relationships depend on consumer code and cannot be precomputed during SDK packaging.
+
+Named, namespace, and default imports are supported, along with top-level functions, variable initializers, and default function/expression exports. Relative imports resolve only against the supplied sources. Extensionless paths try the exact file, `.ts`, `.tsx`, `index.ts`, then `index.tsx`; `.js` specifiers try `.ts` and `.tsx` before the exact `.js` file. Explicit `.ts`/`.tsx` specifiers use the exact file. Named re-exports can forward a default; `export *` forwards only named exports.
+
+Consumers configure their own `boundaries` (factory names whose arguments are inspected without following the factory implementation), `requests` (raw-request wrapper argument positions), `queryParameters` (query values to retain), and `declarationFlags` (boolean markers). These options default to empty lists. Returned `boundaries` identify factory-created exports and their markers; `methods` records reachable HTTP methods, including known methods on unresolved raw requests. CLI routing, aliases, presentation, and destructive-command policy remain with the consumer.
+
+This is static discovery, not proof of runtime execution or safety. Class/member dispatch, dynamic imports, CommonJS, and `tsconfig` path aliases are outside its scope. Missing sources and unsupported constructs can omit calls, so an empty result does not prove that no API calls exist. `unresolvedRequests` contains diagnostics for raw requests that cannot be resolved against the public catalog, not source-coverage diagnostics. Unknown query values are omitted, mutable `let` and `var` bindings are left unknown, and a related operation does not describe every request a workflow makes. The entry imports TypeScript separately and is not loaded by the root client, browser helpers, or operation catalog.
+
 ### Browser sessions
 
 The browser helper configures session cookies and CSRF token injection:

package/dist/source-analysis.d.ts

@@ -0,0 +1,75 @@
+/** Build-time analysis of API usage in consumer-supplied TypeScript source. */
+import type { ApiOperation } from "./operation-types.js";
+/** Identity supplied by the generated SDK operation catalog. */
+export type SourceApiOperation = Pick<ApiOperation, "functionName" | "method" | "path">;
+/** A consumer's raw request wrapper, identified by its resolved function name. */
+export type SourceApiRequest = {
+    functionName: string;
+    /** Zero-based argument containing the request path. */
+    pathArgument: number;
+    /** Zero-based argument containing the options object. */
+    optionsArgument: number;
+    /** Options property containing query parameters. Defaults to `query`. */
+    queryProperty?: string;
+    /** Method when the options omit it. Defaults to GET; unknown spreads stay unknown. */
+    defaultMethod?: string;
+};
+/** Consumer conventions; none of these lists are inferred from command names. */
+export type SourceApiAnalysisOptions = {
+    /** Factory names whose returned objects contain deferred callbacks. */
+    boundaries?: readonly string[];
+    /** Raw request wrappers to link to the operation catalog. */
+    requests?: readonly SourceApiRequest[];
+    /** Query keys to retain. The Sentry `query` key also retains fixed joined terms. */
+    queryParameters?: readonly string[];
+    /** Boolean property names to report when explicitly set to true. */
+    declarationFlags?: readonly string[];
+};
+/** An operation reachable from a source declaration. */
+export type SourceOperationUsage = SourceApiOperation & {
+    /** Known query values or fixed terms; callers may add further filters. */
+    query?: Record<string, string>;
+};
+/** A raw request whose identity cannot be established from the public catalog. */
+export type UnresolvedApiRequest = {
+    /** Source module, using the caller's source-map keys. */
+    file: string;
+    /** One-based request call line. */
+    line: number;
+    /** Known HTTP method, when statically available. */
+    method?: string;
+    /** Known path template, when statically available. */
+    path?: string;
+    /** Why no operation was selected. */
+    reason: string;
+};
+/** Source-derived relationships; no command is executed to obtain them. */
+export type SourceApiUsage = {
+    /** Discovered API operations, preserving distinct contexts. */
+    operations: SourceOperationUsage[];
+    /** Reachable raw requests that need explicit discovery diagnostics. */
+    unresolvedRequests: UnresolvedApiRequest[];
+    /** Known HTTP methods, including unresolved requests and static method properties. */
+    methods: string[];
+};
+/** Source relationships and deferred callback boundaries; never executes input code. */
+export type SourceApiAnalysis = {
+    /** Source file → exported symbol → reachable API usage. */
+    exports: Map<string, Map<string, SourceApiUsage>>;
+    /** Exported boundaries and their consumer-selected factory/flag evidence. */
+    boundaries: {
+        file: string;
+        name: string;
+        factories: string[];
+        flags: string[];
+    }[];
+};
+/**
+ * Follow function references, imports and barrel exports to SDK calls or known
+ * raw request wrappers. Dynamic paths remain diagnostics rather than guesses.
+ * Boundary factories have their arguments inspected, without traversing the
+ * factory's execution machinery. Reading their returned objects as data does
+ * not inherit callback usage. Results describe static reachability, not a
+ * complete execution trace; dynamic behavior may not be discoverable.
+ */
+export declare function analyzeSourceApiUsage(sources: ReadonlyMap<string, string>, operations: readonly SourceApiOperation[], options?: SourceApiAnalysisOptions): SourceApiAnalysis;

package/dist/source-analysis.js

@@ -0,0 +1,796 @@
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// src/source-analysis.ts
+import ts from "typescript";
+var SDK = "@sentry/api";
+var API_PREFIX = /^\/api\/\d+(?=\/)/;
+var PATH_PARAMETER = /\{[^}]*\}/g;
+function unwrap(node) {
+  return ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node) || ts.isNonNullExpression(node) ? unwrap(node.expression) : node;
+}
+function bindsName(binding, name) {
+  return ts.isIdentifier(binding) ? binding.text === name : binding.elements.some((element) => ts.isBindingElement(element) && bindsName(element.name, name));
+}
+function lexicalDeclaration(node, includeSource = false) {
+  for (let parent = node.parent;parent && (includeSource || !ts.isSourceFile(parent)); parent = parent.parent) {
+    if (ts.isFunctionLike(parent)) {
+      const parameter = parent.parameters.find((parameter2) => bindsName(parameter2.name, node.text));
+      if (parameter)
+        return parameter;
+    }
+    if ((ts.isFunctionExpression(parent) || ts.isClassExpression(parent)) && parent.name?.text === node.text)
+      return parent;
+    if (ts.isCatchClause(parent) && parent.variableDeclaration && bindsName(parent.variableDeclaration.name, node.text))
+      return parent.variableDeclaration;
+    if ((ts.isForStatement(parent) || ts.isForOfStatement(parent) || ts.isForInStatement(parent)) && parent.initializer && ts.isVariableDeclarationList(parent.initializer)) {
+      const declaration = parent.initializer.declarations.find((declaration2) => bindsName(declaration2.name, node.text));
+      if (declaration)
+        return declaration;
+    }
+    if (ts.isBlock(parent) || ts.isSourceFile(parent)) {
+      for (const statement of parent.statements) {
+        if (ts.isVariableStatement(statement)) {
+          const declaration = statement.declarationList.declarations.find((declaration2) => bindsName(declaration2.name, node.text));
+          if (declaration)
+            return declaration;
+        }
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === node.text)
+          return statement;
+      }
+    }
+  }
+  return;
+}
+function sourceModule(file, specifier, sources) {
+  if (!specifier.startsWith("."))
+    return specifier;
+  const target = posix.normalize(posix.join(dirname(file), specifier));
+  const extension = posix.extname(target);
+  const candidates = extension === ".js" ? [target.replace(/\.js$/, ".ts"), target.replace(/\.js$/, ".tsx"), target] : extension ? [target] : [target, `${target}.ts`, `${target}.tsx`, posix.join(target, "index.ts"), posix.join(target, "index.tsx")];
+  return candidates.find((candidate) => sources.has(candidate)) ?? target;
+}
+function parseModule(file, text, sources) {
+  const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+  const mod = {
+    source,
+    imports: new Map,
+    exports: new Map,
+    stars: [],
+    declarations: new Map
+  };
+  for (const statement of source.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+      if (statement.importClause?.isTypeOnly)
+        continue;
+      const target = sourceModule(file, statement.moduleSpecifier.text, sources);
+      const defaultImport = statement.importClause?.name;
+      if (defaultImport)
+        mod.imports.set(defaultImport.text, { file: target, name: "default" });
+      const bindings = statement.importClause?.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const binding of bindings.elements) {
+          if (!binding.isTypeOnly)
+            mod.imports.set(binding.name.text, {
+              file: target,
+              name: (binding.propertyName ?? binding.name).text
+            });
+        }
+      } else if (bindings && ts.isNamespaceImport(bindings)) {
+        mod.imports.set(bindings.name.text, { file: target, name: "*" });
+      }
+      continue;
+    }
+    if (ts.isExportDeclaration(statement) && !statement.isTypeOnly) {
+      const target = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? sourceModule(file, statement.moduleSpecifier.text, sources) : file;
+      if (!statement.exportClause)
+        mod.stars.push(target);
+      else if (ts.isNamedExports(statement.exportClause)) {
+        for (const binding of statement.exportClause.elements) {
+          if (!binding.isTypeOnly)
+            mod.exports.set(binding.name.text, {
+              file: target,
+              name: (binding.propertyName ?? binding.name).text
+            });
+        }
+      }
+      continue;
+    }
+    const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+    const isDefault = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) || ts.isExportAssignment(statement) && !statement.isExportEquals;
+    const nodes = [];
+    if (ts.isFunctionDeclaration(statement) && statement.body && (statement.name || isDefault))
+      nodes.push([statement.name?.text ?? "default", statement]);
+    if (ts.isExportAssignment(statement) && !statement.isExportEquals)
+      nodes.push(["default", statement.expression]);
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.initializer)
+          nodes.push([declaration.name.text, declaration.initializer]);
+      }
+    }
+    for (const [name, node] of nodes) {
+      mod.declarations.set(name, {
+        node,
+        refs: new Set,
+        calls: new Set,
+        usage: { operations: [], unresolvedRequests: [], methods: [] },
+        boundary: false,
+        factories: new Set,
+        flags: new Set
+      });
+      if (isDefault)
+        mod.exports.set("default", { file, name });
+      else if (modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword))
+        mod.exports.set(name, { file, name });
+    }
+  }
+  return mod;
+}
+function analyzeSourceApiUsage(sources, operations, options = {}) {
+  const boundaries = new Set(options.boundaries);
+  const requests = new Map(options.requests?.map((request) => [request.functionName, request]));
+  const declarationFlags = new Set(options.declarationFlags);
+  const modules = new Map([...sources].map(([file, text]) => [
+    file,
+    parseModule(file, text, sources)
+  ]));
+  const sdk = new Map(operations.map((operation) => [operation.functionName, operation]));
+  const identities = new Map;
+  const pathKey = (path) => `/${path.replace(API_PREFIX, "").split("/").filter(Boolean).join("/")}/`.replace(PATH_PARAMETER, "{}");
+  for (const operation of operations) {
+    const key = `${operation.method}:${pathKey(operation.path)}`;
+    identities.set(key, [...identities.get(key) ?? [], operation]);
+  }
+  function resolve2(binding, exported = false, seen = new Set) {
+    if (binding.file === SDK)
+      return binding;
+    const key = `${binding.file}#${binding.name}#${exported}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    const mod = modules.get(binding.file);
+    if (!mod)
+      return;
+    if (!exported) {
+      if (mod.declarations.has(binding.name))
+        return binding;
+      const imported = mod.imports.get(binding.name);
+      return imported ? resolve2(imported, true, seen) : undefined;
+    }
+    const next = mod.exports.get(binding.name);
+    if (next)
+      return resolve2(next, next.file !== binding.file, seen);
+    if (binding.name === "default")
+      return;
+    for (const target of mod.stars) {
+      const found = resolve2({ file: target, name: binding.name }, true, seen);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  function bindingFor(file, node) {
+    const mod = modules.get(file);
+    if (ts.isIdentifier(node)) {
+      if (lexicalDeclaration(node))
+        return;
+      const imported = mod.imports.get(node.text);
+      return imported ? resolve2(imported, true) ?? (!modules.has(imported.file) ? imported : undefined) : resolve2({ file, name: node.text });
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && !lexicalDeclaration(node.expression)) {
+      const namespace = mod.imports.get(node.expression.text);
+      if (namespace?.name === "*")
+        return resolve2({ file: namespace.file, name: node.name.text }, true);
+    }
+    return;
+  }
+  function callableBinding(binding) {
+    const seen = new Set;
+    while (binding?.name === "default") {
+      const key = `${binding.file}#${binding.name}`;
+      if (seen.has(key))
+        break;
+      seen.add(key);
+      const declaration = modules.get(binding.file)?.declarations.get(binding.name);
+      if (!declaration)
+        break;
+      const node = unwrap(declaration.node);
+      if (!ts.isIdentifier(node))
+        break;
+      const target = bindingFor(binding.file, node);
+      if (!target)
+        break;
+      binding = target;
+    }
+    return binding;
+  }
+  function initializer(node) {
+    if (!ts.isIdentifier(node))
+      return;
+    const declaration = lexicalDeclaration(node, true);
+    return declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && ts.isVariableDeclarationList(declaration.parent) && declaration.parent.flags & ts.NodeFlags.Const ? declaration.initializer : undefined;
+  }
+  function value(node, template = false, seen = new Set) {
+    if (!node || seen.has(node))
+      return;
+    seen.add(node);
+    node = unwrap(node);
+    if (ts.isStringLiteralLike(node) || ts.isNumericLiteral(node))
+      return node.text;
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+      return "true";
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+      return "false";
+    if (ts.isIdentifier(node))
+      return value(initializer(node), template, seen);
+    if (ts.isTemplateExpression(node)) {
+      let result2 = node.head.text;
+      for (const span of node.templateSpans) {
+        const part = value(span.expression, false, new Set(seen));
+        if (part === undefined && !template)
+          return;
+        result2 += (part ?? "{}") + span.literal.text;
+      }
+      return result2;
+    }
+    return;
+  }
+  function property(node, name, seen = new Set) {
+    if (node == null)
+      return node;
+    if (seen.has(node))
+      return null;
+    seen.add(node);
+    node = unwrap(node);
+    if (ts.isIdentifier(node)) {
+      const initial = initializer(node);
+      return initial ? property(initial, name, seen) : null;
+    }
+    if (!ts.isObjectLiteralExpression(node))
+      return null;
+    for (const member of [...node.properties].reverse()) {
+      if (ts.isSpreadAssignment(member)) {
+        const found = property(member.expression, name, new Set(seen));
+        if (found !== undefined)
+          return found;
+        continue;
+      }
+      const key = ts.isComputedPropertyName(member.name) ? value(member.name.expression) : member.name.text;
+      if (key === undefined)
+        return null;
+      if (key !== name)
+        continue;
+      if (ts.isPropertyAssignment(member))
+        return member.initializer;
+      if (ts.isShorthandPropertyAssignment(member))
+        return member.name;
+      return null;
+    }
+    return;
+  }
+  function queryTerms(node, seen = new Set) {
+    if (!node || seen.has(node))
+      return;
+    const exact = value(node);
+    if (exact !== undefined)
+      return exact;
+    seen.add(node);
+    node = unwrap(node);
+    if (ts.isIdentifier(node))
+      return queryTerms(initializer(node), seen);
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+      return queryTerms(node.left, seen);
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "join" || value(node.arguments[0]) !== " ")
+      return;
+    let array = node.expression.expression;
+    if (ts.isCallExpression(array) && ts.isPropertyAccessExpression(array.expression) && array.expression.name.text === "filter" && array.arguments[0]?.getText() === "Boolean")
+      array = array.expression.expression;
+    if (!ts.isArrayLiteralExpression(array))
+      return;
+    const terms = array.elements.map((item) => value(item)).filter((term) => !!term);
+    return terms.length ? terms.join(" ") : undefined;
+  }
+  function queryContext(requestOptions, key) {
+    const query = property(requestOptions, key);
+    const result2 = {};
+    for (const name of options.queryParameters ?? []) {
+      const expression = property(query, name);
+      const text = name === "query" ? queryTerms(expression) : value(expression);
+      if (text)
+        result2[name] = text;
+    }
+    return Object.keys(result2).length ? result2 : undefined;
+  }
+  for (const [file, mod] of modules) {
+    for (const declaration of mod.declarations.values()) {
+      let visit = function(node) {
+        if (ts.isTypeNode(node))
+          return;
+        if (ts.isPropertyAssignment(node) && declarationFlags.has(node.name.getText()) && node.initializer.kind === ts.SyntaxKind.TrueKeyword && property(node.parent, node.name.getText()) === node.initializer)
+          declaration.flags.add(node.name.getText());
+        if (ts.isPropertyAssignment(node) && node.name.getText() === "method") {
+          const method = value(node.initializer);
+          if (method)
+            declaration.usage.methods.push(method.toUpperCase());
+        }
+        if (ts.isCallExpression(node)) {
+          const reference = bindingFor(file, node.expression);
+          if (reference)
+            declaration.calls.add(`${reference.file}#${reference.name}`);
+          const binding = callableBinding(reference);
+          const name = binding?.name ?? (ts.isIdentifier(node.expression) && !lexicalDeclaration(node.expression) ? node.expression.text : "");
+          if (boundaries.has(name)) {
+            declaration.boundary = true;
+            declaration.factories.add(name);
+            for (const argument of node.arguments)
+              visit(argument);
+            return;
+          }
+          const operation = binding?.file === SDK ? sdk.get(name) : undefined;
+          if (operation) {
+            declaration.usage.operations.push({
+              ...operation,
+              query: queryContext(node.arguments[0], "query")
+            });
+            declaration.usage.methods.push(operation.method);
+            for (const argument of node.arguments)
+              visit(argument);
+            return;
+          }
+          const request = requests.get(name);
+          if (request) {
+            const requestOptions = node.arguments[request.optionsArgument];
+            const methodExpression = property(requestOptions, "method");
+            const method = methodExpression === undefined ? (request.defaultMethod ?? "GET").toUpperCase() : value(methodExpression)?.toUpperCase();
+            const path = value(node.arguments[request.pathArgument], true);
+            const matches = method && path ? identities.get(`${method}:${pathKey(path)}`) ?? [] : [];
+            if (method)
+              declaration.usage.methods.push(method);
+            if (matches.length === 1)
+              declaration.usage.operations.push({
+                ...matches[0],
+                query: queryContext(requestOptions, request.queryProperty ?? "query")
+              });
+            else
+              declaration.usage.unresolvedRequests.push({
+                file,
+                line: mod.source.getLineAndCharacterOfPosition(node.getStart()).line + 1,
+                method,
+                path,
+                reason: !method || !path ? "Dynamic request identity" : matches.length ? "Ambiguous catalog path" : "Request is not in the public catalog"
+              });
+            for (const argument of node.arguments)
+              visit(argument);
+            return;
+          }
+        }
+        if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
+          const parent = node.parent;
+          const isName = ts.isPropertyAccessExpression(parent) && parent.name === node || (ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isFunctionDeclaration(parent)) && parent.name === node;
+          if (!isName) {
+            const binding = bindingFor(file, node);
+            if (binding && !boundaries.has(binding.name)) {
+              const operation = binding.file === SDK ? sdk.get(binding.name) : undefined;
+              if (operation) {
+                declaration.usage.operations.push(operation);
+                declaration.usage.methods.push(operation.method);
+              } else
+                declaration.refs.add(`${binding.file}#${binding.name}`);
+            }
+          }
+        }
+        node.forEachChild(visit);
+      };
+      visit(declaration.node);
+    }
+  }
+  const declarations = new Map([...modules].flatMap(([file, mod]) => [...mod.declarations].map(([name, declaration]) => [`${file}#${name}`, declaration])));
+  function unique(items) {
+    return [
+      ...new Map(items.map((item) => [JSON.stringify(item), item])).values()
+    ];
+  }
+  function isAlias(declaration, ref) {
+    const node = unwrap(declaration.node);
+    if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node))
+      return false;
+    const binding = bindingFor(node.getSourceFile().fileName, node);
+    return !!binding && `${binding.file}#${binding.name}` === ref;
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const declaration of declarations.values()) {
+      for (const ref of declaration.refs) {
+        const child = declarations.get(ref);
+        if (!child?.boundary || !declaration.calls.has(ref) && !isAlias(declaration, ref))
+          continue;
+        if (!declaration.boundary)
+          changed = true;
+        declaration.boundary = true;
+        for (const factory of child.factories) {
+          if (!declaration.factories.has(factory))
+            changed = true;
+          declaration.factories.add(factory);
+        }
+        for (const flag of child.flags) {
+          if (!declaration.flags.has(flag))
+            changed = true;
+          declaration.flags.add(flag);
+        }
+      }
+    }
+  }
+  changed = true;
+  while (changed) {
+    changed = false;
+    for (const declaration of declarations.values()) {
+      const before = JSON.stringify(declaration.usage);
+      for (const ref of declaration.refs) {
+        const child = declarations.get(ref);
+        if (!child)
+          continue;
+        if (child.boundary && !ts.isFunctionLike(unwrap(child.node)) && !isAlias(declaration, ref))
+          continue;
+        declaration.usage.operations.push(...child.usage.operations);
+        declaration.usage.unresolvedRequests.push(...child.usage.unresolvedRequests);
+        declaration.usage.methods.push(...child.usage.methods);
+      }
+      declaration.usage.operations = unique(declaration.usage.operations);
+      declaration.usage.unresolvedRequests = unique(declaration.usage.unresolvedRequests);
+      declaration.usage.methods = unique(declaration.usage.methods);
+      changed ||= before !== JSON.stringify(declaration.usage);
+    }
+  }
+  const result = { exports: new Map, boundaries: [] };
+  function exportNames(file, seen = new Set) {
+    if (seen.has(file))
+      return [];
+    seen.add(file);
+    const mod = modules.get(file);
+    return mod ? [
+      ...mod.exports.keys(),
+      ...mod.stars.flatMap((target) => exportNames(target, seen).filter((name) => name !== "default"))
+    ] : [];
+  }
+  for (const file of modules.keys()) {
+    const exported = new Map;
+    for (const name of new Set(exportNames(file))) {
+      const binding = resolve2({ file, name }, true);
+      const declaration = binding && declarations.get(`${binding.file}#${binding.name}`);
+      if (!declaration)
+        continue;
+      exported.set(name, declaration.usage);
+      if (declaration.boundary)
+        result.boundaries.push({
+          file,
+          name,
+          factories: [...declaration.factories],
+          flags: [...declaration.flags]
+        });
+    }
+    result.exports.set(file, exported);
+  }
+  return result;
+}
+export {
+  analyzeSourceApiUsage
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/api",
-  "version": "0.423.0",
+  "version": "0.424.0",
   "description": "Official auto-generated TypeScript client for the Sentry public REST API",
   "keywords": [
     "sentry",
@@ -42,6 +42,10 @@
     "./operations": {
       "types": "./dist/operations.d.ts",
       "import": "./dist/operations.js"
+    },
+    "./source-analysis": {
+      "types": "./dist/source-analysis.d.ts",
+      "import": "./dist/source-analysis.js"
     }
   },
   "homepage": "https://docs.sentry.io/api/",
@@ -56,10 +60,14 @@
     "url": "https://github.com/getsentry/sentry-api-schema/issues"
   },
   "peerDependencies": {
+    "typescript": "*",
     "valibot": "*",
     "zod": "^3.24.0"
   },
   "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    },
     "valibot": {
       "optional": true
     },