@neat.is/core 0.4.10 → 0.4.11

package/dist/index.cjs

@@ -675,6 +675,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);
 
 // src/policy.ts
 init_cjs_shims();
@@ -1679,6 +1680,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];
@@ -1721,8 +1730,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);
@@ -1739,16 +1753,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_types3.fileId)(serviceName, callSite.relPath);
@@ -1760,6 +1823,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);
@@ -1785,6 +1849,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();
@@ -2020,12 +2090,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_types3.databaseId)(host);
       const result = upsertObservedEdge(
@@ -2041,7 +2112,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(
@@ -3825,8 +3896,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 = [];
@@ -5121,6 +5198,66 @@ function registryPath() {
 function registryLockPath() {
   return import_node_path33.default.join(neatHome(), "projects.json.lock");
 }
+function daemonPidPath() {
+  return import_node_path33.default.join(neatHome(), "neatd.pid");
+}
+function isPidAliveDefault(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function readPidFile(file) {
+  try {
+    const raw = await import_node_fs20.promises.readFile(file, "utf8");
+    const pid = Number.parseInt(raw.trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var defaultLockHolderProbe = {
+  isPidAlive: isPidAliveDefault,
+  daemonPidFromFile: () => readPidFile(daemonPidPath()),
+  async daemonResponds() {
+    const base = process.env.NEAT_API_URL ?? "http://localhost:8080";
+    try {
+      await fetch(`${base}/health`, { signal: AbortSignal.timeout(750) });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+async function readLockPid(lockPath) {
+  return readPidFile(lockPath);
+}
+async function classifyLockHolder(lockPath, probe = defaultLockHolderProbe) {
+  const lockPid = await readLockPid(lockPath);
+  const daemonPid = await probe.daemonPidFromFile();
+  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // The lock already names the daemon, or the daemon answers on its port.
+  // Either confirms a live daemon is in the picture (the second guards
+  // against a stale pidfile whose PID got reused).
+  (daemonPid === lockPid || await probe.daemonResponds())) {
+    return { kind: "daemon", pid: daemonPid };
+  }
+  if (lockPid !== void 0 && lockPid !== process.pid && probe.isPidAlive(lockPid)) {
+    return { kind: "command", pid: lockPid };
+  }
+  return { kind: "stale" };
+}
+function lockHolderMessage(holder, lockPath, timeoutMs) {
+  switch (holder.kind) {
+    case "daemon":
+      return `The neat daemon (pid ${holder.pid}) is holding the registry lock. Register this project through the daemon, or stop neatd and re-run \`neat init\`.`;
+    case "command":
+      return `Another neat command (pid ${holder.pid}) is holding the registry lock. Wait for it to finish, or check \`ps\` if you're not sure what's running.`;
+    case "stale":
+      return `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
+  }
+}
 async function normalizeProjectPath(input) {
   const resolved = import_node_path33.default.resolve(input);
   try {
@@ -5141,21 +5278,31 @@ async function writeAtomically(target, contents) {
   }
   await import_node_fs20.promises.rename(tmp, target);
 }
-async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS) {
+async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
   const deadline = Date.now() + timeoutMs;
   await import_node_fs20.promises.mkdir(import_node_path33.default.dirname(lockPath), { recursive: true });
+  let probedHolder = false;
   while (true) {
     try {
       const fd = await import_node_fs20.promises.open(lockPath, "wx");
-      await fd.close();
+      try {
+        await fd.writeFile(`${process.pid}
+`, "utf8");
+      } finally {
+        await fd.close();
+      }
       return;
     } catch (err) {
       const code = err.code;
       if (code !== "EEXIST") throw err;
+      if (!probedHolder) {
+        probedHolder = true;
+        const holder = await classifyLockHolder(lockPath, probe);
+        if (holder.kind === "daemon") throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
+      }
       if (Date.now() >= deadline) {
-        throw new Error(
-          `neat registry: timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`
-        );
+        const holder = await classifyLockHolder(lockPath, probe);
+        throw new Error(lockHolderMessage(holder, lockPath, timeoutMs));
       }
       await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
     }
@@ -6193,6 +6340,7 @@ async function startDaemon(opts = {}) {
             {
               graph: slot.graph,
               errorsPath: slot.paths.errorsPath,
+              scanPath: slot.entry.path,
               project: slot.entry.name,
               // Receiver already wrote the error event synchronously below.
               writeErrorEventInline: false
@@ -6216,6 +6364,7 @@ async function startDaemon(opts = {}) {
             {
               graph: slot.graph,
               errorsPath: slot.paths.errorsPath,
+              scanPath: slot.entry.path,
               project: slot.entry.name,
               writeErrorEventInline: false
             },