crumbtrail 0.1.0 → 0.2.0

package/dist/chunk-MZDASWQ7.js

@@ -0,0 +1,1570 @@
+// src/detect.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import path from "path";
+function safeRead(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readPackageJson(dir) {
+  const text = safeRead(path.join(dir, "package.json"));
+  if (text == null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (existsSync(path.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync(path.join(dir, "bun.lockb")) || existsSync(path.join(dir, "bun.lock")))
+      return "bun";
+    if (existsSync(path.join(dir, "yarn.lock"))) return "yarn";
+    if (existsSync(path.join(dir, "package-lock.json"))) return "npm";
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function parsePnpmWorkspace(text) {
+  const out = [];
+  let inPackages = false;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.replace(/#.*$/, "");
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (!inPackages) continue;
+    const item = line.match(/^\s*-\s*["']?([^"'#]+?)["']?\s*$/);
+    if (item) {
+      out.push(item[1].trim());
+      continue;
+    }
+    if (/^\S/.test(line)) inPackages = false;
+  }
+  return out;
+}
+function expandWorkspaceGlobs(cwd, patterns) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!")) continue;
+    const wildcard = pattern.endsWith("/*") || pattern.endsWith("/**");
+    if (wildcard) {
+      const base = path.join(cwd, pattern.replace(/\/\*\*?$/, ""));
+      if (!isDir(base)) continue;
+      for (const entry of readdirSync(base)) {
+        const full = path.join(base, entry);
+        if (isDir(full) && existsSync(path.join(full, "package.json"))) {
+          dirs.add(full);
+        }
+      }
+    } else if (!pattern.includes("*")) {
+      const full = path.join(cwd, pattern);
+      if (existsSync(path.join(full, "package.json"))) dirs.add(full);
+    }
+  }
+  return [...dirs].sort();
+}
+function detectWorkspaces(cwd, pkg) {
+  let patterns = null;
+  const wsYaml = path.join(cwd, "pnpm-workspace.yaml");
+  const wsYamlText = safeRead(wsYaml);
+  if (wsYamlText != null) {
+    patterns = parsePnpmWorkspace(wsYamlText);
+  } else if (pkg?.workspaces) {
+    patterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages ?? [];
+  }
+  if (!patterns) return detectNxWorkspaces(cwd);
+  return expandWorkspaceGlobs(cwd, patterns).map((dir) => {
+    const p = readPackageJson(dir);
+    return { name: p?.name ?? path.basename(dir), dir };
+  });
+}
+function readJsonObject(file) {
+  const text = safeRead(file);
+  if (text == null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function nxProjectName(dir) {
+  const proj = readJsonObject(path.join(dir, "project.json"));
+  if (proj && typeof proj.name === "string" && proj.name) return proj.name;
+  const p = readPackageJson(dir);
+  if (p?.name) return p.name;
+  return path.basename(dir);
+}
+function detectNxWorkspaces(cwd) {
+  if (!isFile(path.join(cwd, "nx.json"))) return null;
+  const nx = readJsonObject(path.join(cwd, "nx.json"));
+  const layout = nx?.workspaceLayout ?? {};
+  const appsDir = typeof layout.appsDir === "string" ? layout.appsDir : "apps";
+  const libsDir = typeof layout.libsDir === "string" ? layout.libsDir : "libs";
+  const found = /* @__PURE__ */ new Map();
+  if (isFile(path.join(cwd, "project.json"))) {
+    found.set(cwd, { name: nxProjectName(cwd), dir: cwd });
+  }
+  for (const base of /* @__PURE__ */ new Set([appsDir, libsDir])) {
+    const baseDir = path.join(cwd, base);
+    if (!isDir(baseDir)) continue;
+    for (const entry of readdirSync(baseDir)) {
+      const full = path.join(baseDir, entry);
+      if (!isDir(full)) continue;
+      if (isFile(path.join(full, "project.json")) || existsSync(path.join(full, "package.json"))) {
+        found.set(full, { name: nxProjectName(full), dir: full });
+      }
+    }
+  }
+  if (found.size === 0) return null;
+  return [...found.values()].sort((a, b) => a.dir.localeCompare(b.dir));
+}
+function resolveViteEntry(cwd) {
+  const html = safeRead(path.join(cwd, "index.html"));
+  if (html == null) return null;
+  const tagRe = /<script\b[^>]*>/gi;
+  let m;
+  while ((m = tagRe.exec(html)) !== null) {
+    const tag = m[0];
+    if (!/\btype=["']module["']/i.test(tag)) continue;
+    const src = tag.match(/\bsrc=["']([^"']+)["']/i);
+    if (!src) continue;
+    let rel = src[1];
+    if (/^https?:/i.test(rel)) continue;
+    rel = rel.replace(/^\.?\//, "");
+    const full = path.join(cwd, rel);
+    if (isFile(full)) return full;
+  }
+  return null;
+}
+function resolveReactNativeEntry(cwd) {
+  const candidates = [
+    path.join("app", "_layout.tsx"),
+    path.join("app", "_layout.jsx"),
+    path.join("app", "_layout.js"),
+    path.join("src", "app", "_layout.tsx"),
+    path.join("src", "app", "_layout.jsx"),
+    path.join("src", "app", "_layout.js"),
+    "App.tsx",
+    "App.jsx",
+    "App.ts",
+    "App.js",
+    "index.js",
+    "index.ts"
+  ];
+  for (const c of candidates) {
+    const full = path.join(cwd, c);
+    if (isFile(full)) return full;
+  }
+  return null;
+}
+function parseNodeInvocation(script) {
+  const m = script.match(
+    /\b(?:node|nodemon|ts-node|tsx)\b(?:\s+(?:--?[^\s]+))*\s+([^\s&|]+\.[cm]?[jt]s)\b/
+  );
+  return m ? m[1] : null;
+}
+function resolveNodeEntry(cwd, pkg) {
+  const candidates = [];
+  if (typeof pkg.main === "string") candidates.push(pkg.main);
+  if (typeof pkg.bin === "string") candidates.push(pkg.bin);
+  else if (pkg.bin && typeof pkg.bin === "object") {
+    const first = Object.values(pkg.bin)[0];
+    if (first) candidates.push(first);
+  }
+  if (pkg.scripts?.start) {
+    const fromStart = parseNodeInvocation(pkg.scripts.start);
+    if (fromStart) candidates.push(fromStart);
+  }
+  for (const c of candidates) {
+    const full = path.join(cwd, c);
+    if (isFile(full)) return full;
+  }
+  return null;
+}
+function resolveNestEntry(cwd) {
+  const candidates = [path.join("src", "main.ts"), path.join("src", "main.js")];
+  for (const c of candidates) {
+    const full = path.join(cwd, c);
+    if (isFile(full)) return full;
+  }
+  return null;
+}
+function resolveRemixEntry(cwd) {
+  const candidates = [
+    path.join("app", "entry.client.tsx"),
+    path.join("app", "entry.client.jsx"),
+    path.join("app", "entry.client.js")
+  ];
+  for (const c of candidates) {
+    const full = path.join(cwd, c);
+    if (isFile(full)) return full;
+  }
+  return null;
+}
+function resolveAngularEntry(cwd) {
+  const full = path.join(cwd, "src", "main.ts");
+  return isFile(full) ? full : null;
+}
+function mergedDeps(pkg) {
+  if (!pkg) return {};
+  return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+}
+function textMentions(text, token) {
+  return new RegExp(`\\b${token}\\b`, "i").test(text);
+}
+function resolveOtlpStack(root) {
+  if (isFile(path.join(root, "manage.py"))) {
+    return {
+      stack: "django",
+      reason: "found manage.py (Django) \u2014 OTLP guidance"
+    };
+  }
+  const pyText = [
+    safeRead(path.join(root, "pyproject.toml")),
+    safeRead(path.join(root, "requirements.txt"))
+  ].filter((t) => t != null).join("\n");
+  if (pyText) {
+    if (textMentions(pyText, "fastapi")) {
+      return {
+        stack: "fastapi",
+        reason: "found a `fastapi` dependency in pyproject.toml/requirements.txt \u2014 OTLP guidance"
+      };
+    }
+    if (textMentions(pyText, "flask")) {
+      return {
+        stack: "flask",
+        reason: "found a `flask` dependency in pyproject.toml/requirements.txt \u2014 OTLP guidance"
+      };
+    }
+  }
+  if (isFile(path.join(root, "go.mod"))) {
+    return { stack: "go", reason: "found go.mod (Go) \u2014 OTLP guidance" };
+  }
+  const gemfile = safeRead(path.join(root, "Gemfile"));
+  if (gemfile != null && textMentions(gemfile, "rails")) {
+    return {
+      stack: "rails",
+      reason: "found a Gemfile referencing rails \u2014 OTLP guidance"
+    };
+  }
+  try {
+    if (readdirSync(root).some((entry) => entry.endsWith(".csproj"))) {
+      return {
+        stack: "dotnet",
+        reason: "found a *.csproj file (.NET) \u2014 OTLP guidance"
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+var DENO_UNSUPPORTED_REASON = "Deno projects aren't supported yet";
+var DOCKER_MARKER_FILES = [
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+  "Dockerfile"
+];
+var DOCKER_COMING_SOON_NOTE = "Docker/Compose files found \u2014 infra evidence sources (e.g. docker) are coming soon.";
+function hasDenoMarker(root) {
+  return isFile(path.join(root, "deno.json")) || isFile(path.join(root, "deno.jsonc"));
+}
+function hasDockerMarker(root) {
+  return DOCKER_MARKER_FILES.some((f) => isFile(path.join(root, f)));
+}
+var RECIPE_MATCHERS = [
+  [
+    // Ordered FIRST, ahead of every frontend-framework matcher. A Tauri app's
+    // frontend framework is incidental — a Tauri+Vite or Tauri+SvelteKit app
+    // carries `vite`/`@sveltejs/kit` deps and would otherwise match those
+    // matchers first, but we want the TauriTransport (local Rust store) wiring.
+    // The `@tauri-apps/*` dep + `src-tauri/` directory pair is the most specific
+    // signal, so it must win. The frontend entry is resolved like vite-spa.
+    "tauri",
+    ({ root, deps, reasons }) => {
+      const hasTauriDep = "@tauri-apps/api" in deps || "@tauri-apps/cli" in deps;
+      if (!hasTauriDep || !existsSync(path.join(root, "src-tauri")))
+        return null;
+      reasons.push("found `@tauri-apps/*` dependency + src-tauri/ directory");
+      const entryFile = resolveViteEntry(root);
+      if (!entryFile)
+        reasons.push(
+          "could not resolve a local frontend entry from index.html"
+        );
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    "next",
+    ({ deps, reasons }) => {
+      if (!("next" in deps)) return null;
+      reasons.push("found `next` dependency");
+      return { entryFile: null, nextVersion: deps.next ?? null };
+    }
+  ],
+  [
+    "sveltekit",
+    ({ deps, reasons }) => {
+      if (!("@sveltejs/kit" in deps)) return null;
+      reasons.push("found `@sveltejs/kit` dependency");
+      return { entryFile: null, nextVersion: null };
+    }
+  ],
+  [
+    "nuxt",
+    ({ deps, reasons }) => {
+      if (!("nuxt" in deps)) return null;
+      reasons.push("found `nuxt` dependency");
+      return { entryFile: null, nextVersion: null };
+    }
+  ],
+  [
+    // Ordered before vite-spa (Remix runs on Vite) and before express (Remix
+    // custom-server apps carry express). Matches classic Remix v1/v2 via any
+    // `@remix-run/*` runtime dep, or RR7 framework mode via the
+    // `react-router` + `@react-router/dev` pair. A plain `react-router-dom` SPA
+    // (no `@react-router/dev`) deliberately falls through to vite-spa.
+    "remix",
+    ({ root, deps, reasons }) => {
+      const classicRemix = "@remix-run/react" in deps || "@remix-run/node" in deps || "@remix-run/serve" in deps;
+      const rr7 = "react-router" in deps && "@react-router/dev" in deps;
+      if (!classicRemix && !rr7) return null;
+      reasons.push(
+        classicRemix ? "found `@remix-run/*` dependency" : "found `react-router` + `@react-router/dev` (React Router v7 framework mode)"
+      );
+      const entryFile = resolveRemixEntry(root);
+      if (!entryFile) reasons.push("could not resolve app/entry.client.*");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    // Ordered before vite-spa (Astro is built on Vite). There is no single
+    // deterministic client entry, so the recipe always hands off a guided
+    // snippet — entry stays null by design (not ambiguity).
+    "astro",
+    ({ deps, reasons }) => {
+      if (!("astro" in deps)) return null;
+      reasons.push("found `astro` dependency");
+      return { entryFile: null, nextVersion: null };
+    }
+  ],
+  [
+    // Ordered before vite-spa (safety; Angular has no root index.html so it
+    // wouldn't match vite-spa anyway, but keep precedence explicit). The
+    // `@angular/core` dep alone is a sufficiently specific signal; angular.json
+    // is recorded only as a confirming reason.
+    "angular",
+    ({ root, deps, reasons }) => {
+      if (!("@angular/core" in deps)) return null;
+      reasons.push("found `@angular/core` dependency");
+      if (existsSync(path.join(root, "angular.json")))
+        reasons.push("found angular.json");
+      const entryFile = resolveAngularEntry(root);
+      if (!entryFile) reasons.push("could not resolve src/main.ts");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    "vite-spa",
+    ({ root, deps, reasons }) => {
+      if (!("vite" in deps && existsSync(path.join(root, "index.html"))))
+        return null;
+      reasons.push("found `vite` dependency + index.html");
+      const entryFile = resolveViteEntry(root);
+      if (!entryFile)
+        reasons.push("could not resolve a local module entry from index.html");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    // Ordered before every backend-JS matcher: Nest apps carry
+    // `@nestjs/platform-express` / `@nestjs/platform-fastify`, which pull in
+    // express/fastify — so this must win over those matchers. The bootstrap
+    // entry lives at src/main.ts (resolveNodeEntry can't find it).
+    "nestjs",
+    ({ root, deps, reasons }) => {
+      if (!("@nestjs/core" in deps)) return null;
+      reasons.push("found `@nestjs/core` dependency");
+      const entryFile = resolveNestEntry(root);
+      if (!entryFile) reasons.push("could not resolve src/main.ts");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    "express",
+    ({ root, deps, pkg, reasons }) => {
+      if (!("express" in deps) || !pkg) return null;
+      reasons.push("found `express` dependency");
+      return { entryFile: resolveNodeEntry(root, pkg), nextVersion: null };
+    }
+  ],
+  [
+    "hono",
+    ({ root, deps, pkg, reasons }) => {
+      if (!("hono" in deps) || !pkg) return null;
+      reasons.push("found `hono` dependency");
+      return { entryFile: resolveNodeEntry(root, pkg), nextVersion: null };
+    }
+  ],
+  [
+    "fastify",
+    ({ root, deps, pkg, reasons }) => {
+      if (!("fastify" in deps) || !pkg) return null;
+      reasons.push("found `fastify` dependency");
+      return { entryFile: resolveNodeEntry(root, pkg), nextVersion: null };
+    }
+  ],
+  [
+    // Placed before the generic `node` fallback. RN doesn't carry
+    // next/sveltekit/nuxt/vite+index.html deps, so it only collides with the
+    // node matcher (an RN `package.json` `main` can resolve a node entry). The
+    // `expo` / `react-native` dep is the specific signal that must win.
+    "react-native",
+    ({ root, deps, reasons }) => {
+      if (!("expo" in deps || "react-native" in deps)) return null;
+      reasons.push("found `expo` or `react-native` dependency");
+      const entryFile = resolveReactNativeEntry(root);
+      if (!entryFile)
+        reasons.push("could not resolve an App/_layout/index entry");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    "node",
+    ({ root, pkg, reasons }) => {
+      if (!pkg) return null;
+      const nodeEntry = resolveNodeEntry(root, pkg);
+      if (!nodeEntry) return null;
+      reasons.push("resolved a Node server entry from package.json");
+      return { entryFile: nodeEntry, nextVersion: null };
+    }
+  ],
+  [
+    // Relaxed vite-spa fallback. The strict vite-spa matcher above requires a
+    // root index.html; a Vite project whose index.html lives elsewhere (or is
+    // absent) would otherwise fall through to "no recipe matched". This relaxed
+    // matcher keys on the `vite` dep alone, but is ordered AFTER every backend
+    // matcher (node included) so a project that carries express/hono/etc. plus a
+    // vite devDep still detects its backend framework. Entry resolution still
+    // needs a root index.html (resolveViteEntry), so a rootless project yields a
+    // null entry → the guided fallback-ai plan, which is strictly better DX than
+    // no match at all.
+    "vite-spa",
+    ({ root, deps, reasons }) => {
+      if (!("vite" in deps)) return null;
+      reasons.push(
+        "found `vite` dependency (no root index.html \u2014 guided fallback)"
+      );
+      const entryFile = resolveViteEntry(root);
+      if (!entryFile)
+        reasons.push("could not resolve a local module entry from index.html");
+      return { entryFile, nextVersion: null };
+    }
+  ],
+  [
+    // Ordered LAST — the least-specific fallback. These non-JS backend markers
+    // are filesystem-only (no package.json needed) and must never pre-empt a JS
+    // project, so they sit strictly after the generic `node` matcher. A single
+    // `otlp` recipe carries the detected Stack out via `otlpStack`.
+    "otlp",
+    ({ root, reasons }) => {
+      const hit = resolveOtlpStack(root);
+      if (!hit) return null;
+      reasons.push(hit.reason);
+      return { entryFile: null, nextVersion: null, otlpStack: hit.stack };
+    }
+  ]
+];
+function matchRecipe(ctx) {
+  for (const [recipe, matcher] of RECIPE_MATCHERS) {
+    const hit = matcher(ctx);
+    if (hit)
+      return {
+        recipe,
+        entryFile: hit.entryFile,
+        nextVersion: hit.nextVersion,
+        otlpStack: hit.otlpStack ?? null
+      };
+  }
+  return { recipe: null, entryFile: null, nextVersion: null, otlpStack: null };
+}
+function detect(cwd) {
+  const reasons = [];
+  const root = path.resolve(cwd);
+  const packageJsonPath = existsSync(path.join(root, "package.json")) ? path.join(root, "package.json") : null;
+  const pkg = packageJsonPath ? readPackageJson(root) : null;
+  const packageManager = detectPackageManager(root);
+  const workspaces = detectWorkspaces(root, pkg);
+  const isMonorepo = !!workspaces && workspaces.length > 0;
+  const deps = mergedDeps(pkg);
+  const notes = [];
+  if (hasDockerMarker(root)) notes.push(DOCKER_COMING_SOON_NOTE);
+  const match = matchRecipe({ root, deps, pkg, reasons });
+  const recipe = match.recipe;
+  let entryFile = match.entryFile;
+  const nextVersion = match.nextVersion;
+  const otlpStack = match.otlpStack;
+  let ambiguous = false;
+  if (isMonorepo) {
+    ambiguous = true;
+    entryFile = null;
+    reasons.push(
+      `monorepo root with ${workspaces.length} workspace package(s); pick a workspace to wire`
+    );
+  } else if (!recipe) {
+    ambiguous = true;
+    if (!pkg && hasDenoMarker(root)) reasons.push(DENO_UNSUPPORTED_REASON);
+    else reasons.push("no recipe matched");
+  } else if ((recipe === "tauri" || recipe === "remix" || recipe === "angular" || recipe === "vite-spa" || recipe === "nestjs" || recipe === "express" || recipe === "hono" || recipe === "fastify" || recipe === "react-native" || recipe === "node") && !entryFile) {
+    ambiguous = true;
+  }
+  return {
+    cwd: root,
+    packageJsonPath,
+    recipe,
+    packageManager,
+    entryFile,
+    nextVersion,
+    otlpStack,
+    isMonorepo,
+    workspaces: workspaces ?? [],
+    ambiguous,
+    reasons,
+    notes
+  };
+}
+
+// src/inject/text.ts
+var BOM = "\uFEFF";
+var DIRECTIVE_RE = /^\s*(['"])use (?:client|strict|server)\1\s*;?\s*$/;
+function analyzeSource(text) {
+  let bom = "";
+  let body = text;
+  if (body.charCodeAt(0) === 65279) {
+    bom = BOM;
+    body = body.slice(1);
+  }
+  const eol = /\r\n/.test(body) ? "\r\n" : "\n";
+  return { bom, eol, lines: body.split(/\r?\n/) };
+}
+function prologueEnd(lines) {
+  let end = 0;
+  let idx = 0;
+  if (lines[0]?.startsWith("#!")) {
+    end = 1;
+    idx = 1;
+  }
+  for (; idx < lines.length; idx++) {
+    const line = lines[idx];
+    if (line.trim() === "") continue;
+    if (DIRECTIVE_RE.test(line)) {
+      end = idx + 1;
+      continue;
+    }
+    break;
+  }
+  return end;
+}
+function referencesCrumbtrail(text) {
+  return /crumbtrail-core|crumbtrail-node/.test(text);
+}
+function prependIntoSource(existing, block) {
+  const { bom, eol, lines } = analyzeSource(existing);
+  const end = prologueEnd(lines);
+  const blockLines = block.replace(/\n+$/, "").split("\n");
+  const pre = lines.slice(0, end);
+  const post = lines.slice(end);
+  const out = [...pre];
+  if (pre.length && pre[pre.length - 1].trim() !== "") out.push("");
+  out.push(...blockLines);
+  const postHasContent = post.some((l) => l.trim() !== "");
+  if (postHasContent && post[0].trim() !== "") out.push("");
+  out.push(...post);
+  return bom + out.join(eol);
+}
+function withTrailingNewline(text) {
+  return text.endsWith("\n") ? text : text + "\n";
+}
+
+// src/inject/snippets.ts
+function clientInitSnippet(endpoint, apiKey) {
+  return [
+    'import { Crumbtrail, PRESET_PASSIVE } from "crumbtrail-core";',
+    "",
+    "Crumbtrail.init({",
+    "  ...PRESET_PASSIVE,",
+    `  httpEndpoint: ${JSON.stringify(endpoint)},`,
+    `  httpAuthToken: ${JSON.stringify(apiKey)},`,
+    "});"
+  ].join("\n");
+}
+function nuxtPluginSnippet(endpoint, apiKey) {
+  return [
+    'import { Crumbtrail, PRESET_PASSIVE } from "crumbtrail-core";',
+    "",
+    "export default defineNuxtPlugin(() => {",
+    "  Crumbtrail.init({",
+    "    ...PRESET_PASSIVE,",
+    `    httpEndpoint: ${JSON.stringify(endpoint)},`,
+    `    httpAuthToken: ${JSON.stringify(apiKey)},`,
+    "  });",
+    "});"
+  ].join("\n");
+}
+function nodeInitSnippet(endpoint) {
+  return [
+    "// Crumbtrail \u2014 auto-captures uncaught exceptions, unhandled rejections, and",
+    "// console.error. Key is read from process.env.CRUMBTRAIL_KEY, which autoCapture",
+    "// loads from your .env (written by the CLI). Express apps can also add",
+    "// createCrumbtrailExpressMiddleware for per-request capture.",
+    'import("crumbtrail-node")',
+    `  .then(({ autoCapture }) => autoCapture({ endpoint: ${JSON.stringify(endpoint)} }))`,
+    "  .catch(() => {});"
+  ].join("\n");
+}
+function singleQuoted(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function nestInitSnippet(endpoint) {
+  return [
+    "// Crumbtrail \u2014 auto-captures uncaught exceptions, unhandled rejections, and",
+    "// console.error. Key is read from process.env.CRUMBTRAIL_KEY, which autoCapture",
+    "// loads from your .env (written by the CLI). Express apps can also add",
+    "// createCrumbtrailExpressMiddleware for per-request capture.",
+    "import('crumbtrail-node')",
+    `  .then(({ autoCapture }) => autoCapture({ endpoint: ${singleQuoted(endpoint)} }))`,
+    "  .catch(() => {});"
+  ].join("\n");
+}
+function reactNativeInitSnippet(endpoint, apiKey) {
+  return [
+    'import { createReactNativeCrumbtrail } from "crumbtrail-react-native";',
+    "",
+    "createReactNativeCrumbtrail({",
+    "  config: {",
+    `    httpEndpoint: ${JSON.stringify(endpoint)},`,
+    `    httpAuthToken: ${JSON.stringify(apiKey)},`,
+    "  },",
+    "});"
+  ].join("\n");
+}
+function tauriInitSnippet() {
+  return [
+    'import { Crumbtrail, PRESET_PASSIVE } from "crumbtrail-core";',
+    'import { TauriTransport } from "crumbtrail-tauri";',
+    "",
+    "Crumbtrail.init({ ...PRESET_PASSIVE, transportInstance: new TauriTransport() });"
+  ].join("\n");
+}
+function envKeyLine(apiKey) {
+  return `CRUMBTRAIL_KEY=${apiKey}`;
+}
+
+// src/inject/io.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { execFileSync } from "child_process";
+import path2 from "path";
+function realGitStatus(cwd, target) {
+  let out;
+  try {
+    const env = Object.fromEntries(
+      Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_"))
+    );
+    out = execFileSync("git", ["status", "--porcelain", "--", target], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env
+    });
+  } catch {
+    return { isRepo: false, tracked: false, dirty: false };
+  }
+  const line = out.split("\n").find((l) => l.trim().length > 0);
+  if (!line) {
+    return { isRepo: true, tracked: true, dirty: false };
+  }
+  const code = line.slice(0, 2);
+  const untracked = code === "??";
+  return { isRepo: true, tracked: !untracked, dirty: true };
+}
+var defaultInjectIO = {
+  exists: (p) => existsSync2(p),
+  readFile: (p) => {
+    try {
+      return readFileSync2(p, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  gitStatus: realGitStatus,
+  /**
+   * Every .gitignore from `cwd` up to (and including) the git root, concatenated.
+   *
+   * Walking up is what makes this correct in a monorepo: `.env` is almost always
+   * ignored by the ROOT .gitignore, not by `packages/api/.gitignore` — and a
+   * package-local-only read would tell every service in the repo that its ingest
+   * key is about to be committed when it isn't.
+   */
+  readGitignore: (cwd) => {
+    const parts = [];
+    let dir = path2.resolve(cwd);
+    while (true) {
+      try {
+        parts.push(readFileSync2(path2.join(dir, ".gitignore"), "utf8"));
+      } catch {
+      }
+      if (existsSync2(path2.join(dir, ".git"))) break;
+      const parent = path2.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return parts.length > 0 ? parts.join("\n") : null;
+  }
+};
+
+// src/inject/recipes.ts
+import path3 from "path";
+
+// ../core/dist/index.js
+var CRUMBTRAIL_SESSION_HEADER = "X-Crumbtrail-Session-Id";
+var CRUMBTRAIL_REQUEST_HEADER = "X-Crumbtrail-Request-Id";
+var CRUMBTRAIL_SESSION_HEADER_LOWER = CRUMBTRAIL_SESSION_HEADER.toLowerCase();
+var CRUMBTRAIL_REQUEST_HEADER_LOWER = CRUMBTRAIL_REQUEST_HEADER.toLowerCase();
+var STABLE_ID_ATTRS = ["data-bug-id", "data-testid", "data-test", "id"];
+function stableAttr(el) {
+  for (const attr of STABLE_ID_ATTRS) {
+    const value = el.getAttribute?.(attr);
+    if (value) return `${attr}=${value}`;
+  }
+  return void 0;
+}
+function segment(el) {
+  const tag = el.tagName.toLowerCase();
+  const attr = stableAttr(el);
+  if (attr) return `${tag}[${attr}]`;
+  const parent = el.parentElement;
+  if (!parent) return tag;
+  let index = 1;
+  for (const sibling of Array.from(parent.children)) {
+    if (sibling === el) break;
+    if (sibling.tagName === el.tagName) index++;
+  }
+  return `${tag}:nth-of-type(${index})`;
+}
+function computeElementPath(el) {
+  const parts = [];
+  let current = el;
+  let guard = 0;
+  while (current && guard++ < 50) {
+    const seg = segment(current);
+    parts.unshift(seg);
+    if (seg.includes("[")) break;
+    current = current.parentElement;
+  }
+  return parts.join(">");
+}
+function hashString(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function computeElementSignature(el) {
+  const path5 = computeElementPath(el);
+  return { path: path5, sig: hashString(path5) };
+}
+var WebTargetDescriptorResolver = class {
+  resolve(element) {
+    try {
+      const signature = computeElementSignature(element);
+      return {
+        componentName: element.tagName.toLowerCase(),
+        ancestryHash: signature.sig,
+        selector: signature.path
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+var webTargetDescriptorResolver = new WebTargetDescriptorResolver();
+
+// ../install-shared/dist/index.js
+var JS_STACKS = [
+  "nextjs",
+  "react",
+  "vue",
+  "svelte",
+  "vite",
+  "express",
+  "hono",
+  "node"
+];
+var BACKEND_JS_STACKS = ["express", "hono", "node"];
+var OTLP_STACKS = [
+  "django",
+  "flask",
+  "fastapi",
+  "dotnet",
+  "go",
+  "rails"
+];
+function getInstallVariant(stack) {
+  const backendJs = BACKEND_JS_STACKS.includes(stack);
+  if (JS_STACKS.includes(stack)) {
+    return { stack, kind: "js", backendJs, comingSoon: false };
+  }
+  if (OTLP_STACKS.includes(stack)) {
+    return { stack, kind: "otlp", backendJs: false, comingSoon: false };
+  }
+  return { stack, kind: "infra", backendJs: false, comingSoon: true };
+}
+var OTLP_CAPABILITY_FACTS = {
+  paths: ["/v1/traces", "/v1/logs"],
+  protocols: ["http/protobuf", "http/json"],
+  authHeaders: ["X-Crumbtrail-Auth", "Authorization: Bearer"],
+  compression: { recommended: "none", accepted: ["none", "gzip"] },
+  sessionAttribute: "crumbtrail.session.id"
+};
+function otlpAuthHeaderValue(apiKey) {
+  return `X-Crumbtrail-Auth=${apiKey}`;
+}
+function otlpBearerHeaderValue(apiKey) {
+  return `Authorization=Bearer%20${apiKey}`;
+}
+function buildOtlpSnippets({
+  endpoint,
+  apiKey
+}) {
+  const [protobuf, jsonProtocol] = OTLP_CAPABILITY_FACTS.protocols;
+  return {
+    env: [
+      `OTEL_EXPORTER_OTLP_ENDPOINT=${endpoint}`,
+      `OTEL_EXPORTER_OTLP_PROTOCOL=${protobuf}   # or ${jsonProtocol}`,
+      `OTEL_EXPORTER_OTLP_COMPRESSION=${OTLP_CAPABILITY_FACTS.compression.recommended}   # recommended; gzip is also accepted`
+    ].join("\n"),
+    authHeader: [
+      `OTEL_EXPORTER_OTLP_HEADERS=${otlpAuthHeaderValue(apiKey)}`,
+      `# Or, if your exporter sends a Bearer token (note the %20-escaped space):`,
+      `# OTEL_EXPORTER_OTLP_HEADERS=${otlpBearerHeaderValue(apiKey)}`
+    ].join("\n"),
+    sessionAttr: `OTEL_RESOURCE_ATTRIBUTES=${OTLP_CAPABILITY_FACTS.sessionAttribute}=<your-session-id>`,
+    note: `Crumbtrail's OTLP receiver appends ${OTLP_CAPABILITY_FACTS.paths.join(" and ")} to the endpoint above \u2014 don't include those paths yourself. Set the ${OTLP_CAPABILITY_FACTS.sessionAttribute} resource attribute to join backend spans to the frontend session.`
+  };
+}
+function buildAgentPrompt(stack, keys) {
+  const { kind, backendJs } = getInstallVariant(stack);
+  const { endpoint, apiKey } = keys;
+  const header = [
+    "You are setting up Crumbtrail in this project. Make ONLY the changes below,",
+    "do not refactor or touch anything else, then verify the build still passes.",
+    "",
+    `Ingest endpoint: ${endpoint}`,
+    `Ingest key:      ${apiKey}`,
+    ""
+  ];
+  if (kind === "otlp") {
+    return [
+      ...header,
+      "This is a non-JS backend that already uses OpenTelemetry. Do NOT install a",
+      "second SDK. Instead, add Crumbtrail as an additional OTLP/HTTP exporter:",
+      `  1. Set OTEL_EXPORTER_OTLP_ENDPOINT=${endpoint} (the exporter appends`,
+      "     /v1/traces and /v1/logs \u2014 do not add those paths).",
+      `  2. Send the auth header X-Crumbtrail-Auth: ${apiKey} on every export`,
+      "     (or Authorization: Bearer <key> if your exporter prefers that).",
+      "  3. Stamp the resource attribute crumbtrail.session.id so spans/logs join",
+      "     the right session.",
+      "  4. Keep your existing exporter \u2014 add Crumbtrail alongside it.",
+      "  5. Verify the app still builds and starts."
+    ].join("\n");
+  }
+  const jsLines = [
+    ...header,
+    "This is a JavaScript/TypeScript project. Do the following:",
+    "  1. Install the SDK:  npm install crumbtrail-core",
+    '  2. Import the SDK:  import { Crumbtrail, PRESET_PASSIVE } from "crumbtrail-core";',
+    "  3. Initialize once at the app entry point with PRESET_PASSIVE:",
+    "       Crumbtrail.init({",
+    "         ...PRESET_PASSIVE,",
+    `         httpEndpoint: "${endpoint}",`,
+    `         httpAuthToken: "${apiKey}",`,
+    "       });"
+  ];
+  if (backendJs && stack === "express") {
+    jsLines.push(
+      "  4. This is an Express backend \u2014 also install crumbtrail-node and capture",
+      "     server errors and requests with its Express middleware:",
+      "       import {",
+      "         createCrumbtrailExpressMiddleware,",
+      "         createCrumbtrailExpressErrorMiddleware,",
+      '       } from "crumbtrail-node";',
+      `       const opts = { endpoint: "${endpoint}", authToken: "${apiKey}" };`,
+      "       app.use(createCrumbtrailExpressMiddleware(opts));      // before your routes",
+      "       app.use(createCrumbtrailExpressErrorMiddleware(opts)); // after your routes",
+      "  5. Change nothing else, then verify the build still passes."
+    );
+  } else if (backendJs) {
+    jsLines.push(
+      "  4. This is also a backend. Install crumbtrail-node; it ships no framework",
+      "     middleware for this stack, so open a headless session and record",
+      "     server-side events against it:",
+      '       import { startHeadlessSession } from "crumbtrail-node";',
+      "       const session = await startHeadlessSession({",
+      `         endpoint: "${endpoint}",`,
+      `         authToken: "${apiKey}",`,
+      '         sessionId: "<your-session-id>",',
+      "       });",
+      "       // session.record(event) for server events; session.end() when the request ends.",
+      "  5. Change nothing else, then verify the build still passes."
+    );
+  } else {
+    jsLines.push(
+      "  4. Change nothing else, then verify the build still passes."
+    );
+  }
+  return jsLines.join("\n");
+}
+
+// src/recipe-registry.ts
+var RECIPE_REGISTRY = {
+  tauri: {
+    stack: "vite",
+    // no "tauri" Stack id — Tauri frontends are typically vite
+    sdkPackages: ["crumbtrail-core", "crumbtrail-tauri"],
+    serviceName: "app",
+    kind: "inject"
+  },
+  next: {
+    stack: "nextjs",
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  sveltekit: {
+    stack: "svelte",
+    // no "sveltekit" Stack id — svelte is the closest js stack
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  nuxt: {
+    stack: "vue",
+    // no "nuxt" Stack id — vue is the closest js stack
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  remix: {
+    stack: "react",
+    // no "remix" Stack id — react is the closest js stack
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  astro: {
+    stack: "vite",
+    // no "astro" Stack id — vite is the closest generic frontend stack
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  angular: {
+    stack: "vite",
+    // no "angular" Stack id — vite is the closest generic frontend stack
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  "vite-spa": {
+    stack: "vite",
+    sdkPackages: ["crumbtrail-core"],
+    serviceName: "web",
+    kind: "inject"
+  },
+  nestjs: {
+    stack: "node",
+    // no "nestjs" Stack id — node is the backend-JS stack
+    sdkPackages: ["crumbtrail-core", "crumbtrail-node"],
+    serviceName: "api",
+    kind: "inject"
+  },
+  express: {
+    stack: "express",
+    sdkPackages: ["crumbtrail-core", "crumbtrail-node"],
+    serviceName: "api",
+    kind: "inject"
+  },
+  hono: {
+    stack: "hono",
+    sdkPackages: ["crumbtrail-core", "crumbtrail-node"],
+    serviceName: "api",
+    kind: "inject"
+  },
+  fastify: {
+    stack: "node",
+    // no dedicated "fastify" Stack id — node is the backend-JS stack
+    sdkPackages: ["crumbtrail-core", "crumbtrail-node"],
+    serviceName: "api",
+    kind: "inject"
+  },
+  "react-native": {
+    stack: "react",
+    // no "react-native" Stack id — react is the closest js stack
+    sdkPackages: ["crumbtrail-core", "crumbtrail-react-native"],
+    serviceName: "app",
+    kind: "inject"
+  },
+  node: {
+    stack: "node",
+    sdkPackages: ["crumbtrail-core", "crumbtrail-node"],
+    serviceName: "api",
+    kind: "inject"
+  },
+  otlp: {
+    // PLACEHOLDER ONLY. `otlp` is the single recipe that carries a VARIABLE
+    // detected Stack (django/flask/fastapi/go/rails/dotnet). This static value is
+    // NOT authoritative — every call site (provision.ts createService,
+    // recipes.ts buildAgentPrompt) must prefer `DetectResult.otlpStack` and only
+    // fall back to this when a detected stack is somehow absent.
+    stack: "django",
+    // Empty: this backend already speaks OpenTelemetry, so there is no SDK to
+    // install. installSdk() must guard the empty list and skip spawning entirely.
+    sdkPackages: [],
+    serviceName: "backend",
+    kind: "otlp"
+  }
+};
+
+// src/inject/recipes.ts
+function skipPlan(input, warnings = []) {
+  return {
+    recipe: input.recipe,
+    kind: "skip-already-wired",
+    targetPath: null,
+    content: null,
+    warnings: [
+      ...warnings,
+      "Project already references Crumbtrail \u2014 nothing to inject."
+    ]
+  };
+}
+function fallbackPlan(input, snippet, warnings, envAction) {
+  return {
+    recipe: input.recipe,
+    kind: "fallback-ai",
+    targetPath: null,
+    content: null,
+    snippet,
+    // Thread the real endpoint/apiKey through — never hardcode.
+    agentPrompt: buildAgentPrompt(RECIPE_REGISTRY[input.recipe].stack, {
+      endpoint: input.endpoint,
+      apiKey: input.apiKey
+    }),
+    warnings,
+    envAction
+  };
+}
+function createPlan(input, target, block, warnings = [], envAction) {
+  return {
+    recipe: input.recipe,
+    kind: "create",
+    targetPath: target,
+    content: withTrailingNewline(block),
+    warnings,
+    envAction
+  };
+}
+function prependWithPreflight(input, io, target, block, warnings = [], envAction) {
+  const existing = io.readFile(target);
+  if (existing == null) {
+    return fallbackPlan(
+      input,
+      block,
+      [
+        ...warnings,
+        `Could not read ${target}; use the snippet or AI prompt to wire it manually.`
+      ],
+      envAction
+    );
+  }
+  if (referencesCrumbtrail(existing)) {
+    return skipPlan(input, warnings);
+  }
+  const status = io.gitStatus(input.cwd, target);
+  if (status.dirty && !input.options?.force) {
+    return {
+      recipe: input.recipe,
+      kind: "needs-confirm-dirty",
+      targetPath: target,
+      content: block,
+      warnings: [
+        ...warnings,
+        `${target} has uncommitted changes \u2014 confirm (or re-run with force) before prepending.`
+      ],
+      envAction
+    };
+  }
+  return {
+    recipe: input.recipe,
+    kind: "prepend",
+    targetPath: target,
+    content: block,
+    warnings,
+    envAction
+  };
+}
+function installedNextVersion(cwd, io) {
+  const text = io.readFile(
+    path3.join(cwd, "node_modules", "next", "package.json")
+  );
+  if (text == null) return null;
+  try {
+    const pkg = JSON.parse(text);
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function projectAlreadyWired(cwd, io) {
+  const text = io.readFile(path3.join(cwd, "package.json"));
+  if (text == null) return false;
+  try {
+    const pkg = JSON.parse(text);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return "crumbtrail-core" in deps || "crumbtrail-node" in deps;
+  } catch {
+    return false;
+  }
+}
+function supportsInstrumentationClient(version) {
+  if (!version) return true;
+  const m = version.match(/(\d+)(?:\.(\d+))?/);
+  if (!m) return true;
+  const major = Number(m[1]);
+  const minor = m[2] ? Number(m[2]) : 0;
+  if (major > 15) return true;
+  if (major < 15) return false;
+  return minor >= 3;
+}
+function buildEnvAction(cwd, apiKey, io) {
+  const envPath = path3.join(cwd, ".env");
+  const existing = io.readFile(envPath);
+  if (existing != null && /^CRUMBTRAIL_KEY=/m.test(existing)) {
+    return { warning: "CRUMBTRAIL_KEY already present in .env \u2014 left as-is." };
+  }
+  const gitignore = io.readGitignore(cwd);
+  const covered = gitignore != null && /^\s*\.env\b/m.test(gitignore);
+  return {
+    action: {
+      targetPath: envPath,
+      line: envKeyLine(apiKey),
+      gitignoreWarning: covered ? void 0 : "`.env` is not covered by .gitignore \u2014 add `.env` so your ingest key is not committed."
+    },
+    warning: covered ? void 0 : "`.env` is not gitignored; the appended key could be committed."
+  };
+}
+function firstExistingDir(io, ...dirs) {
+  return dirs.find((d) => io.exists(d)) ?? null;
+}
+function planNext(input, io) {
+  const { cwd } = input;
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  const usesSrc = io.exists(path3.join(cwd, "src", "app")) || io.exists(path3.join(cwd, "src", "pages"));
+  const baseDir = usesSrc ? path3.join(cwd, "src") : cwd;
+  const effectiveVersion = installedNextVersion(cwd, io) ?? input.nextVersion;
+  if (supportsInstrumentationClient(effectiveVersion)) {
+    const target = path3.join(baseDir, "instrumentation-client.ts");
+    if (io.exists(target)) {
+      const existing = io.readFile(target);
+      if (existing && referencesCrumbtrail(existing)) return skipPlan(input);
+      return prependWithPreflight(input, io, target, block);
+    }
+    return createPlan(input, target, block);
+  }
+  const pagesApp = firstExistingDir(
+    io,
+    path3.join(baseDir, "pages", "_app.tsx"),
+    path3.join(baseDir, "pages", "_app.jsx")
+  ) ?? null;
+  if (pagesApp) {
+    return prependWithPreflight(input, io, pagesApp, block, [
+      "Older Next.js \u2014 prepending into pages/_app; move to instrumentation-client.ts after upgrading to 15.3+."
+    ]);
+  }
+  const appLayout = firstExistingDir(
+    io,
+    path3.join(baseDir, "app", "layout.tsx"),
+    path3.join(baseDir, "app", "layout.jsx")
+  ) ?? null;
+  if (appLayout) {
+    return fallbackPlan(input, block, [
+      `Next <15.3 with only an app-router root layout: client init can't be prepended into app/layout (a Server Component that never ships to the browser). Add the snippet to a "use client" module imported by the root layout, or upgrade to Next 15.3+ for the auto-loaded instrumentation-client.ts.`
+    ]);
+  }
+  return fallbackPlan(input, block, [
+    "Older Next.js detected but no app/layout or pages/_app file was found."
+  ]);
+}
+function planSvelteKit(input, io) {
+  const target = path3.join(input.cwd, "src", "hooks.client.ts");
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  if (io.exists(target)) {
+    return prependWithPreflight(input, io, target, block);
+  }
+  return createPlan(input, target, block);
+}
+function planNuxt(input, io) {
+  const { cwd } = input;
+  const baseDir = io.exists(path3.join(cwd, "app")) ? path3.join(cwd, "app") : cwd;
+  const target = path3.join(baseDir, "plugins", "crumbtrail.client.ts");
+  const block = nuxtPluginSnippet(input.endpoint, input.apiKey);
+  if (io.exists(target)) {
+    const existing = io.readFile(target);
+    if (existing && referencesCrumbtrail(existing)) return skipPlan(input);
+    return fallbackPlan(input, block, [
+      `${target} already exists and isn't Crumbtrail's \u2014 wire it manually.`
+    ]);
+  }
+  return createPlan(input, target, block);
+}
+function planVite(input, io) {
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  if (!input.entryFile) {
+    return fallbackPlan(input, block, [
+      "Could not resolve the Vite entry from index.html \u2014 wire it manually."
+    ]);
+  }
+  return prependWithPreflight(input, io, input.entryFile, block);
+}
+function planNode(input, io) {
+  const block = input.recipe === "nestjs" ? nestInitSnippet(input.endpoint) : nodeInitSnippet(input.endpoint);
+  const { action, warning } = buildEnvAction(input.cwd, input.apiKey, io);
+  const envWarnings = warning ? [warning] : [];
+  if (!input.entryFile) {
+    return fallbackPlan(
+      input,
+      block,
+      [
+        "Could not resolve the Node server entry \u2014 wire it manually.",
+        ...envWarnings
+      ],
+      action
+    );
+  }
+  return prependWithPreflight(
+    input,
+    io,
+    input.entryFile,
+    block,
+    envWarnings,
+    action
+  );
+}
+function planRemix(input, io) {
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  if (!input.entryFile) {
+    return fallbackPlan(input, block, [
+      "Could not resolve app/entry.client.* \u2014 on a React Router 7 default template the client entry is hidden, so run `npx react-router reveal` to unhide app/entry.client.tsx (and entry.server.tsx), then re-run the wizard. Otherwise add the snippet to your Remix client entry manually (do not let the CLI create it; it would omit hydrateRoot)."
+    ]);
+  }
+  return prependWithPreflight(input, io, input.entryFile, block);
+}
+function planAstro(input, _io) {
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  return fallbackPlan(input, block, [
+    "Astro has no single client entry \u2014 add this snippet inside a client-side <script> in a shared layout (e.g. src/layouts/*.astro) so it runs on every page."
+  ]);
+}
+function planAngular(input, io) {
+  const block = clientInitSnippet(input.endpoint, input.apiKey);
+  if (!input.entryFile) {
+    return fallbackPlan(input, block, [
+      "Could not resolve the Angular entry (src/main.ts) \u2014 wire it manually."
+    ]);
+  }
+  return prependWithPreflight(input, io, input.entryFile, block);
+}
+function planReactNative(input, io) {
+  const block = reactNativeInitSnippet(input.endpoint, input.apiKey);
+  if (!input.entryFile) {
+    return fallbackPlan(input, block, [
+      "Could not resolve the React Native entry (App/_layout/index) \u2014 wire it manually."
+    ]);
+  }
+  return prependWithPreflight(input, io, input.entryFile, block);
+}
+var TAURI_RUST_WARNINGS = [
+  "Tauri also needs a Rust step the CLI can't do: register the plugin in src-tauri \u2014 add `tauri-plugin-crumbtrail` to Cargo.toml and `.plugin(tauri_plugin_crumbtrail::init())` in lib.rs (crumbtrail-tauri README, step 1).",
+  "Grant the plugin permission: add `crumbtrail:default` to src-tauri/capabilities/default.json, or every Crumbtrail invoke fails (crumbtrail-tauri README, step 2)."
+];
+function planTauri(input, io) {
+  const block = tauriInitSnippet();
+  if (!input.entryFile) {
+    return fallbackPlan(input, block, [
+      "Could not resolve the Tauri frontend entry from index.html \u2014 wire it manually.",
+      ...TAURI_RUST_WARNINGS
+    ]);
+  }
+  return prependWithPreflight(input, io, input.entryFile, block, [
+    ...TAURI_RUST_WARNINGS
+  ]);
+}
+function planOtlp(input) {
+  const stack = input.stack ?? RECIPE_REGISTRY[input.recipe].stack;
+  const otlp = buildOtlpSnippets({
+    endpoint: input.endpoint,
+    apiKey: input.apiKey
+  });
+  const snippet = [
+    otlp.env,
+    "",
+    otlp.authHeader,
+    "",
+    otlp.sessionAttr,
+    "",
+    `# ${otlp.note}`
+  ].join("\n");
+  return {
+    recipe: input.recipe,
+    kind: "otlp-guidance",
+    targetPath: null,
+    content: null,
+    snippet,
+    agentPrompt: buildAgentPrompt(stack, {
+      endpoint: input.endpoint,
+      apiKey: input.apiKey
+    }),
+    warnings: []
+  };
+}
+function buildPlan(input, io = defaultInjectIO) {
+  if (projectAlreadyWired(input.cwd, io)) {
+    return skipPlan(input);
+  }
+  switch (input.recipe) {
+    case "tauri":
+      return planTauri(input, io);
+    case "react-native":
+      return planReactNative(input, io);
+    case "next":
+      return planNext(input, io);
+    case "sveltekit":
+      return planSvelteKit(input, io);
+    case "nuxt":
+      return planNuxt(input, io);
+    case "remix":
+      return planRemix(input, io);
+    case "astro":
+      return planAstro(input, io);
+    case "angular":
+      return planAngular(input, io);
+    case "vite-spa":
+      return planVite(input, io);
+    case "nestjs":
+    case "express":
+    case "hono":
+    case "fastify":
+    case "node":
+      return planNode(input, io);
+    case "otlp":
+      return planOtlp(input);
+    default: {
+      const exhaustive = input.recipe;
+      throw new Error(`Unknown recipe: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/inject/executor.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readFileSync as readFileSync3,
+  rmSync,
+  writeFileSync
+} from "fs";
+import path4 from "path";
+var defaultExecutorIO = {
+  exists: (p) => existsSync3(p),
+  readFile: (p) => {
+    try {
+      return readFileSync3(p, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  writeFile: (p, content) => writeFileSync(p, content),
+  mkdirp: (dir) => {
+    mkdirSync(dir, { recursive: true });
+  },
+  remove: (p) => {
+    rmSync(p, { force: true });
+  }
+};
+function ensureTrailingNewline(text) {
+  if (text === "") return "";
+  return text.endsWith("\n") ? text : text + "\n";
+}
+function applyAllOrNothing(ops, io) {
+  const preimages = [];
+  const written = [];
+  try {
+    for (const op of ops) {
+      const existed = io.exists(op.path);
+      const prior = existed ? io.readFile(op.path) : null;
+      preimages.push({ path: op.path, existed, content: prior });
+      let next;
+      switch (op.op) {
+        case "create":
+          if (existed) {
+            throw new Error(`refusing to overwrite existing file: ${op.path}`);
+          }
+          next = op.content;
+          break;
+        case "prepend":
+          next = prependIntoSource(prior ?? "", op.block);
+          break;
+        case "env": {
+          const base = prior ?? "";
+          if (/^CRUMBTRAIL_KEY=/m.test(base)) {
+            preimages.pop();
+            continue;
+          }
+          next = ensureTrailingNewline(base) + op.line + "\n";
+          break;
+        }
+      }
+      io.mkdirp(path4.dirname(op.path));
+      io.writeFile(op.path, next);
+      written.push(op.path);
+    }
+    return written;
+  } catch (err) {
+    for (const pre of preimages.reverse()) {
+      if (!pre.existed) io.remove(pre.path);
+      else if (pre.content != null) io.writeFile(pre.path, pre.content);
+    }
+    throw err;
+  }
+}
+function executePlan(plan, io = defaultExecutorIO, options = {}) {
+  if (plan.kind === "skip-already-wired") {
+    return {
+      kind: plan.kind,
+      written: [],
+      skipped: true,
+      message: "Already wired \u2014 skipped."
+    };
+  }
+  if (plan.kind === "fallback-ai") {
+    return {
+      kind: plan.kind,
+      written: [],
+      skipped: true,
+      message: "Ambiguous \u2014 emitted snippet + AI prompt instead of editing files."
+    };
+  }
+  if (plan.kind === "otlp-guidance") {
+    return {
+      kind: plan.kind,
+      written: [],
+      skipped: true,
+      message: "OTLP backend \u2014 printed setup guidance instead of editing files."
+    };
+  }
+  if (plan.kind === "needs-confirm-dirty" && !options.confirmDirty) {
+    return {
+      kind: plan.kind,
+      written: [],
+      skipped: true,
+      message: "Target is dirty \u2014 confirm or pass force to apply."
+    };
+  }
+  const ops = [];
+  if (plan.targetPath && plan.content != null) {
+    if (plan.kind === "create") {
+      ops.push({
+        op: "create",
+        path: plan.targetPath,
+        content: withTrailingNewline(plan.content)
+      });
+    } else {
+      ops.push({ op: "prepend", path: plan.targetPath, block: plan.content });
+    }
+  }
+  if (plan.envAction) {
+    ops.push({
+      op: "env",
+      path: plan.envAction.targetPath,
+      line: plan.envAction.line
+    });
+  }
+  const written = applyAllOrNothing(ops, io);
+  return {
+    kind: plan.kind,
+    written,
+    skipped: written.length === 0,
+    message: written.length === 0 ? "Nothing to write." : `Wrote ${written.length} file(s).`
+  };
+}
+
+export {
+  detectPackageManager,
+  parsePnpmWorkspace,
+  resolveViteEntry,
+  resolveReactNativeEntry,
+  parseNodeInvocation,
+  resolveNestEntry,
+  resolveRemixEntry,
+  resolveAngularEntry,
+  resolveOtlpStack,
+  DENO_UNSUPPORTED_REASON,
+  DOCKER_COMING_SOON_NOTE,
+  matchRecipe,
+  detect,
+  analyzeSource,
+  prologueEnd,
+  referencesCrumbtrail,
+  prependIntoSource,
+  withTrailingNewline,
+  clientInitSnippet,
+  nuxtPluginSnippet,
+  nodeInitSnippet,
+  nestInitSnippet,
+  reactNativeInitSnippet,
+  tauriInitSnippet,
+  envKeyLine,
+  defaultInjectIO,
+  RECIPE_REGISTRY,
+  projectAlreadyWired,
+  supportsInstrumentationClient,
+  buildPlan,
+  defaultExecutorIO,
+  executePlan
+};