@neat.is/core 0.9.10-dev.20260830 → 0.9.11

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-QETJIA2Q.js";
+} from "./chunk-UNO3X6ZV.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,7 +37,7 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-B6KJG5KN.js";
+} from "./chunk-3UAUMPIY.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-ERE47MCR.js";

package/dist/neatd.cjs

@@ -1828,6 +1828,24 @@ function incidentCountForNode(nodeId, incidents) {
   if (!incidents || incidents.length === 0) return 0;
   return incidents.filter((ev) => incidentMatchesNode(ev, nodeId)).length;
 }
+var DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
+  import_types.EdgeType.CALLS,
+  import_types.EdgeType.CONNECTS_TO,
+  import_types.EdgeType.PUBLISHES_TO,
+  import_types.EdgeType.CONSUMES_FROM
+]);
+var TIMEOUT_ERROR_PATTERNS = [
+  /\bDEADLINE_EXCEEDED\b/i,
+  /\bdeadline exceeded\b/i,
+  /\bETIMEDOUT\b/i,
+  /\btimed[\s-]?out\b/i,
+  /\btimeout\b/i
+];
+function isBoundaryTimeoutError(ev) {
+  if (ev.httpStatusCode === 504) return true;
+  const haystack = [ev.errorType, ev.exceptionType, ev.errorMessage].filter((s) => typeof s === "string").join(" \n ");
+  return TIMEOUT_ERROR_PATTERNS.some((re) => re.test(haystack));
+}
 function nodeContext(graph, nodeId, incidents, now = Date.now()) {
   const scope = nodeScope(graph, nodeId);
   let errorsFromCallers = 0;
@@ -1837,6 +1855,8 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
   let latestInboundMs;
   let latencyP95Ms;
   let stale = false;
+  let observedErroringDownstream = false;
+  let hasOutboundDeps = false;
   for (const n of scope) {
     if (!graph.hasNode(n)) continue;
     for (const edgeId of graph.inboundEdges(n)) {
@@ -1858,10 +1878,17 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
       outboundVolume += e.callCount ?? e.signal?.spanCount ?? 0;
       if (e.type === import_types.EdgeType.CALLS) outboundErrors += e.signal?.errorCount ?? 0;
       if (e.provenance === import_types.Provenance.STALE) stale = true;
+      if (DEP_EDGE_TYPES.has(e.type)) {
+        hasOutboundDeps = true;
+        if ((e.signal?.errorCount ?? 0) > 0) observedErroringDownstream = true;
+      }
     }
   }
   const errorsEmittedHere = incidentCountForNode(nodeId, incidents) + outboundErrors;
   const lastObservedAgeMs = latestInboundMs !== void 0 ? Math.max(0, now - latestInboundMs) : void 0;
+  const boundaryTimeout = (incidents ?? []).some(
+    (ev) => incidentMatchesNode(ev, nodeId) && isBoundaryTimeoutError(ev)
+  );
   return {
     errorsEmittedHere,
     errorsFromCallers,
@@ -1869,17 +1896,24 @@ function nodeContext(graph, nodeId, incidents, now = Date.now()) {
     outboundVolume,
     ...lastObservedAgeMs !== void 0 ? { lastObservedAgeMs } : {},
     ...latencyP95Ms !== void 0 ? { latencyP95Ms } : {},
-    stale
+    stale,
+    boundaryTimeout,
+    observedErroringDownstream,
+    hasOutboundDeps
   };
 }
 function isSaturated(ctx) {
   return ctx.latencyP95Ms !== void 0 && ctx.latencyP95Ms >= SATURATION_P95_MS;
 }
+function isBoundaryTimeoutSymptom(ctx) {
+  return ctx.errorsEmittedHere > 0 && ctx.boundaryTimeout === true && ctx.errorsFromCallers === 0 && ctx.hasOutboundDeps === true && ctx.observedErroringDownstream !== true;
+}
 function classifyNode(ctx) {
   if (ctx.errorsEmittedHere > 0) {
     if ((ctx.stale || isSaturated(ctx)) && ctx.errorsFromCallers >= ctx.errorsEmittedHere) {
       return "symptom-only";
     }
+    if (isBoundaryTimeoutSymptom(ctx)) return "symptom-only";
     return "primary-failure";
   }
   if (ctx.errorsFromCallers > 0) return "symptom-only";
@@ -2084,6 +2118,57 @@ function getRootCause(graph, errorNodeId, errorEvent, incidents, opts) {
   if (!navigation) return tagged.result;
   return enrichWithNavigation(graph, errorNodeId, tagged, incidents, opts?.now ?? Date.now());
 }
+function boundaryIncidentRoute(nodeId, incidents) {
+  for (const ev of incidents ?? []) {
+    if (!incidentMatchesNode(ev, nodeId)) continue;
+    const r = ev.attributes?.["http.route"] ?? ev.attributes?.["http.target"] ?? ev.attributes?.["url.path"];
+    if (typeof r === "string" && r.length > 0) return r;
+  }
+  return void 0;
+}
+function declaredOutboundCallees(graph, nodeId) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const n of nodeScope(graph, nodeId)) {
+    if (!graph.hasNode(n)) continue;
+    for (const edgeId of graph.outboundEdges(n)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (!DEP_EDGE_TYPES.has(e.type)) continue;
+      if (e.provenance !== import_types.Provenance.EXTRACTED) continue;
+      if (e.target === nodeId || byTarget.has(e.target)) continue;
+      const route = e.evidence?.pathTemplate;
+      byTarget.set(
+        e.target,
+        route !== void 0 ? { target: e.target, route } : { target: e.target }
+      );
+    }
+  }
+  return [...byTarget.values()];
+}
+function normalizeRoute(s) {
+  return s.replace(/\/+$/, "").toLowerCase();
+}
+function routeMatches(declared, incident) {
+  const a = normalizeRoute(declared);
+  const b = normalizeRoute(incident);
+  return a === b || a.startsWith(b) || b.startsWith(a);
+}
+function structuralUpstreamPointer(graph, boundaryNode, incidents) {
+  const route = boundaryIncidentRoute(boundaryNode, incidents);
+  const callees = declaredOutboundCallees(graph, boundaryNode);
+  if (callees.length === 0) return null;
+  const narrowed = route !== void 0 ? callees.filter((c) => c.route !== void 0 && routeMatches(c.route, route)) : callees;
+  const chosen = narrowed.length === 1 ? narrowed[0] : callees.length === 1 ? callees[0] : null;
+  if (!chosen) return null;
+  let node = chosen.target;
+  const seen = /* @__PURE__ */ new Set([boundaryNode, node]);
+  for (let depth = 0; depth < ROOT_CAUSE_MAX_DEPTH; depth++) {
+    const next = declaredOutboundCallees(graph, node);
+    if (next.length !== 1 || seen.has(next[0].target)) break;
+    node = next[0].target;
+    seen.add(node);
+  }
+  return route !== void 0 ? { node, route } : { node };
+}
 function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
   const legacy = tagged.result;
   const seedNode = legacy.rootCauseNode;
