@neat.is/core 0.4.27 → 0.4.28-dev.20260708

package/dist/chunk-XV4D7A3Z.js

@@ -1,907 +0,0 @@
-import {
-  DEFAULT_PROJECT,
-  Projects,
-  attachGraphToEventBus,
-  buildApi,
-  ensureObservedFileNode,
-  ensureServiceNode,
-  extractFromDirectory,
-  getGraph,
-  handleSpan,
-  listProjects,
-  loadGraphFromDisk,
-  makeErrorSpanWriter,
-  pathsForProject,
-  pruneRegistry,
-  reconcileObservedRelPath,
-  registryPath,
-  resetGraph,
-  saveGraphToDisk,
-  setStatus,
-  startPersistLoop,
-  startStalenessLoop,
-  touchLastSeen,
-  upsertObservedEdge,
-  writeAtomically
-} from "./chunk-QM6BMPVJ.js";
-import {
-  assertBindAuthority,
-  buildOtelReceiver,
-  listenSteppingOtlp,
-  readAuthEnv
-} from "./chunk-A3322JYS.js";
-
-// src/daemon.ts
-import {
-  promises as fs2,
-  watch,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import path2 from "path";
-import { createRequire } from "module";
-
-// src/connectors/index.ts
-var NO_ENV = "unknown";
-async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
-  const signals = await connector.poll(ctx);
-  let edgesCreated = 0;
-  let edgesUpdated = 0;
-  let unresolved = 0;
-  for (const signal of signals) {
-    const resolved = resolveTarget(signal, ctx);
-    if (!resolved) {
-      unresolved++;
-      continue;
-    }
-    const serviceNodeId = ensureServiceNode(graph, resolved.serviceName, NO_ENV);
-    const callSite = signal.callSite ? { relPath: signal.callSite.file, line: signal.callSite.line } : void 0;
-    const sourceId = callSite ? ensureObservedFileNode(graph, resolved.serviceName, serviceNodeId, callSite) : serviceNodeId;
-    const evidence = callSite ? {
-      file: reconcileObservedRelPath(graph, resolved.serviceName, callSite.relPath),
-      line: callSite.line
-    } : void 0;
-    const calls = Math.trunc(signal.callCount);
-    if (calls < 1) continue;
-    const errors = Math.min(Math.max(Math.trunc(signal.errorCount), 0), calls);
-    let created = false;
-    let ok = true;
-    for (let i = 0; i < calls; i++) {
-      const result = upsertObservedEdge(
-        graph,
-        resolved.edgeType,
-        sourceId,
-        resolved.targetNodeId,
-        signal.lastObservedIso,
-        i < errors,
-        evidence
-      );
-      if (!result) {
-        ok = false;
-        break;
-      }
-      if (i === 0) created = result.created;
-    }
-    if (!ok) {
-      unresolved++;
-      continue;
-    }
-    if (created) edgesCreated++;
-    else edgesUpdated++;
-  }
-  return { signalCount: signals.length, edgesCreated, edgesUpdated, unresolved };
-}
-var DEFAULT_POLL_INTERVAL_MS = 6e4;
-function startConnectorPollLoop(connector, ctx, graph, resolveTarget, options = {}) {
-  let stopped = false;
-  let since = ctx.since;
-  const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const onError = options.onError ?? ((err) => console.error(`[neatd] connector poll failed (${connector.provider})`, err));
-  const tick = () => {
-    if (stopped) return;
-    void (async () => {
-      const tickStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-      try {
-        await runConnectorPoll(connector, { ...ctx, since }, graph, resolveTarget);
-        since = tickStartedAt;
-      } catch (err) {
-        onError(err);
-      }
-    })();
-  };
-  const interval = setInterval(tick, intervalMs);
-  if (typeof interval.unref === "function") interval.unref();
-  return () => {
-    stopped = true;
-    clearInterval(interval);
-  };
-}
-
-// src/unrouted.ts
-import { promises as fs } from "fs";
-import path from "path";
-function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new Date()) {
-  return {
-    timestamp: now.toISOString(),
-    reason: "no-project-match",
-    service_name: serviceName ?? null,
-    traceId: traceId ?? null
-  };
-}
-async function appendUnroutedSpan(neatHome, record) {
-  const target = path.join(neatHome, "errors.ndjson");
-  await fs.mkdir(neatHome, { recursive: true });
-  await fs.appendFile(target, JSON.stringify(record) + "\n", "utf8");
-}
-function unroutedErrorsPath(neatHome) {
-  return path.join(neatHome, "errors.ndjson");
-}
-
-// src/daemon.ts
-import { NodeType } from "@neat.is/types";
-function daemonJsonPath(scanPath) {
-  return path2.join(scanPath, "neat-out", "daemon.json");
-}
-function daemonsDiscoveryDir(home) {
-  const base = home && home.length > 0 ? home : neatHomeFromEnv();
-  return path2.join(base, "daemons");
-}
-function daemonDiscoveryPath(project, home) {
-  return path2.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
-}
-function sanitizeDiscoveryName(project) {
-  return project.replace(/[^A-Za-z0-9._-]/g, "_");
-}
-function neatHomeFromEnv() {
-  const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path2.resolve(env);
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path2.join(home, ".neat");
-}
-async function readDaemonRecord(scanPath) {
-  try {
-    const raw = await fs2.readFile(daemonJsonPath(scanPath), "utf8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.project === "string" && parsed.ports && typeof parsed.ports.rest === "number" && typeof parsed.ports.otlp === "number" && typeof parsed.ports.web === "number") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function resolveNeatVersion() {
-  if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
-    return process.env.NEAT_LOCAL_VERSION;
-  }
-  try {
-    const req = createRequire(import.meta.url);
-    const pkg = req("../package.json");
-    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-async function writeDaemonRecord(record, home) {
-  const body = JSON.stringify(record, null, 2) + "\n";
-  await writeAtomically(daemonJsonPath(record.projectPath), body);
-  try {
-    await writeAtomically(daemonDiscoveryPath(record.project, home), body);
-  } catch (err) {
-    console.warn(
-      `neatd: could not write discovery copy for "${record.project}" \u2014 ${err.message}`
-    );
-  }
-}
-async function clearDaemonRecord(record, home) {
-  try {
-    const stopped = { ...record, status: "stopped" };
-    await writeAtomically(daemonJsonPath(record.projectPath), JSON.stringify(stopped, null, 2) + "\n");
-  } catch {
-  }
-  try {
-    await fs2.unlink(daemonDiscoveryPath(record.project, home));
-  } catch {
-  }
-}
-function reconcileDaemonRecordSync(record, home) {
-  try {
-    const stopped = { ...record, status: "stopped" };
-    const target = daemonJsonPath(record.projectPath);
-    const tmp = `${target}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(stopped, null, 2) + "\n");
-    renameSync(tmp, target);
-  } catch {
-  }
-  try {
-    unlinkSync(daemonDiscoveryPath(record.project, home));
-  } catch {
-  }
-}
-function teardownSlot(slot) {
-  try {
-    slot.stopPersist();
-  } catch {
-  }
-  try {
-    slot.stopStaleness();
-  } catch {
-  }
-  try {
-    slot.stopConnectors();
-  } catch {
-  }
-  try {
-    slot.detachEvents();
-  } catch {
-  }
-}
-function neatHomeFor(opts) {
-  if (opts.neatHome && opts.neatHome.length > 0) return path2.resolve(opts.neatHome);
-  const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path2.resolve(env);
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path2.join(home, ".neat");
-}
-function routeSpanToProject(serviceName, projects) {
-  if (!serviceName) return DEFAULT_PROJECT;
-  for (const entry of projects) {
-    if (entry.status === "paused") continue;
-    if (entry.name === serviceName) return entry.name;
-  }
-  const candidates = [];
-  for (const entry of projects) {
-    if (entry.status === "paused") continue;
-    if (isTokenPrefix(entry.name, serviceName)) candidates.push(entry);
-  }
-  if (candidates.length > 0) {
-    candidates.sort((a, b) => b.name.length - a.name.length);
-    return candidates[0].name;
-  }
-  for (const entry of projects) {
-    if (entry.status === "paused") continue;
-    if (isTokenContained(entry.name, serviceName)) return entry.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);
-}
-function serviceNameMatchesProject(serviceName, project) {
-  if (serviceName === project) return true;
-  if (isTokenPrefix(project, serviceName)) return true;
-  if (isTokenContained(project, serviceName)) return true;
-  return false;
-}
-function spanBelongsToSingleProject(graph, project, serviceName) {
-  if (!serviceName) return true;
-  if (serviceNameMatchesProject(serviceName, project)) return true;
-  return graph.someNode(
-    (_id, attrs) => attrs.type === NodeType.ServiceNode && attrs.name === serviceName
-  );
-}
-async function bootstrapProject(entry, connectors = []) {
-  const paths = pathsForProject(entry.name, path2.join(entry.path, "neat-out"));
-  try {
-    const stat = await fs2.stat(entry.path);
-    if (!stat.isDirectory()) {
-      throw new Error(`registered path ${entry.path} is not a directory`);
-    }
-  } catch (err) {
-    await setStatus(entry.name, "broken").catch(() => {
-    });
-    return {
-      entry,
-      // Empty graph is fine — `slots` keeps the entry visible in `status`
-      // output; nothing routes to it because it's not 'active'.
-      graph: getGraph(`__broken__:${entry.name}`),
-      outPath: "",
-      paths,
-      stopPersist: () => {
-      },
-      stopStaleness: () => {
-      },
-      stopConnectors: () => {
-      },
-      detachEvents: () => {
-      },
-      status: "broken",
-      errorReason: err.message
-    };
-  }
-  resetGraph(entry.name);
-  const graph = getGraph(entry.name);
-  const outPath = paths.snapshotPath;
-  await loadGraphFromDisk(graph, outPath);
-  const detachEvents = attachGraphToEventBus(graph, { project: entry.name });
-  try {
-    await extractFromDirectory(graph, entry.path);
-    const stopPersist = startPersistLoop(graph, outPath, { exitOnSignal: false });
-    const stopStaleness = startStalenessLoop(graph, {
-      staleEventsPath: paths.staleEventsPath,
-      project: entry.name
-    });
-    const stopFns = connectors.map(
-      (registration) => startConnectorPollLoop(
-        registration.connector,
-        { projectDir: entry.path, credentials: registration.credentials },
-        graph,
-        registration.resolveTarget,
-        { intervalMs: registration.intervalMs }
-      )
-    );
-    const stopConnectors = () => {
-      for (const stop of stopFns) stop();
-    };
-    await touchLastSeen(entry.name).catch(() => {
-    });
-    return {
-      entry,
-      graph,
-      outPath,
-      paths,
-      stopPersist,
-      stopStaleness,
-      stopConnectors,
-      detachEvents,
-      status: "active"
-    };
-  } catch (err) {
-    detachEvents();
-    throw err;
-  }
-}
-function resolveRestPort(opts) {
-  if (typeof opts.restPort === "number") return opts.restPort;
-  const env = process.env.PORT;
-  if (env && env.length > 0) {
-    const n = Number.parseInt(env, 10);
-    if (Number.isFinite(n)) return n;
-  }
-  return 8080;
-}
-function resolveOtlpPort(opts) {
-  if (typeof opts.otlpPort === "number") return opts.otlpPort;
-  const env = process.env.OTEL_PORT;
-  if (env && env.length > 0) {
-    const n = Number.parseInt(env, 10);
-    if (Number.isFinite(n)) return n;
-  }
-  return 4318;
-}
-function resolveWebPort() {
-  const env = process.env.NEAT_WEB_PORT;
-  if (env && env.length > 0) {
-    const n = Number.parseInt(env, 10);
-    if (Number.isFinite(n)) return n;
-  }
-  return 6328;
-}
-function portFromListenAddress(address, fallback) {
-  try {
-    const port = new URL(address).port;
-    const n = Number.parseInt(port, 10);
-    if (Number.isFinite(n) && n > 0) return n;
-  } catch {
-  }
-  return fallback;
-}
-function resolveHost(opts, authTokenSet) {
-  if (opts.host && opts.host.length > 0) return opts.host;
-  const env = process.env.HOST;
-  if (env && env.length > 0) return env;
-  if (!authTokenSet) return "127.0.0.1";
-  return "0.0.0.0";
-}
-async function startDaemon(opts = {}) {
-  const home = neatHomeFor(opts);
-  const regPath = registryPath();
-  const projectArg = typeof opts.project === "string" && opts.project.length > 0 ? opts.project : process.env.NEAT_PROJECT && process.env.NEAT_PROJECT.length > 0 ? process.env.NEAT_PROJECT : null;
-  const projectPathArg = opts.projectPath && opts.projectPath.length > 0 ? opts.projectPath : process.env.NEAT_PROJECT_PATH && process.env.NEAT_PROJECT_PATH.length > 0 ? process.env.NEAT_PROJECT_PATH : null;
-  const singleProject = projectArg;
-  const singleProjectPath = singleProject && projectPathArg ? path2.resolve(projectPathArg) : null;
-  if (singleProject && !singleProjectPath) {
-    throw new Error(
-      `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
-    );
-  }
-  if (!singleProject) {
-    try {
-      await fs2.access(regPath);
-    } catch {
-      throw new Error(
-        `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
-      );
-    }
-  }
-  const pidPath = path2.join(home, "neatd.pid");
-  await writeAtomically(pidPath, `${process.pid}
-`);
-  const slots = /* @__PURE__ */ new Map();
-  const registry = new Projects();
-  const bootstrapStatus = /* @__PURE__ */ new Map();
-  const bootstrapStartedAt = /* @__PURE__ */ new Map();
-  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.`
-    );
-  }
-  const unroutedPath = unroutedErrorsPath(home);
-  const lastUnroutedWarnAt = /* @__PURE__ */ new Map();
-  async function recordUnroutedSpan(serviceName, traceId) {
-    const key = serviceName ?? "<missing>";
-    const now = Date.now();
-    try {
-      await appendUnroutedSpan(home, buildUnroutedSpanRecord(serviceName, traceId, new Date(now)));
-    } catch {
-    }
-    const prev = lastUnroutedWarnAt.get(key) ?? 0;
-    if (now - prev < DROP_WARN_INTERVAL_MS) return;
-    lastUnroutedWarnAt.set(key, now);
-    console.warn(
-      `[neatd] dropping span \u2014 service.name "${key}" matches no registered project and no \`default\` project exists. See ${unroutedPath}.`
-    );
-  }
-  function upsertRegistryFromSlot(slot) {
-    if (slot.status !== "active") return;
-    registry.set(slot.entry.name, {
-      scanPath: slot.entry.path,
-      paths: slot.paths,
-      graph: slot.graph
-    });
-  }
-  async function tryRecoverSlot(entry) {
-    try {
-      const fresh = await bootstrapProject(entry, opts.connectors ?? []);
-      const prior = slots.get(entry.name);
-      if (prior) teardownSlot(prior);
-      slots.set(entry.name, fresh);
-      upsertRegistryFromSlot(fresh);
-      if (fresh.status === "active") {
-        await setStatus(entry.name, "active").catch(() => {
-        });
-        console.log(
-          `neatd: project "${entry.name}" recovered from broken \u2014 active`
-        );
-      }
-      return fresh;
-    } catch (err) {
-      console.warn(
-        `neatd: project "${entry.name}" still broken after recovery attempt \u2014 ${err.message}`
-      );
-      return slots.get(entry.name);
-    }
-  }
-  async function bootstrapOne(entry) {
-    bootstrapStatus.set(entry.name, "bootstrapping");
-    bootstrapStartedAt.set(entry.name, Date.now());
-    try {
-      const slot = await bootstrapProject(entry, opts.connectors ?? []);
-      const prior = slots.get(entry.name);
-      if (prior) teardownSlot(prior);
-      slots.set(entry.name, slot);
-      upsertRegistryFromSlot(slot);
-      bootstrapStatus.set(entry.name, slot.status === "broken" ? "broken" : "active");
-      if (slot.status === "broken") {
-        console.warn(`neatd: project "${entry.name}" broken \u2014 ${slot.errorReason}`);
-      } else {
-        console.log(`neatd: project "${entry.name}" active (${entry.path})`);
-      }
-    } catch (err) {
-      bootstrapStatus.set(entry.name, "broken");
-      console.warn(
-        `neatd: project "${entry.name}" failed to bootstrap \u2014 ${err.message}`
-      );
-      await setStatus(entry.name, "broken").catch(() => {
-      });
-    }
-  }
-  async function enumerateProjects() {
-    if (singleProject && singleProjectPath) {
-      return [
-        {
-          name: singleProject,
-          path: singleProjectPath,
-          registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-          languages: [],
-          status: "active"
-        }
-      ];
-    }
-    return listProjects();
-  }
-  async function loadAll() {
-    if (!singleProject) {
-      try {
-        const pruned = await pruneRegistry();
-        for (const entry of pruned) {
-          console.log(
-            `neatd: pruned project "${entry.name}" \u2014 registered path ${entry.path} is gone`
-          );
-          slots.delete(entry.name);
-          bootstrapStatus.delete(entry.name);
-          bootstrapStartedAt.delete(entry.name);
-        }
-      } catch (err) {
-        console.warn(`neatd: registry prune skipped \u2014 ${err.message}`);
-      }
-    }
-    const projects = await enumerateProjects();
-    const seen = /* @__PURE__ */ new Set();
-    const pending = [];
-    for (const entry of projects) {
-      seen.add(entry.name);
-      const existing = slots.get(entry.name);
-      if (existing) {
-        if (existing.status === "broken") {
-          pending.push(tryRecoverSlot(entry).then(() => {
-          }));
-        }
-        continue;
-      }
-      pending.push(bootstrapOne(entry));
-    }
-    for (const [name, slot] of [...slots.entries()]) {
-      if (seen.has(name)) continue;
-      teardownSlot(slot);
-      slots.delete(name);
-      bootstrapStatus.delete(name);
-      bootstrapStartedAt.delete(name);
-      console.log(`neatd: project "${name}" removed from registry \u2014 stopped`);
-    }
-    await Promise.allSettled(pending);
-  }
-  const initialEntries = await enumerateProjects().catch(() => []);
-  for (const entry of initialEntries) {
-    bootstrapStatus.set(entry.name, "bootstrapping");
-    bootstrapStartedAt.set(entry.name, Date.now());
-  }
-  const bind = opts.bindListeners !== false;
-  let restApp = null;
-  let otlpApp = null;
-  let restAddress = "";
-  let otlpAddress = "";
-  let daemonRecord = null;
-  if (bind) {
-    const auth = readAuthEnv();
-    const host = resolveHost(opts, Boolean(auth.authToken));
-    const restPort = resolveRestPort(opts);
-    const otlpPort = resolveOtlpPort(opts);
-    assertBindAuthority(host, auth.authToken);
-    try {
-      restApp = await buildApi({
-        projects: registry,
-        authToken: auth.authToken,
-        trustProxy: auth.trustProxy,
-        publicRead: auth.publicRead,
-        bootstrap: {
-          status: (name) => bootstrapStatus.get(name),
-          list: () => {
-            const now = Date.now();
-            return [...bootstrapStatus.entries()].map(([name, status]) => ({
-              name,
-              status,
-              elapsedMs: now - (bootstrapStartedAt.get(name) ?? now)
-            }));
-          }
-        },
-        // ADR-096 §4/§5/§7 — hand the daemon's identity to buildApi so the REST
-        // surface reflects "the daemon is the project": `GET /projects` reports
-        // only this project (the dashboard pins to it), and the daemon-wide
-        // `/health` carries it at the top level for the spawn-reuse identity
-        // check. Absent for the legacy multi-project daemon.
-        singleProject: singleProject && singleProjectPath ? { name: singleProject, path: singleProjectPath } : void 0
-      });
-      restAddress = await restApp.listen({ port: restPort, host });
-      console.log(
-        `neatd: REST listening on http://${host}:${portFromListenAddress(restAddress, restPort)}`
-      );
-    } catch (err) {
-      for (const slot of slots.values()) {
-        teardownSlot(slot);
-      }
-      if (restApp) await restApp.close().catch(() => {
-      });
-      await fs2.unlink(pidPath).catch(() => {
-      });
-      throw new Error(
-        `neatd: failed to bind REST on port ${restPort} \u2014 ${err.message}`
-      );
-    }
-    async function resolveTargetSlot(serviceName, traceId) {
-      if (singleProject) {
-        let slot2 = slots.get(singleProject);
-        if (!slot2) {
-          slot2 = await tryRecoverSlot({
-            name: singleProject,
-            path: singleProjectPath,
-            registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
-            languages: [],
-            status: "active"
-          });
-        } else if (slot2.status === "broken") {
-          slot2 = await tryRecoverSlot(slot2.entry);
-        }
-        if (!slot2 || slot2.status !== "active") {
-          warnDroppedSpan(singleProject, slot2?.errorReason ?? "unknown");
-          return null;
-        }
-        if (!spanBelongsToSingleProject(slot2.graph, singleProject, serviceName)) {
-          await recordUnroutedSpan(serviceName, traceId);
-          return null;
-        }
-        return slot2;
-      }
-      const liveEntries = await listProjects().catch(() => []);
-      const target = routeSpanToProject(serviceName, liveEntries);
-      let slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
-      if (!slot) {
-        await recordUnroutedSpan(serviceName, traceId);
-        return null;
-      }
-      if (slot.status === "broken") {
-        const entry = liveEntries.find((e) => e.name === slot.entry.name);
-        if (entry) {
-          slot = await tryRecoverSlot(entry);
-        }
-        if (slot.status !== "active") {
-          warnDroppedSpan(slot.entry.name, slot.errorReason ?? "unknown");
-          return null;
-        }
-      }
-      return slot.status === "active" ? slot : null;
-    }
-    async function resolveSlotByName(project, serviceName, traceId) {
-      const liveEntries = await listProjects().catch(() => []);
-      let slot = slots.get(project);
-      if (!slot) {
-        await recordUnroutedSpan(serviceName, traceId);
-        return null;
-      }
-      if (slot.status === "broken") {
-        const entry = liveEntries.find((e) => e.name === slot.entry.name);
-        if (entry) {
-          slot = await tryRecoverSlot(entry);
-        }
-        if (slot.status !== "active") {
-          warnDroppedSpan(slot.entry.name, slot.errorReason ?? "unknown");
-          return null;
-        }
-      }
-      return slot.status === "active" ? slot : null;
-    }
-    try {
-      otlpApp = await buildOtelReceiver({
-        authToken: auth.otelToken,
-        trustProxy: auth.trustProxy,
-        onSpan: async (span) => {
-          const slot = await resolveTargetSlot(span.service, span.traceId);
-          if (!slot) return;
-          await handleSpan(
-            {
-              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
-            },
-            span
-          );
-        },
-        onErrorSpanSync: async (span) => {
-          const slot = await resolveTargetSlot(span.service, span.traceId);
-          if (!slot) return;
-          await makeErrorSpanWriter(slot.paths.errorsPath, slot.graph, slot.entry.path)(span);
-        },
-        // Project-scoped route (issue #367) — the URL already named the
-        // project. Resolution is a direct slot lookup; service.name resolves
-        // the ServiceNode inside the slot's graph instead of which project
-        // owns the span.
-        onProjectSpan: async (project, span) => {
-          const slot = await resolveSlotByName(project, span.service, span.traceId);
-          if (!slot) return;
-          await handleSpan(
-            {
-              graph: slot.graph,
-              errorsPath: slot.paths.errorsPath,
-              scanPath: slot.entry.path,
-              project: slot.entry.name,
-              writeErrorEventInline: false
-            },
-            span
-          );
-        },
-        onProjectErrorSpanSync: async (project, span) => {
-          const slot = await resolveSlotByName(project, span.service, span.traceId);
-          if (!slot) return;
-          await makeErrorSpanWriter(slot.paths.errorsPath, slot.graph, slot.entry.path)(span);
-        }
-      });
-      otlpAddress = await listenSteppingOtlp(otlpApp, otlpPort, host);
-      console.log(`neatd: OTLP listening on ${otlpAddress}/v1/traces`);
-    } catch (err) {
-      for (const slot of slots.values()) {
-        teardownSlot(slot);
-      }
-      if (restApp) await restApp.close().catch(() => {
-      });
-      if (otlpApp) await otlpApp.close().catch(() => {
-      });
-      await fs2.unlink(pidPath).catch(() => {
-      });
-      throw new Error(
-        `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
-      );
-    }
-    if (singleProject && singleProjectPath) {
-      const ports = {
-        rest: portFromListenAddress(restAddress, restPort),
-        otlp: portFromListenAddress(otlpAddress, otlpPort),
-        // The daemon doesn't bind the web port itself (neatd spawns the web
-        // child); it records the allocated value passed through so the
-        // dashboard and `neat ps` agree on where to look.
-        web: typeof opts.webPort === "number" ? opts.webPort : resolveWebPort()
-      };
-      daemonRecord = {
-        project: singleProject,
-        projectPath: singleProjectPath,
-        pid: process.pid,
-        status: "running",
-        ports,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        neatVersion: resolveNeatVersion()
-      };
-      try {
-        await writeDaemonRecord(daemonRecord, home);
-        console.log(
-          `neatd: project "${singleProject}" \u2192 REST ${ports.rest} / OTLP ${ports.otlp} / web ${ports.web} (daemon.json written)`
-        );
-      } catch (err) {
-        for (const slot of slots.values()) teardownSlot(slot);
-        if (restApp) await restApp.close().catch(() => {
-        });
-        if (otlpApp) await otlpApp.close().catch(() => {
-        });
-        await fs2.unlink(pidPath).catch(() => {
-        });
-        throw new Error(
-          `neatd: failed to write daemon.json for "${singleProject}" \u2014 ${err.message}`
-        );
-      }
-    }
-  }
-  const initialBootstrap = loadAll().catch((err) => {
-    console.warn(`neatd: initial bootstrap pass failed \u2014 ${err.message}`);
-  });
-  let reloading = initialBootstrap;
-  const reload = async () => {
-    if (reloading) return reloading;
-    reloading = (async () => {
-      try {
-        await loadAll();
-      } finally {
-        reloading = null;
-      }
-    })();
-    return reloading;
-  };
-  void initialBootstrap.finally(() => {
-    if (reloading === initialBootstrap) reloading = null;
-  });
-  const tracker = {
-    status: (name) => bootstrapStatus.get(name),
-    list: () => {
-      const now = Date.now();
-      return [...bootstrapStatus.entries()].map(([name, status]) => ({
-        name,
-        status,
-        elapsedMs: now - (bootstrapStartedAt.get(name) ?? now)
-      }));
-    }
-  };
-  const sighupHandler = () => {
-    void reload().catch((err) => {
-      console.warn(`neatd: SIGHUP reload failed \u2014 ${err.message}`);
-    });
-  };
-  process.on("SIGHUP", sighupHandler);
-  const REGISTRY_RELOAD_DEBOUNCE_MS = 500;
-  let registryWatcher = null;
-  let reloadTimer = null;
-  if (!singleProject) try {
-    const regDir = path2.dirname(regPath);
-    const regBase = path2.basename(regPath);
-    registryWatcher = watch(regDir, (_eventType, filename) => {
-      if (filename !== null && filename !== regBase) return;
-      if (reloadTimer) clearTimeout(reloadTimer);
-      reloadTimer = setTimeout(() => {
-        reloadTimer = null;
-        void reload().catch((err) => {
-          console.warn(
-            `neatd: registry-watch reload failed \u2014 ${err.message}`
-          );
-        });
-      }, REGISTRY_RELOAD_DEBOUNCE_MS);
-    });
-  } catch (err) {
-    console.warn(
-      `neatd: failed to watch registry at ${regPath} \u2014 ${err.message}. Run \`neatd reload\` (or send SIGHUP) after registering new projects.`
-    );
-  }
-  let stopped = false;
-  const stop = async () => {
-    if (stopped) return;
-    stopped = true;
-    process.off("SIGHUP", sighupHandler);
-    if (reloadTimer) {
-      clearTimeout(reloadTimer);
-      reloadTimer = null;
-    }
-    if (registryWatcher) {
-      try {
-        registryWatcher.close();
-      } catch {
-      }
-      registryWatcher = null;
-    }
-    if (otlpApp) await otlpApp.close().catch(() => {
-    });
-    if (restApp) await restApp.close().catch(() => {
-    });
-    for (const slot of slots.values()) {
-      if (slot.status === "active" && slot.outPath) {
-        await saveGraphToDisk(slot.graph, slot.outPath).catch(() => {
-        });
-      }
-    }
-    for (const slot of slots.values()) {
-      teardownSlot(slot);
-    }
-    if (daemonRecord) {
-      await clearDaemonRecord(daemonRecord, home);
-    }
-    await fs2.unlink(pidPath).catch(() => {
-    });
-  };
-  return {
-    slots,
-    reload,
-    stop,
-    pidPath,
-    restAddress,
-    otlpAddress,
-    bootstrap: tracker,
-    initialBootstrap,
-    daemonRecord,
-    neatHome: home
-  };
-}
-
-export {
-  readDaemonRecord,
-  resolveNeatVersion,
-  writeDaemonRecord,
-  clearDaemonRecord,
-  reconcileDaemonRecordSync,
-  routeSpanToProject,
-  portFromListenAddress,
-  resolveHost,
-  startDaemon
-};
-//# sourceMappingURL=chunk-XV4D7A3Z.js.map