@neat.is/core 0.4.3 → 0.4.5

package/dist/cli.cjs

@@ -301,12 +301,15 @@ function parseOtlpRequest(body) {
   const out = [];
   for (const rs of body.resourceSpans ?? []) {
     const resourceAttrs = attrsToRecord(rs.resource?.attributes);
-    const service = typeof resourceAttrs["service.name"] === "string" ? resourceAttrs["service.name"] : "unknown";
+    const rawServiceName = resourceAttrs["service.name"];
+    const resourceServiceNamePresent = typeof rawServiceName === "string" && rawServiceName.length > 0;
+    const service = resourceServiceNamePresent ? rawServiceName : "unidentified";
     for (const ss of rs.scopeSpans ?? []) {
       for (const span of ss.spans ?? []) {
         const attrs = attrsToRecord(span.attributes);
         const parsed = {
           service,
+          resourceServiceNamePresent,
           traceId: span.traceId ?? "",
           spanId: span.spanId ?? "",
           parentSpanId: span.parentSpanId || void 0,
@@ -401,6 +404,64 @@ async function buildOtelReceiver(opts) {
     for (const s of spans) queue.push(s);
     drainPromise = drainPromise.then(() => drain());
   };
+  const projectQueue = [];
+  let projectDraining = false;
+  let projectDrainPromise = Promise.resolve();
+  const drainProject = async () => {
+    if (projectDraining) return;
+    projectDraining = true;
+    try {
+      while (projectQueue.length > 0) {
+        const { project, span } = projectQueue.shift();
+        try {
+          if (opts.onProjectSpan) {
+            await opts.onProjectSpan(project, span);
+          } else {
+            await opts.onSpan(span);
+          }
+        } catch (err) {
+          console.warn(`[neat] otel handler error: ${err.message}`);
+        }
+      }
+    } finally {
+      projectDraining = false;
+    }
+  };
+  const enqueueProject = (project, spans) => {
+    if (spans.length === 0) return;
+    for (const s of spans) projectQueue.push({ project, span: s });
+    projectDrainPromise = projectDrainPromise.then(() => drainProject());
+  };
+  const legacyEndpointWarned = /* @__PURE__ */ new Set();
+  function warnLegacyEndpoint(serviceName) {
+    if (legacyEndpointWarned.has(serviceName)) return;
+    legacyEndpointWarned.add(serviceName);
+    console.warn(
+      `[neatd] received span on the global endpoint; migrate OTEL_EXPORTER_OTLP_TRACES_ENDPOINT to /projects/<name>/v1/traces (service.name="${serviceName}").`
+    );
+  }
+  async function readOtlpBody(req) {
+    const ct = (req.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
+    if (ct === "application/x-protobuf") {
+      try {
+        const body = await decodeProtobufBody(req.body);
+        return { ok: true, body, flavor: "protobuf" };
+      } catch (err) {
+        return { ok: false, code: 400, error: `protobuf decode failed: ${err.message}` };
+      }
+    }
+    if (!ct || ct === "application/json") {
+      return { ok: true, body: req.body ?? {}, flavor: "json" };
+    }
+    return { ok: false, code: 415, error: `unsupported content-type: ${ct}` };
+  }
+  function sendOtlpSuccess(reply, flavor) {
+    if (flavor === "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: {} });
+  }
   app.addContentTypeParser(
     "application/x-protobuf",
     { parseAs: "buffer", bodyLimit: opts.bodyLimit ?? 16 * 1024 * 1024 },
@@ -410,26 +471,44 @@ async function buildOtelReceiver(opts) {
   );
   app.get("/health", async () => ({ ok: true }));
   app.post("/v1/traces", async (req, reply) => {
-    const ct = (req.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
-    let body;
-    let responseFlavor;
-    if (ct === "application/x-protobuf") {
-      responseFlavor = "protobuf";
+    const result = await readOtlpBody(req);
+    if (!result.ok) {
+      return reply.code(result.code).send({ error: result.error });
+    }
+    const spans = parseOtlpRequest(result.body);
+    for (const s of spans) warnLegacyEndpoint(s.service);
+    if (opts.onErrorSpanSync) {
       try {
-        body = await decodeProtobufBody(req.body);
+        for (const span of spans) {
+          if (span.statusCode === 2) await opts.onErrorSpanSync(span);
+        }
       } catch (err) {
-        return reply.code(400).send({
-          error: `protobuf decode failed: ${err.message}`
+        return reply.code(500).send({
+          error: `error-event write failed: ${err.message}`
         });
       }
-    } else if (!ct || ct === "application/json") {
-      responseFlavor = "json";
-      body = req.body ?? {};
-    } else {
-      return reply.code(415).send({ error: `unsupported content-type: ${ct}` });
     }
-    const spans = parseOtlpRequest(body);
-    if (opts.onErrorSpanSync) {
+    enqueue(spans);
+    return sendOtlpSuccess(reply, result.flavor);
+  });
+  app.post("/projects/:project/v1/traces", async (req, reply) => {
+    const project = req.params.project;
+    const result = await readOtlpBody(req);
+    if (!result.ok) {
+      return reply.code(result.code).send({ error: result.error });
+    }
+    const spans = parseOtlpRequest(result.body);
+    if (opts.onProjectErrorSpanSync) {
+      try {
+        for (const span of spans) {
+          if (span.statusCode === 2) await opts.onProjectErrorSpanSync(project, span);
+        }
+      } catch (err) {
+        return reply.code(500).send({
+          error: `error-event write failed: ${err.message}`
+        });
+      }
+    } else if (opts.onErrorSpanSync) {
       try {
         for (const span of spans) {
           if (span.statusCode === 2) await opts.onErrorSpanSync(span);
@@ -440,17 +519,13 @@ async function buildOtelReceiver(opts) {
         });
       }
     }
-    enqueue(spans);
-    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: {} });
+    enqueueProject(project, spans);
+    return sendOtlpSuccess(reply, result.flavor);
   });
   const decorated = app;
   decorated.flushPending = async () => {
-    while (queue.length > 0 || draining) {
-      await drainPromise;
+    while (queue.length > 0 || draining || projectQueue.length > 0 || projectDraining) {
+      await Promise.all([drainPromise, projectDrainPromise]);
     }
   };
   return decorated;
@@ -1548,6 +1623,14 @@ function thresholdForEdgeType(edgeType, overrides) {
 function nowIso(ctx) {
   return new Date(ctx.now ? ctx.now() : Date.now()).toISOString();
 }
+var unidentifiedWarnedProjects = /* @__PURE__ */ new Set();
+function warnUnidentifiedSpan(project) {
+  if (unidentifiedWarnedProjects.has(project)) return;
+  unidentifiedWarnedProjects.add(project);
+  console.warn(
+    `[neatd] span lacked service.name; routed to 'unidentified' in project ${project}; check your OTel SDK config.`
+  );
+}
 function pickAttr(span, ...keys) {
   for (const k of keys) {
     const v = span.attributes[k];
@@ -1802,6 +1885,9 @@ async function handleSpan(ctx, span) {
   const ts = span.startTimeIso ?? nowIso(ctx);
   const nowMs = ctx.now ? ctx.now() : Date.now();
   const env = span.env ?? "unknown";
+  if (span.resourceServiceNamePresent === false) {
+    warnUnidentifiedSpan(ctx.project ?? DEFAULT_PROJECT);
+  }
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = span.statusCode === 2;
   cacheSpanService(span, nowMs);
@@ -6484,45 +6570,49 @@ var import_node_path40 = __toESM(require("path"), 1);
 init_cjs_shims();
 var OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-069). OpenTelemetry auto-instrumentation hook.";
 var OTEL_INIT_CJS = `${OTEL_INIT_HEADER}
-// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
-// the auto-instrumentation hook attaches. Configure via the env file.
-const path = require('node:path')
-try {
-  require('dotenv').config({ path: path.join(__dirname, '.env.neat') })
-} catch (err) {
-  // dotenv unavailable \u2014 fall through to process.env.
-}
-require('@opentelemetry/auto-instrumentations-node/register')
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+
+const { NodeSDK } = require('@opentelemetry/sdk-node')
+const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
+
+const instrumentations = [getNodeAutoInstrumentations()]
+__INSTRUMENTATION_BLOCK__
+new NodeSDK({ instrumentations }).start()
 `;
 var OTEL_INIT_ESM = `${OTEL_INIT_HEADER}
-// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
-// the auto-instrumentation hook attaches. Configure via the env file.
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-import dotenv from 'dotenv'
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
-const here = path.dirname(fileURLToPath(import.meta.url))
-dotenv.config({ path: path.join(here, '.env.neat') })
+import { NodeSDK } from '@opentelemetry/sdk-node'
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
 
-await import('@opentelemetry/auto-instrumentations-node/register')
+const instrumentations = [getNodeAutoInstrumentations()]
+__INSTRUMENTATION_BLOCK__
+new NodeSDK({ instrumentations }).start()
 `;
 var OTEL_INIT_TS = `${OTEL_INIT_HEADER}
-// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
-// the auto-instrumentation hook attaches. Configure via the env file.
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-import dotenv from 'dotenv'
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
-const here = path.dirname(fileURLToPath(import.meta.url))
-dotenv.config({ path: path.join(here, '.env.neat') })
+import { NodeSDK } from '@opentelemetry/sdk-node'
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
 
-await import('@opentelemetry/auto-instrumentations-node/register')
+const instrumentations = [getNodeAutoInstrumentations()]
+__INSTRUMENTATION_BLOCK__
+new NodeSDK({ instrumentations }).start()
 `;
-function renderEnvNeat(projectName) {
+function renderNodeOtelInit(template, serviceName, projectName, registrations = []) {
+  const block = registrations.length === 0 ? "" : `
+${registrations.join("\n")}
+`;
+  return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName).replace(/__INSTRUMENTATION_BLOCK__\n?/g, block);
+}
+function renderEnvNeat(serviceName, projectName) {
   return [
     "# Generated by `neat init --apply` (ADR-069).",
-    `OTEL_SERVICE_NAME=${projectName}`,
-    "OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318",
+    `OTEL_SERVICE_NAME=${serviceName}`,
+    `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/projects/${projectName}/v1/traces`,
     ""
   ].join("\n");
 }
@@ -6542,39 +6632,41 @@ export async function register() {
 }
 `;
 var NEXT_INSTRUMENTATION_NODE_TS = `${NEXT_INSTRUMENTATION_HEADER}
-process.env.OTEL_SERVICE_NAME ||= '__PROJECT_NAME__'
-process.env.OTEL_EXPORTER_OTLP_ENDPOINT ||= 'http://localhost:4318'
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 import { NodeSDK } from '@opentelemetry/sdk-node'
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
 
-new NodeSDK({ instrumentations: [getNodeAutoInstrumentations()] }).start()
+const instrumentations = [getNodeAutoInstrumentations()]
+__INSTRUMENTATION_BLOCK__
+new NodeSDK({ instrumentations }).start()
 `;
 var NEXT_INSTRUMENTATION_NODE_JS = `${NEXT_INSTRUMENTATION_HEADER}
-process.env.OTEL_SERVICE_NAME ||= '__PROJECT_NAME__'
-process.env.OTEL_EXPORTER_OTLP_ENDPOINT ||= 'http://localhost:4318'
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 const { NodeSDK } = require('@opentelemetry/sdk-node')
 const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
 
-new NodeSDK({ instrumentations: [getNodeAutoInstrumentations()] }).start()
+const instrumentations = [getNodeAutoInstrumentations()]
+__INSTRUMENTATION_BLOCK__
+new NodeSDK({ instrumentations }).start()
 `;
-function renderNextInstrumentationNode(template, projectName) {
-  return template.replace(/__PROJECT_NAME__/g, projectName);
+function renderNextInstrumentationNode(template, serviceName, projectName, registrations = []) {
+  const block = registrations.length === 0 ? "" : `
+${registrations.join("\n")}
+`;
+  return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName).replace(/__INSTRUMENTATION_BLOCK__\n?/g, block);
 }
 var FRAMEWORK_OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-074). OpenTelemetry SDK hook.";
 var FRAMEWORK_OTEL_INIT_TS_BODY = `${FRAMEWORK_OTEL_INIT_HEADER}
-// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
-// the OTel SDK starts so the exporter target and service name are in scope.
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-import dotenv from 'dotenv'
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+
 import { NodeSDK } from '@opentelemetry/sdk-node'
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
 
-const here = path.dirname(fileURLToPath(import.meta.url))
-dotenv.config({ path: path.join(here, '.env.neat') })
-
 const sdk = new NodeSDK({
   serviceName: process.env.OTEL_SERVICE_NAME,
   instrumentations: [getNodeAutoInstrumentations()],
@@ -6582,14 +6674,9 @@ const sdk = new NodeSDK({
 sdk.start()
 `;
 var FRAMEWORK_OTEL_INIT_JS_BODY = `${FRAMEWORK_OTEL_INIT_HEADER}
-// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
-// the OTel SDK starts so the exporter target and service name are in scope.
-const path = require('node:path')
-try {
-  require('dotenv').config({ path: path.join(__dirname, '.env.neat') })
-} catch (err) {
-  // dotenv unavailable \u2014 fall through to process.env.
-}
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+
 const { NodeSDK } = require('@opentelemetry/sdk-node')
 const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
 
@@ -6599,6 +6686,9 @@ const sdk = new NodeSDK({
 })
 sdk.start()
 `;
+function renderFrameworkOtelInit(template, serviceName, projectName) {
+  return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName);
+}
 var REMIX_OTEL_SERVER_TS = FRAMEWORK_OTEL_INIT_TS_BODY;
 var REMIX_OTEL_SERVER_JS = FRAMEWORK_OTEL_INIT_JS_BODY;
 var SVELTEKIT_OTEL_INIT_TS = FRAMEWORK_OTEL_INIT_TS_BODY;
@@ -6661,25 +6751,56 @@ export const onRequest = defineMiddleware(async (context, next) => {
 var SDK_PACKAGES = [
   { name: "@opentelemetry/api", version: "^1.9.0" },
   { name: "@opentelemetry/sdk-node", version: "^0.57.0" },
-  { name: "@opentelemetry/auto-instrumentations-node", version: "^0.55.0" },
-  // ADR-069 §5 — dotenv is the fourth dep. The generated otel-init loads
-  // .env.neat through it so OTEL_SERVICE_NAME and the endpoint are in scope
-  // before the auto-instrumentation hook attaches.
-  { name: "dotenv", version: "^16.4.5" }
+  { name: "@opentelemetry/auto-instrumentations-node", version: "^0.55.0" }
 ];
+function detectNonBundledInstrumentations(pkg) {
+  const deps = allDeps(pkg);
+  const out = [];
+  if ("@prisma/client" in deps) {
+    out.push({
+      pkg: "@prisma/instrumentation",
+      version: "^5.0.0",
+      registration: "instrumentations.push(new (require('@prisma/instrumentation').PrismaInstrumentation)())"
+    });
+  }
+  return out;
+}
 var OTEL_ENV = {
   // ADR-069 §4 — endpoint moves into the per-package .env.neat (written
   // by the apply phase). The envEdits surface stays for the dry-run
   // patch render: it documents the key/value the user can inspect in the
   // generated .env.neat.
   file: null,
-  key: "OTEL_EXPORTER_OTLP_ENDPOINT",
-  value: "http://localhost:4318"
+  key: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+  value: "http://localhost:4318/projects/<project>/v1/traces"
 };
-function envServiceName(pkg, serviceDir, project) {
+function serviceNodeName(pkg, serviceDir) {
+  return pkg.name ?? import_node_path40.default.basename(serviceDir);
+}
+function projectToken(pkg, serviceDir, project) {
   if (project && project.length > 0) return project;
   return pkg.name ?? import_node_path40.default.basename(serviceDir);
 }
+async function readJsonFile(p) {
+  try {
+    const raw = await import_node_fs25.promises.readFile(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function detectRuntimeKind(pkgRoot, pkg) {
+  const deps = allDeps(pkg);
+  if ("react-native" in deps || "expo" in deps) return "react-native";
+  const appJson = await readJsonFile(import_node_path40.default.join(pkgRoot, "app.json"));
+  if (appJson && typeof appJson === "object" && "expo" in appJson) {
+    return "react-native";
+  }
+  if (await exists2(import_node_path40.default.join(pkgRoot, "vite.config.js")) || await exists2(import_node_path40.default.join(pkgRoot, "vite.config.ts")) || await exists2(import_node_path40.default.join(pkgRoot, "vite.config.mjs")) || "vite" in deps) {
+    return "browser-bundle";
+  }
+  return "node";
+}
 async function readPackageJson(serviceDir) {
   try {
     const raw = await import_node_fs25.promises.readFile(import_node_path40.default.join(serviceDir, "package.json"), "utf8");
@@ -6926,7 +7047,6 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
   const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const dependencyEdits = [];
   for (const sdk of SDK_PACKAGES) {
-    if (sdk.name === "dotenv") continue;
     if (sdk.name in existingDeps) continue;
     dependencyEdits.push({
       file: manifestPath,
@@ -6935,7 +7055,19 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
       version: sdk.version
     });
   }
-  const projectName = envServiceName(pkg, serviceDir, project);
+  const nonBundled = detectNonBundledInstrumentations(pkg);
+  for (const inst of nonBundled) {
+    if (inst.pkg in existingDeps) continue;
+    dependencyEdits.push({
+      file: manifestPath,
+      kind: "add",
+      name: inst.pkg,
+      version: inst.version
+    });
+  }
+  const svcName = serviceNodeName(pkg, serviceDir);
+  const projectName = projectToken(pkg, serviceDir, project);
+  const registrations = nonBundled.map((i) => i.registration);
   const generatedFiles = [];
   if (!await exists2(instrumentationFile)) {
     generatedFiles.push({
@@ -6949,7 +7081,9 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
       file: instrumentationNodeFile,
       contents: renderNextInstrumentationNode(
         useTs ? NEXT_INSTRUMENTATION_NODE_TS : NEXT_INSTRUMENTATION_NODE_JS,
-        projectName
+        svcName,
+        projectName,
+        registrations
       ),
       skipIfExists: true
     });
@@ -6957,7 +7091,7 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
-      contents: renderEnvNeat(projectName),
+      contents: renderEnvNeat(svcName, projectName),
       skipIfExists: true
     });
   }
@@ -7018,11 +7152,21 @@ async function queueEnvNeat(serviceDir, pkg, project, generatedFiles) {
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
-      contents: renderEnvNeat(envServiceName(pkg, serviceDir, project)),
+      contents: renderEnvNeat(
+        serviceNodeName(pkg, serviceDir),
+        projectToken(pkg, serviceDir, project)
+      ),
       skipIfExists: true
     });
   }
 }
+function renderFrameworkOtelInitForPkg(template, pkg, serviceDir, project) {
+  return renderFrameworkOtelInit(
+    template,
+    serviceNodeName(pkg, serviceDir),
+    projectToken(pkg, serviceDir, project)
+  );
+}
 function fileImportsOtelHook(raw, specifiers) {
   const lines = raw.split(/\r?\n/);
   for (const line of lines) {
@@ -7048,7 +7192,12 @@ async function planRemix(serviceDir, pkg, manifestPath, entryFile, project) {
   if (!await exists2(otelServerFile)) {
     generatedFiles.push({
       file: otelServerFile,
-      contents: useTs ? REMIX_OTEL_SERVER_TS : REMIX_OTEL_SERVER_JS,
+      contents: renderFrameworkOtelInitForPkg(
+        useTs ? REMIX_OTEL_SERVER_TS : REMIX_OTEL_SERVER_JS,
+        pkg,
+        serviceDir,
+        project
+      ),
       skipIfExists: true
     });
   }
@@ -7102,7 +7251,12 @@ async function planSvelteKit(serviceDir, pkg, manifestPath, hooksFile, project)
   if (!await exists2(otelInitFile)) {
     generatedFiles.push({
       file: otelInitFile,
-      contents: useTs ? SVELTEKIT_OTEL_INIT_TS : SVELTEKIT_OTEL_INIT_JS,
+      contents: renderFrameworkOtelInitForPkg(
+        useTs ? SVELTEKIT_OTEL_INIT_TS : SVELTEKIT_OTEL_INIT_JS,
+        pkg,
+        serviceDir,
+        project
+      ),
       skipIfExists: true
     });
   }
@@ -7165,7 +7319,12 @@ async function planNuxt(serviceDir, pkg, manifestPath, project) {
   if (!await exists2(otelInitFile)) {
     generatedFiles.push({
       file: otelInitFile,
-      contents: useTs ? NUXT_OTEL_INIT_TS : NUXT_OTEL_INIT_JS,
+      contents: renderFrameworkOtelInitForPkg(
+        useTs ? NUXT_OTEL_INIT_TS : NUXT_OTEL_INIT_JS,
+        pkg,
+        serviceDir,
+        project
+      ),
       skipIfExists: true
     });
   }
@@ -7221,7 +7380,12 @@ async function planAstro(serviceDir, pkg, manifestPath, project) {
   if (!await exists2(otelInitFile)) {
     generatedFiles.push({
       file: otelInitFile,
-      contents: useTs ? ASTRO_OTEL_INIT_TS : ASTRO_OTEL_INIT_JS,
+      contents: renderFrameworkOtelInitForPkg(
+        useTs ? ASTRO_OTEL_INIT_TS : ASTRO_OTEL_INIT_JS,
+        pkg,
+        serviceDir,
+        project
+      ),
       skipIfExists: true
     });
   }
@@ -7269,51 +7433,73 @@ async function planAstro(serviceDir, pkg, manifestPath, project) {
     framework: "astro"
   };
 }
-async function plan(serviceDir, opts) {
-  const pkg = await readPackageJson(serviceDir);
-  const manifestPath = import_node_path40.default.join(serviceDir, "package.json");
-  const project = opts?.project;
-  const empty = {
-    language: "javascript",
-    serviceDir,
-    dependencyEdits: [],
-    entrypointEdits: [],
-    envEdits: [],
-    generatedFiles: []
-  };
-  if (!pkg) return empty;
+async function findFrameworkDispatch(serviceDir, pkg, manifestPath, project) {
   if (hasNextDependency(pkg)) {
     const nextConfig = await findNextConfig(serviceDir);
     if (nextConfig) {
-      return planNext(serviceDir, pkg, manifestPath, nextConfig, project);
+      return () => planNext(serviceDir, pkg, manifestPath, nextConfig, project);
     }
   }
   if (hasRemixDependency(pkg)) {
     const remixEntry = await findRemixEntry(serviceDir);
     if (remixEntry) {
-      return planRemix(serviceDir, pkg, manifestPath, remixEntry, project);
+      return () => planRemix(serviceDir, pkg, manifestPath, remixEntry, project);
     }
   }
   if (hasSvelteKitDependency(pkg)) {
     const hooks = await findSvelteKitHooks(serviceDir);
     const config = await findSvelteKitConfig(serviceDir);
     if (hooks || config) {
-      return planSvelteKit(serviceDir, pkg, manifestPath, hooks, project);
+      return () => planSvelteKit(serviceDir, pkg, manifestPath, hooks, project);
     }
   }
   if (hasNuxtDependency(pkg)) {
     const nuxtConfig = await findNuxtConfig(serviceDir);
     if (nuxtConfig) {
-      return planNuxt(serviceDir, pkg, manifestPath, project);
+      return () => planNuxt(serviceDir, pkg, manifestPath, project);
     }
   }
   if (hasAstroDependency(pkg)) {
     const astroConfig = await findAstroConfig(serviceDir);
     if (astroConfig) {
-      return planAstro(serviceDir, pkg, manifestPath, project);
+      return () => planAstro(serviceDir, pkg, manifestPath, project);
     }
   }
-  const entryFile = await resolveEntry(serviceDir, pkg);
+  return null;
+}
+async function plan(serviceDir, opts) {
+  const pkg = await readPackageJson(serviceDir);
+  const manifestPath = import_node_path40.default.join(serviceDir, "package.json");
+  const project = opts?.project;
+  const empty = {
+    language: "javascript",
+    serviceDir,
+    dependencyEdits: [],
+    entrypointEdits: [],
+    envEdits: [],
+    generatedFiles: []
+  };
+  if (!pkg) return empty;
+  const frameworkDispatch = await findFrameworkDispatch(
+    serviceDir,
+    pkg,
+    manifestPath,
+    project
+  );
+  let entryFile = null;
+  if (!frameworkDispatch) {
+    entryFile = await resolveEntry(serviceDir, pkg);
+    if (!entryFile) {
+      return { ...empty, libOnly: true };
+    }
+  }
+  if (frameworkDispatch) {
+    return frameworkDispatch();
+  }
+  const runtimeKind = await detectRuntimeKind(serviceDir, pkg);
+  if (runtimeKind !== "node") {
+    return { ...empty, runtimeKind };
+  }
   if (!entryFile) {
     return { ...empty, libOnly: true };
   }
@@ -7331,6 +7517,16 @@ async function plan(serviceDir, opts) {
       version: sdk.version
     });
   }
+  const nonBundled = detectNonBundledInstrumentations(pkg);
+  for (const inst of nonBundled) {
+    if (inst.pkg in existingDeps) continue;
+    dependencyEdits.push({
+      file: manifestPath,
+      kind: "add",
+      name: inst.pkg,
+      version: inst.version
+    });
+  }
   const entrypointEdits = [];
   try {
     const raw = await import_node_fs25.promises.readFile(entryFile, "utf8");
@@ -7347,18 +7543,26 @@ async function plan(serviceDir, opts) {
   } catch {
     return { ...empty, libOnly: true };
   }
+  const svcName = serviceNodeName(pkg, serviceDir);
+  const projectName = projectToken(pkg, serviceDir, project);
+  const registrations = nonBundled.map((i) => i.registration);
   const generatedFiles = [];
   if (!await exists2(otelInitFile)) {
     generatedFiles.push({
       file: otelInitFile,
-      contents: otelInitContents(flavor),
+      contents: renderNodeOtelInit(
+        otelInitContents(flavor),
+        svcName,
+        projectName,
+        registrations
+      ),
       skipIfExists: true
     });
   }
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
-      contents: renderEnvNeat(envServiceName(pkg, serviceDir, project)),
+      contents: renderEnvNeat(svcName, projectName),
       skipIfExists: true
     });
   }
@@ -7415,6 +7619,22 @@ async function apply(installPlan) {
       writtenFiles: []
     };
   }
+  if (installPlan.runtimeKind === "browser-bundle") {
+    return {
+      serviceDir,
+      outcome: "browser-bundle",
+      reason: "browser bundle; Node OTel SDK cannot run here",
+      writtenFiles: []
+    };
+  }
+  if (installPlan.runtimeKind === "react-native") {
+    return {
+      serviceDir,
+      outcome: "react-native",
+      reason: "React Native / Expo target; Node OTel SDK cannot run here",
+      writtenFiles: []
+    };
+  }
   if (installPlan.dependencyEdits.length === 0 && installPlan.entrypointEdits.length === 0 && (installPlan.generatedFiles?.length ?? 0) === 0 && installPlan.nextConfigEdit === void 0) {
     return {
       serviceDir,
@@ -7870,6 +8090,7 @@ function renderPatch(sections) {
 init_cjs_shims();
 var import_node_fs27 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
+var import_node_net = __toESM(require("net"), 1);
 var import_node_path42 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_readline = __toESM(require("readline"), 1);
@@ -7901,11 +8122,13 @@ async function applyInstallersOver(services, project) {
   let instrumented = 0;
   let already = 0;
   let libOnly = 0;
+  let browserBundle = 0;
+  let reactNative = 0;
   for (const svc of services) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
     const plan3 = await installer.plan(svc.dir, { project });
-    if (isEmptyPlan(plan3) && !plan3.libOnly) {
+    if (isEmptyPlan(plan3) && !plan3.libOnly && plan3.runtimeKind === void 0) {
       already++;
       continue;
     }
@@ -7913,8 +8136,15 @@ async function applyInstallersOver(services, project) {
     if (outcome.outcome === "instrumented") instrumented++;
     else if (outcome.outcome === "already-instrumented") already++;
     else if (outcome.outcome === "lib-only") libOnly++;
+    else if (outcome.outcome === "browser-bundle") {
+      browserBundle++;
+      console.log(`skipping ${svc.dir}: browser bundle; browser-OTel support lands in a future release.`);
+    } else if (outcome.outcome === "react-native") {
+      reactNative++;
+      console.log(`skipping ${svc.dir}: React Native target; browser-OTel support lands in a future release.`);
+    }
   }
-  return { instrumented, alreadyInstrumented: already, libOnly };
+  return { instrumented, alreadyInstrumented: already, libOnly, browserBundle, reactNative };
 }
 async function promptYesNo(question) {
   const rl = import_node_readline.default.createInterface({ input: process.stdin, output: process.stdout });
@@ -8027,6 +8257,28 @@ async function waitForDaemonReady(restPort, timeoutMs) {
     stillBootstrapping: projects.filter((p) => p.status === "bootstrapping").map((p) => p.name)
   };
 }
+var NEAT_PORTS = [8080, 4318, 6328];
+async function isPortFree(port) {
+  return new Promise((resolve) => {
+    const server = import_node_net.default.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => server.close(() => resolve(true)));
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function probePortsFree() {
+  for (const port of NEAT_PORTS) {
+    if (!await isPortFree(port)) return { free: false, held: port };
+  }
+  return { free: true };
+}
+function formatPortCollisionMessage(port) {
+  return [
+    `neat: port ${port} is in use; the NEAT daemon needs it.`,
+    `      run \`neatd stop\` to release the previous daemon, or`,
+    `      \`lsof -i :${port}\` to find the holding process.`
+  ];
+}
 function spawnDaemonDetached() {
   const here = import_node_path42.default.dirname(new URL(importMetaUrl).pathname);
   const candidates = [
@@ -8118,13 +8370,15 @@ async function runOrchestrator(opts) {
   if (gi.action !== "unchanged") {
     console.log(`${gi.action} .gitignore (neat-out/)`);
   }
+  let currentProjectName = opts.project;
   try {
-    await addProject({
+    const entry2 = await addProject({
       name: opts.project,
       path: opts.scanPath,
       languages,
       status: "active"
     });
+    currentProjectName = entry2.name;
   } catch (err) {
     if (!(err instanceof ProjectNameCollisionError)) throw err;
     console.error(`neat: ${err.message}`);
@@ -8132,6 +8386,20 @@ async function runOrchestrator(opts) {
     result.exitCode = 1;
     return result;
   }
+  const siblings = await listProjects();
+  const paused = [];
+  for (const p of siblings) {
+    if (p.name !== currentProjectName && p.status === "active") {
+      await setStatus(p.name, "paused");
+      paused.push(p.name);
+    }
+  }
+  if (paused.length > 0) {
+    const plural = paused.length === 1 ? "" : "s";
+    console.log(
+      `neat: paused ${paused.length} sibling project${plural}; run \`neat resume <name>\` to bring one back active.`
+    );
+  }
   if (!runApply) {
     result.steps.apply.skipped = true;
     console.log("skipped instrumentation (--no-instrument)");
@@ -8147,6 +8415,14 @@ async function runOrchestrator(opts) {
   if (await checkDaemonHealth(restPort)) {
     result.steps.daemon = "already-running";
   } else {
+    const probe = await probePortsFree();
+    if (!probe.free) {
+      for (const line of formatPortCollisionMessage(probe.held)) {
+        console.error(line);
+      }
+      result.exitCode = 3;
+      return result;
+    }
     try {
       spawnDaemonDetached();
     } catch (err) {
@@ -8804,7 +9080,7 @@ async function runSync(opts) {
     snapshotPath = target;
   }
   const skipApply = opts.dryRun || opts.noInstrument;
-  const applyTally = skipApply ? { instrumented: 0, alreadyInstrumented: 0, libOnly: 0 } : await applyInstallersOver(persisted.services, entry2.name);
+  const applyTally = skipApply ? { instrumented: 0, alreadyInstrumented: 0, libOnly: 0, browserBundle: 0, reactNative: 0 } : await applyInstallersOver(persisted.services, entry2.name);
   const warnings = [];
   let daemonState = "skipped";
   let exitCode = 0;
@@ -8954,7 +9230,8 @@ function usage() {
   console.log("  0  success");
   console.log("  1  server error (4xx/5xx body printed to stderr)");
   console.log("  2  misuse (missing args, bad flags) \u2014 handled before any network call");
-  console.log("  3  daemon not reachable (connection refused / timeout)");
+  console.log("  3  environmental \u2014 daemon unreachable, or one of ports 8080 / 4318 / 6328");
+  console.log("     is held by another process when `neat <path>` tries to spawn the daemon");
   console.log("");
   console.log("environment:");
   console.log("  NEAT_API_URL    base URL for the core REST API (default http://localhost:8080)");
@@ -9152,7 +9429,7 @@ async function buildPatchSections(services, project) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
     const plan3 = await installer.plan(svc.dir, { project });
-    if (isEmptyPlan(plan3) && !plan3.libOnly) continue;
+    if (isEmptyPlan(plan3) && !plan3.libOnly && plan3.runtimeKind === void 0) continue;
     sections.push({ installer: installer.name, plan: plan3 });
   }
   return sections;
@@ -9196,13 +9473,15 @@ async function runInit(opts) {
     written.push(gitignoreResult.file);
   }
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
+  let currentProjectName = opts.project;
   try {
-    await addProject({
+    const entry2 = await addProject({
       name: opts.project,
       path: opts.scanPath,
       languages,
       status: "active"
     });
+    currentProjectName = entry2.name;
   } catch (err) {
     if (err instanceof ProjectNameCollisionError) {
       console.error(`neat init: ${err.message}`);
@@ -9211,11 +9490,27 @@ async function runInit(opts) {
     }
     throw err;
   }
+  const siblings = await listProjects();
+  const paused = [];
+  for (const p of siblings) {
+    if (p.name !== currentProjectName && p.status === "active") {
+      await setStatus(p.name, "paused");
+      paused.push(p.name);
+    }
+  }
+  if (paused.length > 0) {
+    const plural = paused.length === 1 ? "" : "s";
+    console.log(
+      `neat: paused ${paused.length} sibling project${plural}; run \`neat resume <name>\` to bring one back active.`
+    );
+  }
   if (!opts.noInstall) {
     if (opts.apply) {
       let instrumented = 0;
       let alreadyInstrumented = 0;
       let libOnly = 0;
+      let browserBundle = 0;
+      let reactNative = 0;
       for (const section of sections) {
         const installer = INSTALLERS.find((i) => i.name === section.installer);
         if (!installer) continue;
@@ -9227,13 +9522,24 @@ async function runInit(opts) {
           alreadyInstrumented++;
         } else if (outcome.outcome === "lib-only") {
           libOnly++;
+        } else if (outcome.outcome === "browser-bundle") {
+          browserBundle++;
+          console.log(`skipping ${section.plan.serviceDir}: browser bundle; browser-OTel support lands in a future release.`);
+        } else if (outcome.outcome === "react-native") {
+          reactNative++;
+          console.log(`skipping ${section.plan.serviceDir}: React Native target; browser-OTel support lands in a future release.`);
         }
       }
       if (sections.length > 0) {
         console.log("");
-        console.log(
-          `apply: instrumented ${instrumented}, already-instrumented ${alreadyInstrumented}, lib-only ${libOnly}`
-        );
+        const parts = [
+          `instrumented ${instrumented}`,
+          `already-instrumented ${alreadyInstrumented}`,
+          `lib-only ${libOnly}`
+        ];
+        if (browserBundle > 0) parts.push(`browser-bundle ${browserBundle}`);
+        if (reactNative > 0) parts.push(`react-native ${reactNative}`);
+        console.log(`apply: ${parts.join(", ")}`);
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {