@neat.is/core 0.3.5 → 0.3.7

package/dist/index.d.cts

@@ -358,6 +358,29 @@ interface DaemonHandle {
  *
  * Pure function. Daemon callers pass a snapshot of the registry to avoid
  * per-span fs reads.
+ *
+ * Matching order (ADR-072 — real-world `service.name` rarely equals project
+ * name; monorepos publish per-package names like `brief-api` under a
+ * project named `brief`):
+ *
+ *   1. Exact: `entry.name === serviceName`.
+ *   2. Hyphen/underscore-separated prefix: `entry.name` is a leading token
+ *      of `serviceName` (`brief` matches `brief-api`, `brief_worker`).
+ *      Longest-match wins so `brief-api` beats `brief` when both are
+ *      registered.
+ *   3. Containment as a separator-delimited token (`api` inside
+ *      `brief-api-staging`).
+ *
+ * Routing eligibility (ADR-071):
+ * - `active` matches at every pass (the steady-state path).
+ * - `broken` also matches — the daemon needs the span to reach the broken
+ *   slot so the ingest-time auto-recover path can attempt a bootstrap and
+ *   lift the project back to `active`. The router only chooses the target;
+ *   whether the span actually lands is the ingest handler's decision.
+ * - `paused` is intentionally not routed; the operator paused it on
+ *   purpose, so the span falls through to the default-project flow.
+ *
+ * Falls back to `DEFAULT_PROJECT` when nothing matches.
  */
 declare function routeSpanToProject(serviceName: string | undefined, projects: ReadonlyArray<RegistryEntry>): string;
 declare function startDaemon(opts?: DaemonOptions): Promise<DaemonHandle>;

package/dist/index.d.ts

@@ -358,6 +358,29 @@ interface DaemonHandle {
  *
  * Pure function. Daemon callers pass a snapshot of the registry to avoid
  * per-span fs reads.
+ *
+ * Matching order (ADR-072 — real-world `service.name` rarely equals project
+ * name; monorepos publish per-package names like `brief-api` under a
+ * project named `brief`):
+ *
+ *   1. Exact: `entry.name === serviceName`.
+ *   2. Hyphen/underscore-separated prefix: `entry.name` is a leading token
+ *      of `serviceName` (`brief` matches `brief-api`, `brief_worker`).
+ *      Longest-match wins so `brief-api` beats `brief` when both are
+ *      registered.
+ *   3. Containment as a separator-delimited token (`api` inside
+ *      `brief-api-staging`).
+ *
+ * Routing eligibility (ADR-071):
+ * - `active` matches at every pass (the steady-state path).
+ * - `broken` also matches — the daemon needs the span to reach the broken
+ *   slot so the ingest-time auto-recover path can attempt a bootstrap and
+ *   lift the project back to `active`. The router only chooses the target;
+ *   whether the span actually lands is the ingest handler's decision.
+ * - `paused` is intentionally not routed; the operator paused it on
+ *   purpose, so the span falls through to the default-project flow.
+ *
+ * Falls back to `DEFAULT_PROJECT` when nothing matches.
  */
 declare function routeSpanToProject(serviceName: string | undefined, projects: ReadonlyArray<RegistryEntry>): string;
 declare function startDaemon(opts?: DaemonOptions): Promise<DaemonHandle>;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   routeSpanToProject,
   startDaemon
-} from "./chunk-KCEZSFU2.js";
+} from "./chunk-EDHOCFOG.js";
 import {
   ProjectNameCollisionError,
   addProject,
@@ -37,15 +37,15 @@ import {
   thresholdForEdgeType,
   touchLastSeen,
   writeAtomically
-} from "./chunk-BUB3ASD5.js";
+} from "./chunk-ZU2RQRCN.js";
 import {
   startOtelGrpcReceiver
-} from "./chunk-G3PDTGOW.js";
+} from "./chunk-CY67YKNO.js";
 import {
   buildOtelReceiver,
   logSpanHandler,
   parseOtlpRequest
-} from "./chunk-4ASCXBZF.js";
+} from "./chunk-75IBA4UL.js";
 export {
   ProjectNameCollisionError,
   addProject,

package/dist/neatd.cjs

@@ -257,8 +257,7 @@ function parseOtlpRequest(body) {
   }
   return out;
 }
