@neat.is/core 0.4.2 → 0.4.4

package/dist/cli.cjs

@@ -401,6 +401,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 +468,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 +516,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;
@@ -6484,45 +6556,31 @@ 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.
-}
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+
 require('@opentelemetry/auto-instrumentations-node/register')
 `;
 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'
-
-const here = path.dirname(fileURLToPath(import.meta.url))
-dotenv.config({ path: path.join(here, '.env.neat') })
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 await import('@opentelemetry/auto-instrumentations-node/register')
 `;
 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'
-
-const here = path.dirname(fileURLToPath(import.meta.url))
-dotenv.config({ path: path.join(here, '.env.neat') })
+process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
+process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 await import('@opentelemetry/auto-instrumentations-node/register')
 `;
-function renderEnvNeat(projectName) {
+function renderNodeOtelInit(template, serviceName, projectName) {
+  return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName);
+}
+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,54 +6600,34 @@ export async function register() {
 }
 `;
 var NEXT_INSTRUMENTATION_NODE_TS = `${NEXT_INSTRUMENTATION_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()],
-})
-sdk.start()
+new NodeSDK({ instrumentations: [getNodeAutoInstrumentations()] }).start()
 `;
 var NEXT_INSTRUMENTATION_NODE_JS = `${NEXT_INSTRUMENTATION_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'
-import { NodeSDK } from '@opentelemetry/sdk-node'
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
+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') })
+const { NodeSDK } = require('@opentelemetry/sdk-node')
+const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
 
-const sdk = new NodeSDK({
-  serviceName: process.env.OTEL_SERVICE_NAME,
-  instrumentations: [getNodeAutoInstrumentations()],
-})
-sdk.start()
+new NodeSDK({ instrumentations: [getNodeAutoInstrumentations()] }).start()
 `;
+function renderNextInstrumentationNode(template, serviceName, projectName) {
+  return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName);
+}
 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()],
@@ -6597,14 +6635,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')
 
@@ -6614,6 +6647,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;
@@ -6676,11 +6712,7 @@ 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" }
 ];
 var OTEL_ENV = {
   // ADR-069 §4 — endpoint moves into the per-package .env.neat (written
@@ -6688,13 +6720,36 @@ var OTEL_ENV = {
   // 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");
@@ -6919,14 +6974,25 @@ function lineIsOtelInjection(line) {
   if (trimmed.length === 0) return false;
   return /(?:require\(|import\s+)['"]\.\/otel-init[^'"]*['"]/.test(trimmed);
 }
+async function detectsSrcLayout(serviceDir) {
+  const [hasSrcApp, hasSrcPages, hasRootApp, hasRootPages] = await Promise.all([
+    exists2(import_node_path40.default.join(serviceDir, "src", "app")),
+    exists2(import_node_path40.default.join(serviceDir, "src", "pages")),
+    exists2(import_node_path40.default.join(serviceDir, "app")),
+    exists2(import_node_path40.default.join(serviceDir, "pages"))
+  ]);
+  return (hasSrcApp || hasSrcPages) && !hasRootApp && !hasRootPages;
+}
 async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project) {
   const useTs = await isTypeScriptProject(serviceDir);
-  const instrumentationFile = import_node_path40.default.join(serviceDir, useTs ? "instrumentation.ts" : "instrumentation.js");
+  const srcLayout = await detectsSrcLayout(serviceDir);
+  const baseDir = srcLayout ? import_node_path40.default.join(serviceDir, "src") : serviceDir;
+  const instrumentationFile = import_node_path40.default.join(baseDir, useTs ? "instrumentation.ts" : "instrumentation.js");
   const instrumentationNodeFile = import_node_path40.default.join(
-    serviceDir,
+    baseDir,
     useTs ? "instrumentation.node.ts" : "instrumentation.node.js"
   );
-  const envNeatFile = import_node_path40.default.join(serviceDir, ".env.neat");
+  const envNeatFile = import_node_path40.default.join(baseDir, ".env.neat");
   const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const dependencyEdits = [];
   for (const sdk of SDK_PACKAGES) {
@@ -6938,6 +7004,8 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
       version: sdk.version
     });
   }
+  const svcName = serviceNodeName(pkg, serviceDir);
+  const projectName = projectToken(pkg, serviceDir, project);
   const generatedFiles = [];
   if (!await exists2(instrumentationFile)) {
     generatedFiles.push({
@@ -6949,14 +7017,18 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
   if (!await exists2(instrumentationNodeFile)) {
     generatedFiles.push({
       file: instrumentationNodeFile,
-      contents: useTs ? NEXT_INSTRUMENTATION_NODE_TS : NEXT_INSTRUMENTATION_NODE_JS,
+      contents: renderNextInstrumentationNode(
+        useTs ? NEXT_INSTRUMENTATION_NODE_TS : NEXT_INSTRUMENTATION_NODE_JS,
+        svcName,
+        projectName
+      ),
       skipIfExists: true
     });
   }
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
-      contents: renderEnvNeat(envServiceName(pkg, serviceDir, project)),
+      contents: renderEnvNeat(svcName, projectName),
       skipIfExists: true
     });
   }
@@ -7017,11 +7089,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) {
@@ -7047,7 +7129,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
     });
   }