@@ -2117,6 +2202,29 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
       confidence: Math.min(legacy.confidence, 0.4),
       ...lastProv ? { provenance: lastProv } : {}
     });
+  } else if (seedCtx && isBoundaryTimeoutSymptom(seedCtx)) {
+    const pointer = structuralUpstreamPointer(graph, seedNode, incidents);
+    const seedName = displayNameOf(seedNode);
+    const routeNote = pointer?.route ? ` serving ${pointer.route}` : "";
+    if (pointer) {
+      const causeName = displayNameOf(pointer.node);
+      candidates.push({
+        node: pointer.node,
+        classification: "primary-failure",
+        reason: `${causeName} is the likely root cause (structural, INFERRED \u2014 not observed): the boundary ${seedName} only timed out waiting, and the actual culprit hung without exporting a span, so this is walked from the declared call graph${routeNote}, not from runtime signal. Restore instrumentation / inspect ${causeName} to confirm.`,
+        context: nodeContext(graph, pointer.node, incidents, now),
+        confidence: Math.min(legacy.confidence, PROVENANCE_CEILING.EXTRACTED),
+        provenance: import_types.Provenance.INFERRED
+      });
+    }
+    candidates.push({
+      node: seedNode,
+      classification: "symptom-only",
+      reason: pointer ? `${seedName} timed out waiting on a downstream that hung and exported nothing \u2014 a boundary reporting an upstream fault, not the fault itself.` : `${seedName} timed out but nothing it can see downstream is erroring \u2014 the cause is downstream and unobserved (the culprit hung and exported no span). No single declared callee${routeNote} resolves, so no confident cause is named; inspect ${seedName}'s declared downstream.`,
+      context: seedCtx,
+      confidence: Math.min(legacy.confidence, 0.3),
+      ...lastProv ? { provenance: lastProv } : {}
+    });
   } else if (staleChain) {
     const culprit = staleChain.culprit;
     const culpritName = displayNameOf(culprit);
@@ -6422,6 +6530,7 @@ function buildErrorEventForReceiver(span, graph, scanPath) {
   const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
   const locus = incidentLocus(span, graph, scanPath);
   const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
+  const httpStatus = httpResponseStatus(span);
   return {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
@@ -6431,6 +6540,7 @@ function buildErrorEventForReceiver(span, graph, scanPath) {
     errorMessage: incidentMessage(span),
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+    ...httpStatus !== void 0 ? { httpStatusCode: httpStatus } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
     affectedNode: locus.affectedNode
   };
@@ -6782,26 +6892,8 @@ async function handleSpan(ctx, span) {
   if (span.statusCode === 2) {
     stitchTrace(ctx.graph, sourceId, ts);
     if (ctx.writeErrorEventInline !== false) {
-      const locus = incidentLocus(span, ctx.graph, ctx.scanPath);
-      const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
-      const ev = {
-        id: `${span.traceId}:${span.spanId}`,
-        timestamp: ts,
-        service: span.service,
-        traceId: span.traceId,
-        spanId: span.spanId,
-        errorMessage: incidentMessage(span),
-        ...span.exception?.type ? { exceptionType: span.exception.type } : {},
-        ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
-        ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-        // Attribute to where the failure originated — the symbol / file / service
-        // the throwing span named (incidentAffectedNode / ADR-191, extended to
-        // recover the locus from the stacktrace when the span stamped no code.*
-        // attrs, ADR-216) — the same source-based attribution the durable
-        // receiver write uses, not the outbound edge target this span minted.
-        affectedNode: locus.affectedNode
-      };
-      await appendErrorEvent(ctx, ev);
+      const ev = buildErrorEventForReceiver(span, ctx.graph, ctx.scanPath);
+      if (ev) await appendErrorEvent(ctx, ev);
     }
   }
   if (span.statusCode !== 2) {