-function loadProtobufDecoder() {
-  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+function loadProtoRoot() {
   const here = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
   const protoRoot = import_node_path35.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
@@ -267,11 +266,32 @@ function loadProtobufDecoder() {
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
   );
+  return root;
+}
+function loadProtobufDecoder() {
+  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+  const root = loadProtoRoot();
   exportTraceServiceRequestType = root.lookupType(
     "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
   );
   return exportTraceServiceRequestType;
 }
+function loadProtobufResponseEncoder() {
+  if (exportTraceServiceResponseType) return exportTraceServiceResponseType;
+  const root = loadProtoRoot();
+  exportTraceServiceResponseType = root.lookupType(
+    "opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse"
+  );
+  return exportTraceServiceResponseType;
+}
+function encodeProtobufResponseBody() {
+  if (cachedProtobufResponseBody) return cachedProtobufResponseBody;
+  const Type = loadProtobufResponseEncoder();
+  const msg = Type.create({});
+  const encoded = Type.encode(msg).finish();
+  cachedProtobufResponseBody = Buffer.from(encoded);
+  return cachedProtobufResponseBody;
+}
 async function decodeProtobufBody(buf) {
   const Type = loadProtobufDecoder();
   const decoded = Type.decode(buf).toJSON();
@@ -318,7 +338,9 @@ async function buildOtelReceiver(opts) {
   app.post("/v1/traces", async (req2, reply) => {
     const ct = (req2.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
     let body;
+    let responseFlavor;
     if (ct === "application/x-protobuf") {
+      responseFlavor = "protobuf";
       try {
         body = await decodeProtobufBody(req2.body);
       } catch (err) {
@@ -327,6 +349,7 @@ async function buildOtelReceiver(opts) {
         });
       }
     } else if (!ct || ct === "application/json") {
+      responseFlavor = "json";
       body = req2.body ?? {};
     } else {
       return reply.code(415).send({ error: `unsupported content-type: ${ct}` });
@@ -344,7 +367,11 @@ async function buildOtelReceiver(opts) {
       }
     }
     enqueue(spans);
-    return reply.code(200).send({ partialSuccess: {} });
+    if (responseFlavor === "protobuf") {
+      const buf = encodeProtobufResponseBody();
+      return reply.code(200).header("content-type", "application/x-protobuf").send(buf);
+    }
+    return reply.code(200).header("content-type", "application/json").send({ partialSuccess: {} });
   });
   const decorated = app;
   decorated.flushPending = async () => {
@@ -354,7 +381,7 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
+var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
@@ -364,6 +391,8 @@ var init_otel = __esm({
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
     exportTraceServiceRequestType = null;
+    exportTraceServiceResponseType = null;
+    cachedProtobufResponseBody = null;
   }
 });
 
@@ -371,6 +400,7 @@ var init_otel = __esm({
 init_cjs_shims();
 var import_node_fs22 = require("fs");
 var import_node_path38 = __toESM(require("path"), 1);
+var import_node_module = require("module");
 
 // src/daemon.ts
 init_cjs_shims();
@@ -1585,7 +1615,7 @@ function buildErrorEventForReceiver(span) {
     service: span.service,
     traceId: span.traceId,
     spanId: span.spanId,
-    errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+    errorMessage: span.exception?.message ?? "unknown error",
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -1677,7 +1707,7 @@ async function handleSpan(ctx, span) {
         service: span.service,
         traceId: span.traceId,
         spanId: span.spanId,
-        errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+        errorMessage: span.exception?.message ?? "unknown error",
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -5054,13 +5084,35 @@ function neatHomeFor(opts) {
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
   for (const entry2 of projects) {
-    if (entry2.status !== "active") continue;
-    if (entry2.languages.length === 0) {
-    }
+    if (entry2.status === "paused") continue;
     if (entry2.name === serviceName) return entry2.name;
   }
+  const candidates = [];
+  for (const entry2 of projects) {
+    if (entry2.status === "paused") continue;
+    if (isTokenPrefix(entry2.name, serviceName)) candidates.push(entry2);
+  }
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => b.name.length - a.name.length);
+    return candidates[0].name;
+  }
+  for (const entry2 of projects) {
+    if (entry2.status === "paused") continue;
+    if (isTokenContained(entry2.name, serviceName)) return entry2.name;
+  }
   return DEFAULT_PROJECT;
 }
+function isTokenPrefix(prefix, full) {
+  if (prefix.length >= full.length) return false;
+  if (!full.startsWith(prefix)) return false;
+  const sep = full.charAt(prefix.length);
+  return sep === "-" || sep === "_";
+}
+function isTokenContained(needle, haystack) {
+  if (!haystack.includes(needle)) return false;
+  const tokens = haystack.split(/[-_]/);
+  return tokens.includes(needle);
+}
 async function bootstrapProject(entry2) {
   const paths = pathsForProject(entry2.name, import_node_path36.default.join(entry2.path, "neat-out"));
   try {
@@ -5140,6 +5192,17 @@ async function startDaemon(opts = {}) {
 `);
   const slots = /* @__PURE__ */ new Map();
   const registry = new Projects();
+  const DROP_WARN_INTERVAL_MS = 6e4;
+  const lastDropWarnAt = /* @__PURE__ */ new Map();
+  function warnDroppedSpan(project, reason) {
+    const now = Date.now();
+    const prev = lastDropWarnAt.get(project) ?? 0;
+    if (now - prev < DROP_WARN_INTERVAL_MS) return;
+    lastDropWarnAt.set(project, now);
+    console.warn(
+      `[neatd] dropping span for project "${project}" \u2014 project status: broken (${reason}). Run \`neatd reload\` to retry bootstrap.`
+    );
+  }
   function upsertRegistryFromSlot(slot) {
     if (slot.status !== "active") return;
     registry.set(slot.entry.name, {
@@ -5148,12 +5211,38 @@ async function startDaemon(opts = {}) {
       graph: slot.graph
     });
   }
+  async function tryRecoverSlot(entry2) {
+    try {
+      const fresh = await bootstrapProject(entry2);
+      slots.set(entry2.name, fresh);
+      upsertRegistryFromSlot(fresh);
+      if (fresh.status === "active") {
+        await setStatus(entry2.name, "active").catch(() => {
+        });
+        console.log(
+          `neatd: project "${entry2.name}" recovered from broken \u2014 active`
+        );
+      }
+      return fresh;
+    } catch (err) {
+      console.warn(
+        `neatd: project "${entry2.name}" still broken after recovery attempt \u2014 ${err.message}`
+      );
+      return slots.get(entry2.name);
+    }
+  }
   async function loadAll() {
     const projects = await listProjects();
     const seen = /* @__PURE__ */ new Set();
     for (const entry2 of projects) {
       seen.add(entry2.name);
-      if (slots.has(entry2.name)) continue;
+      const existing = slots.get(entry2.name);
+      if (existing) {
+        if (existing.status === "broken") {
+          await tryRecoverSlot(entry2);
+        }
+        continue;
+      }
       try {
         const slot = await bootstrapProject(entry2);
         slots.set(entry2.name, slot);
@@ -5210,13 +5299,28 @@ async function startDaemon(opts = {}) {
         `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
       );
     }
+    async function resolveTargetSlot(serviceName) {
+      const liveEntries = await listProjects().catch(() => []);
+      const target = routeSpanToProject(serviceName, liveEntries);
+      let slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
+      if (!slot) return null;
+      if (slot.status === "broken") {
+        const entry2 = liveEntries.find((e) => e.name === slot.entry.name);
+        if (entry2) {
+          slot = await tryRecoverSlot(entry2);
+        }
+        if (slot.status !== "active") {
+          warnDroppedSpan(slot.entry.name, slot.errorReason ?? "unknown");
+          return null;
+        }
+      }
+      return slot.status === "active" ? slot : null;
+    }
     try {
       otlpApp = await buildOtelReceiver({
         onSpan: async (span) => {
-          const liveEntries = await listProjects().catch(() => []);
-          const target = routeSpanToProject(span.service, liveEntries);
-          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
-          if (!slot || slot.status !== "active") return;
+          const slot = await resolveTargetSlot(span.service);
+          if (!slot) return;
           await handleSpan(
             {
               graph: slot.graph,
@@ -5229,10 +5333,8 @@ async function startDaemon(opts = {}) {
           );
         },
         onErrorSpanSync: async (span) => {
-          const liveEntries = await listProjects().catch(() => []);
-          const target = routeSpanToProject(span.service, liveEntries);
-          const slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
-          if (!slot || slot.status !== "active") return;
+          const slot = await resolveTargetSlot(span.service);
+          if (!slot) return;
           await makeErrorSpanWriter(slot.paths.errorsPath)(span);
         }
       });
@@ -5389,7 +5491,83 @@ async function spawnWebUI(restPort) {
   return { child, port, stop };
 }
 
+// src/version-skew.ts
+init_cjs_shims();
+var import_promises = require("timers/promises");
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/neat.is/latest";
+var DEFAULT_TIMEOUT_MS = 2e3;
+async function fetchRegistryVersion(url, timeoutMs, fetchImpl) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = (0, import_promises.setTimeout)(timeoutMs).then(() => {
+    timedOut = true;
+    controller.abort();
+  });
+  try {
+    const res = await Promise.race([
+      fetchImpl(url, { signal: controller.signal, headers: { accept: "application/json" } }),
+      timer.then(() => null)
+    ]);
+    if (timedOut || !res) return null;
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (typeof body.version !== "string" || body.version.length === 0) return null;
+    return body.version;
+  } catch {
+    return null;
+  } finally {
+    if (!timedOut) controller.abort();
+  }
+}
+function isLocalBehind(local, remote) {
+  if (local === remote) return false;
+  const parse10 = (v) => {
+    const core = v.split(/[-+]/)[0] ?? v;
+    return core.split(".").map((s) => {
+      const n = Number.parseInt(s, 10);
+      return Number.isFinite(n) ? n : 0;
+    });
+  };
+  const a = parse10(local);
+  const b = parse10(remote);
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+async function checkVersionSkew(opts) {
+  const url = opts.registryUrl ?? NPM_REGISTRY_URL;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const warn = opts.warn ?? ((m) => console.warn(m));
+  const remote = await fetchRegistryVersion(url, timeoutMs, fetchImpl);
+  if (!remote) return { remoteVersion: null, skewed: false, warned: false };
+  if (!isLocalBehind(opts.localVersion, remote)) {
+    return { remoteVersion: remote, skewed: false, warned: false };
+  }
+  warn(
+    `[neatd] running neat.is@${opts.localVersion} but neat.is@${remote} is on npm \u2014 run \`npm install -g neat.is@latest\` to update`
+  );
+  return { remoteVersion: remote, skewed: true, warned: true };
+}
+
 // src/neatd.ts
+function localVersion() {
+  if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
+    return process.env.NEAT_LOCAL_VERSION;
+  }
+  try {
+    const req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req2("../package.json");
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 function neatHome2() {
   if (process.env.NEAT_HOME && process.env.NEAT_HOME.length > 0) {
     return import_node_path38.default.resolve(process.env.NEAT_HOME);
@@ -5419,6 +5597,10 @@ async function cmdStart() {
   console.log(`neatd: registry at ${registryPath()}`);
   if (handle.restAddress) console.log(`neatd: REST  \u2192 ${handle.restAddress}`);
   if (handle.otlpAddress) console.log(`neatd: OTLP  \u2192 ${handle.otlpAddress}`);
+  if (process.env.NEAT_DISABLE_VERSION_CHECK !== "1") {
+    void checkVersionSkew({ localVersion: localVersion() }).catch(() => {
+    });
+  }
   const skipWeb = process.env.NEAT_WEB_DISABLED === "1";
   let web = null;
   if (!skipWeb) {