@neat.is/core 0.4.10 → 0.4.11

package/dist/neatd.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   startDaemon
-} from "./chunk-RC3CIDZO.js";
+} from "./chunk-W4RNPPB5.js";
 import {
   listProjects,
   registryPath
-} from "./chunk-J5CEKCTR.js";
+} from "./chunk-OJHI33LD.js";
 import {
   BindAuthorityError,
   __require

package/dist/server.cjs

@@ -1819,6 +1819,7 @@ init_cjs_shims();
 init_cjs_shims();
 var import_node_fs3 = require("fs");
 var import_node_path3 = __toESM(require("path"), 1);
+var sourceMapJs = __toESM(require("source-map-js"), 1);
 var import_types4 = require("@neat.is/types");
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS = 24 * HOUR_MS;
@@ -1864,6 +1865,14 @@ function warnUnidentifiedSpan(project) {
     `[neatd] span lacked service.name; routed to 'unidentified' in project ${project}; check your OTel SDK config.`
   );
 }
+var noSourceMapWarnedServices = /* @__PURE__ */ new Set();
+function warnNoSourceMaps(serviceName) {
+  if (noSourceMapWarnedServices.has(serviceName)) return;
+  noSourceMapWarnedServices.add(serviceName);
+  console.warn(
+    `[neat] ${serviceName}: no .map files found under dist/; observed file edges will land on dist paths, not src. Set sourceMap: true in tsconfig to enable file-level reconciliation.`
+  );
+}
 function pickAttr(span, ...keys) {
   for (const k of keys) {
     const v = span.attributes[k];
@@ -1906,8 +1915,13 @@ function languageForExt(relPath) {
       return void 0;
   }
 }
-function relPathForRuntimeFile(filepath, serviceNode) {
+function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix(filepath).replace(/^file:\/\//, "");
+  if (scanPath && scanPath.length > 0) {
+    const absRoot = toPosix(import_node_path3.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
+    if (p.startsWith(anchor)) return p.slice(anchor.length);
+  }
   const root = serviceNode?.repoPath;
   if (root && root !== "." && root.length > 0) {
     const rootPosix = toPosix(root);
@@ -1924,16 +1938,65 @@ function relPathForRuntimeFile(filepath, serviceNode) {
   p = p.replace(/^[A-Za-z]:/, "").replace(/^\/+/, "");
   return p.length > 0 ? p : null;
 }
-function callSiteFromSpan(span, serviceNode) {
+var sourceMapCache = /* @__PURE__ */ new Map();
+function resolveDistToSrc(absFilepath, line) {
+  if (!absFilepath.endsWith(".js")) return null;
+  let entry = sourceMapCache.get(absFilepath);
+  if (entry === void 0) {
+    entry = null;
+    const mapPath = `${absFilepath}.map`;
+    try {
+      if ((0, import_node_fs3.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs3.readFileSync)(mapPath, "utf8"));
+        const consumer = new sourceMapJs.SourceMapConsumer(raw);
+        entry = { consumer, dir: import_node_path3.default.dirname(mapPath) };
+      }
+    } catch {
+      entry = null;
+    }
+    sourceMapCache.set(absFilepath, entry);
+  }
+  if (!entry) return null;
+  try {
+    const pos = entry.consumer.originalPositionFor({
+      line: line !== void 0 && Number.isFinite(line) ? line : 1,
+      column: 0
+    });
+    if (!pos || !pos.source) return null;
+    const root = entry.consumer.sourceRoot ?? "";
+    const resolved = import_node_path3.default.resolve(entry.dir, root, pos.source);
+    return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
+  } catch {
+    return null;
+  }
+}
+function callSiteFromSpan(span, serviceNode, scanPath) {
   const filepath = span.attributes[CODE_FILEPATH_ATTR];
   if (typeof filepath !== "string" || filepath.length === 0) return null;
-  const relPath = relPathForRuntimeFile(filepath, serviceNode);
-  if (!relPath) return null;
   const linenoRaw = span.attributes[CODE_LINENO_ATTR];
-  const line = typeof linenoRaw === "number" && Number.isFinite(linenoRaw) ? linenoRaw : void 0;
+  let line = typeof linenoRaw === "number" && Number.isFinite(linenoRaw) ? linenoRaw : void 0;
+  const abs = toPosix(filepath).replace(/^file:\/\//, "");
+  const resolved = resolveDistToSrc(abs, line);
+  let effectivePath = filepath;
+  let originalRelPath;
+  if (resolved) {
+    originalRelPath = relPathForRuntimeFile(filepath, serviceNode, scanPath) ?? void 0;
+    effectivePath = resolved.filepath;
+    if (resolved.line !== void 0) line = resolved.line;
+  }
+  const relPath = relPathForRuntimeFile(effectivePath, serviceNode, scanPath);
+  if (!relPath) return null;
+  if (!resolved && abs.endsWith(".js") && relPath.startsWith("dist/") && serviceNode?.name) {
+    warnNoSourceMaps(serviceNode.name);
+  }
   const fnRaw = span.attributes[CODE_FUNCTION_ATTR];
   const fn = typeof fnRaw === "string" && fnRaw.length > 0 ? fnRaw : void 0;
-  return { relPath, ...line !== void 0 ? { line } : {}, ...fn ? { fn } : {} };
+  return {
+    relPath,
+    ...line !== void 0 ? { line } : {},
+    ...fn ? { fn } : {},
+    ...originalRelPath && originalRelPath !== relPath ? { originalRelPath } : {}
+  };
 }
 function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
   const fileNodeId = (0, import_types4.fileId)(serviceName, callSite.relPath);
@@ -1945,6 +2008,7 @@ function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
       service: serviceName,
       path: callSite.relPath,
       ...language ? { language } : {},
+      ...callSite.originalRelPath ? { originalPath: callSite.originalRelPath } : {},
       discoveredVia: "otel"
     };
     graph.addNode(fileNodeId, node);
@@ -1970,6 +2034,12 @@ function makeInferredEdgeId(type, source, target) {
 }
 var INFERRED_CONFIDENCE = 0.6;
 var STITCH_MAX_DEPTH = 2;
+var WIRE_SPAN_KIND_CLIENT = 3;
+var WIRE_SPAN_KIND_PRODUCER = 4;
+function spanMintsObservedEdge(kind) {
+  if (kind === void 0 || kind === 0) return true;
+  return kind === WIRE_SPAN_KIND_CLIENT || kind === WIRE_SPAN_KIND_PRODUCER;
+}
 var PARENT_SPAN_CACHE_SIZE = 1e4;
 var PARENT_SPAN_CACHE_TTL_MS = 5 * 60 * 1e3;
 var parentSpanCache = /* @__PURE__ */ new Map();
@@ -2180,12 +2250,13 @@ async function handleSpan(ctx, span) {
   const isError = span.statusCode === 2;
   cacheSpanService(span, nowMs);
   const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
-  const callSite = callSiteFromSpan(span, sourceServiceNode);
+  const callSite = callSiteFromSpan(span, sourceServiceNode, ctx.scanPath);
   const observedSource = () => callSite ? ensureObservedFileNode(ctx.graph, span.service, sourceId, callSite) : sourceId;
   let affectedNode = sourceId;
+  const mintsFromCallerSide = spanMintsObservedEdge(span.kind);
   if (span.dbSystem) {
     const host = pickAddress(span);
-    if (host) {
+    if (mintsFromCallerSide && host) {
       ensureDatabaseNode(ctx.graph, host, span.dbSystem);
       const targetId = (0, import_types4.databaseId)(host);
       const result = upsertObservedEdge(
@@ -2201,7 +2272,7 @@ async function handleSpan(ctx, span) {
   } else {
     const host = pickAddress(span);
     let resolvedViaAddress = false;
-    if (host && host !== span.service) {
+    if (mintsFromCallerSide && host && host !== span.service) {
       const targetId = resolveServiceId(ctx.graph, host, env);
       if (targetId && targetId !== sourceId) {
         upsertObservedEdge(
@@ -3985,8 +4056,14 @@ function collectStringLiterals(node, out) {
     if (child) collectStringLiterals(child, out);
   }
 }
+var PARSE_CHUNK = 16384;
+function parseSource(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK)
+  );
+}
 function callsFromSource(source, parser, knownHosts) {
-  const tree = parser.parse(source);
+  const tree = parseSource(parser, source);
   const literals = [];
   collectStringLiterals(tree.rootNode, literals);
   const out = [];