@@ -7101,7 +7188,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
     });
   }
@@ -7164,7 +7256,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
     });
   }
@@ -7220,7 +7317,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
     });
   }
@@ -7312,6 +7414,10 @@ async function plan(serviceDir, opts) {
       return planAstro(serviceDir, pkg, manifestPath, project);
     }
   }
+  const runtimeKind = await detectRuntimeKind(serviceDir, pkg);
+  if (runtimeKind !== "node") {
+    return { ...empty, runtimeKind };
+  }
   const entryFile = await resolveEntry(serviceDir, pkg);
   if (!entryFile) {
     return { ...empty, libOnly: true };
@@ -7346,18 +7452,20 @@ async function plan(serviceDir, opts) {
   } catch {
     return { ...empty, libOnly: true };
   }
+  const svcName = serviceNodeName(pkg, serviceDir);
+  const projectName = projectToken(pkg, serviceDir, project);
   const generatedFiles = [];
   if (!await exists2(otelInitFile)) {
     generatedFiles.push({
       file: otelInitFile,
-      contents: otelInitContents(flavor),
+      contents: renderNodeOtelInit(otelInitContents(flavor), svcName, projectName),
       skipIfExists: true
     });
   }
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
-      contents: renderEnvNeat(envServiceName(pkg, serviceDir, project)),
+      contents: renderEnvNeat(svcName, projectName),
       skipIfExists: true
     });
   }
@@ -7382,9 +7490,13 @@ function isAllowedWritePath(serviceDir, target) {
   if (base === "package.json") return true;
   if (base === ".env.neat") return true;
   if (/^otel-init\.(?:js|cjs|mjs|ts)$/.test(base)) return true;
-  if (/^instrumentation(?:\.node)?\.(?:js|cjs|mjs|ts)$/.test(base)) return true;
-  if (/^next\.config\.(?:js|mjs|ts)$/.test(base)) return true;
   const relPosix = rel.split(import_node_path40.default.sep).join("/");
+  if (/^instrumentation(?:\.node)?\.(?:js|cjs|mjs|ts)$/.test(base)) {
+    if (relPosix === base) return true;
+    if (relPosix === `src/${base}`) return true;
+    return false;
+  }
+  if (/^next\.config\.(?:js|mjs|ts)$/.test(base)) return true;
   if (relPosix === "app/otel.server.ts" || relPosix === "app/otel.server.js") return true;
   if (/^app\/entry\.server\.(?:tsx?|jsx?)$/.test(relPosix)) return true;
   if (relPosix === "src/otel-init.ts" || relPosix === "src/otel-init.js") return true;
@@ -7410,6 +7522,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,
@@ -7896,11 +8024,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;
     }
@@ -7908,8 +8038,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 });
@@ -8113,13 +8250,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}`);
@@ -8127,6 +8266,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)");
@@ -8799,7 +8952,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;
@@ -9147,7 +9300,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;
@@ -9191,13 +9344,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}`);
@@ -9206,11 +9361,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;
@@ -9222,13 +9393,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 {
@@ -9718,7 +9900,7 @@ async function runQueryVerb(cmd, parsed) {
   }
 }
 var entry = process.argv[1] ?? "";
-if (/[\\/]cli\.(?:cjs|js)$/.test(entry) || entry.endsWith("/cli") || entry.endsWith("/neat")) {
+if (/[\\/]cli\.(?:cjs|js)$/.test(entry) || entry.endsWith("/cli") || entry.endsWith("/neat") || entry.endsWith("/neat.is")) {
   main().catch((err) => {
     console.error(err);
     process.exit(1);