@saptools/service-flow 0.1.2 → 0.1.4

package/dist/chunk-JY6GBGZT.js

@@ -0,0 +1,1313 @@
+#!/usr/bin/env node
+
+// src/discovery/discover-repositories.ts
+import fs from "fs/promises";
+import path2 from "path";
+
+// src/utils/path-utils.ts
+import path from "path";
+function normalizePath(value) {
+  return value.split(path.sep).join("/");
+}
+function relativePath(root, value) {
+  return normalizePath(path.relative(root, value) || ".");
+}
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function stripQuotes(value) {
+  return value.replace(/^['"`]|['"`]$/g, "");
+}
+
+// src/discovery/discover-repositories.ts
+async function discoverRepositories(rootPath, ignore) {
+  const root = path2.resolve(rootPath);
+  const ignored = new Set(ignore);
+  const found = [];
+  async function isRealGitMarker(dir) {
+    const gitPath = path2.join(dir, ".git");
+    try {
+      const st = await fs.stat(gitPath);
+      if (st.isDirectory()) {
+        const children = await fs.readdir(gitPath);
+        return children.includes("HEAD") || children.includes("config");
+      }
+      if (st.isFile()) {
+        const text = await fs.readFile(gitPath, "utf8");
+        return text.trimStart().startsWith("gitdir:");
+      }
+    } catch {
+    }
+    try {
+      const fixture = await fs.stat(path2.join(dir, ".git-fixture"));
+      return fixture.isFile() || fixture.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async function walk(dir) {
+    const rel = relativePath(root, dir);
+    if (rel !== "." && rel.split("/").some((part) => ignored.has(part))) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const hasMarker = entries.some((e) => e.name === ".git" || e.name === ".git-fixture");
+    if (hasMarker && await isRealGitMarker(dir)) {
+      found.push({
+        name: path2.basename(dir),
+        absolutePath: dir,
+        relativePath: relativePath(root, dir),
+        isGitRepo: true
+      });
+    }
+    for (const entry of entries)
+      if (entry.isDirectory() && !ignore.includes(entry.name))
+        await walk(path2.join(dir, entry.name));
+  }
+  await walk(root);
+  return found.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+
+// src/parsers/package-json-parser.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+function recordOfString(value) {
+  if (!value || typeof value !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(([, v]) => typeof v === "string")
+  );
+}
+function readRequires(cds) {
+  const requires = cds && typeof cds === "object" && "requires" in cds ? cds.requires : void 0;
+  if (!requires || typeof requires !== "object") return [];
+  return Object.entries(requires).flatMap(([alias, raw]) => {
+    if (!raw || typeof raw !== "object") return [];
+    const obj = raw;
+    const credentials = obj.credentials && typeof obj.credentials === "object" ? obj.credentials : {};
+    return [
+      {
+        alias,
+        kind: typeof obj.kind === "string" ? obj.kind : void 0,
+        model: typeof obj.model === "string" ? obj.model : void 0,
+        destination: typeof credentials.destination === "string" ? credentials.destination : void 0,
+        servicePath: typeof credentials.path === "string" ? credentials.path : void 0,
+        requestTimeout: typeof credentials.requestTimeout === "number" ? credentials.requestTimeout : void 0,
+        rawJson: JSON.stringify(raw)
+      }
+    ];
+  });
+}
+async function parsePackageJson(repoPath) {
+  try {
+    const raw = await fs2.readFile(path3.join(repoPath, "package.json"), "utf8");
+    const json = JSON.parse(raw);
+    return {
+      packageName: typeof json.name === "string" ? json.name : void 0,
+      packageVersion: typeof json.version === "string" ? json.version : void 0,
+      dependencies: {
+        ...recordOfString(json.dependencies),
+        ...recordOfString(json.devDependencies)
+      },
+      cdsRequires: readRequires(json.cds),
+      scripts: recordOfString(json.scripts)
+    };
+  } catch {
+    return { dependencies: {}, cdsRequires: [], scripts: {} };
+  }
+}
+
+// src/parsers/cds-parser.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+function lineOf(text, index) {
+  return text.slice(0, index).split("\n").length;
+}
+function maskCommentsAndStrings(text) {
+  let out = "";
+  let mode = "code";
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i] ?? "";
+    const n = text[i + 1] ?? "";
+    if (mode === "code" && c === "/" && n === "/") {
+      mode = "line";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "code" && c === "/" && n === "*") {
+      mode = "block";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "line" && c === "\n") mode = "code";
+    if (mode === "block" && c === "*" && n === "/") {
+      mode = "code";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "code" && (c === "'" || c === '"' || c === "`")) {
+      mode = c === "'" ? "single" : c === '"' ? "double" : "template";
+      out += " ";
+      continue;
+    }
+    if (mode === "single" && c === "'" || mode === "double" && c === '"' || mode === "template" && c === "`")
+      mode = "code";
+    out += mode === "code" || c === "\n" ? c : " ";
+  }
+  return out;
+}
+function readAnnotation(text, index) {
+  if (text[index] !== "@") return void 0;
+  let i = index + 1;
+  while (/\s/.test(text[i] ?? "")) i += 1;
+  if (text[i] !== "(") return void 0;
+  let depth = 0;
+  for (; i < text.length; i += 1) {
+    if (text[i] === "(") depth += 1;
+    if (text[i] === ")") depth -= 1;
+    if (depth === 0) return { end: i + 1, raw: text.slice(index, i + 1) };
+  }
+  return void 0;
+}
+function collectAnnotations(text, index) {
+  let i = index;
+  let raw = "";
+  while (i < text.length) {
+    while (/\s/.test(text[i] ?? "")) i += 1;
+    const annotation = readAnnotation(text, i);
+    if (!annotation) break;
+    raw += annotation.raw;
+    i = annotation.end;
+  }
+  return { end: i, raw };
+}
+function pathAnnotation(raw) {
+  return /path\s*:\s*['"]([^'"]+)['"]/s.exec(raw)?.[1];
+}
+function matchingBrace(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    if (text[i] === "{") depth += 1;
+    if (text[i] === "}") depth -= 1;
+    if (depth === 0) return i;
+  }
+  return text.length - 1;
+}
+function operationsFromBody(text, maskedBody, bodyOffset, filePath) {
+  return [...maskedBody.matchAll(/\b(action|function|event)\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?:returns\s+([^;{]+))?/g)].map((m) => ({
+    operationType: m[1] ?? "action",
+    operationName: m[2] ?? "unknown",
+    operationPath: ensureLeadingSlash(m[2] ?? "unknown"),
+    paramsJson: JSON.stringify((m[3] ?? "").split(",").map((part) => part.trim()).filter(Boolean)),
+    returnType: m[4]?.trim(),
+    sourceFile: normalizePath(filePath),
+    sourceLine: lineOf(text, bodyOffset + (m.index ?? 0))
+  }));
+}
+async function parseCdsFile(repoPath, filePath) {
+  const absolute = path4.join(repoPath, filePath);
+  const text = await fs3.readFile(absolute, "utf8");
+  const masked = maskCommentsAndStrings(text);
+  const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
+  const services = [];
+  const pendingAnnotations = [];
+  for (const a of masked.matchAll(/@\s*\(/g)) {
+    const annotation = collectAnnotations(masked, a.index ?? 0);
+    pendingAnnotations.push(annotation);
+  }
+  const serviceRegex = /\b(extend\s+)?service\s+([\w.]+)\b/g;
+  let match;
+  while (match = serviceRegex.exec(masked)) {
+    const afterName = collectAnnotations(masked, serviceRegex.lastIndex);
+    const open = masked.indexOf("{", afterName.end);
+    if (open === -1) continue;
+    const matchIndex = match.index;
+    const prefix = pendingAnnotations.filter((a) => a.end <= matchIndex && matchIndex - a.end < 8).map((a) => a.raw).join("");
+    const annotations = `${prefix}${afterName.raw}`;
+    const end = matchingBrace(masked, open);
+    const body = masked.slice(open + 1, end);
+    const name = match[2] ?? "UnknownService";
+    const serviceName = name.split(".").pop() ?? name;
+    const servicePath = ensureLeadingSlash(pathAnnotation(annotations) ?? serviceName);
+    services.push({
+      namespace,
+      serviceName,
+      qualifiedName: name.includes(".") ? name : namespace ? `${namespace}.${name}` : name,
+      servicePath,
+      isExtend: Boolean(match[1]),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf(text, match.index),
+      operations: operationsFromBody(text, body, open + 1, filePath)
+    });
+    serviceRegex.lastIndex = end + 1;
+  }
+  const baseOps = new Map(services.filter((s) => !s.isExtend).map((s) => [s.qualifiedName, s.operations]));
+  for (const service of services.filter((s) => s.isExtend && s.operations.length === 0)) {
+    const inherited = baseOps.get(service.qualifiedName) ?? baseOps.get(service.serviceName);
+    if (inherited) service.operations = inherited.map((op) => ({ ...op, sourceFile: service.sourceFile, sourceLine: service.sourceLine }));
+  }
+  return services;
+}
+
+// src/parsers/decorator-parser.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+import ts2 from "typescript";
+
+// src/parsers/ts-project.ts
+import ts from "typescript";
+function createSourceFile(filePath, text) {
+  return ts.createSourceFile(
+    filePath,
+    text,
+    ts.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".js") ? ts.ScriptKind.JS : ts.ScriptKind.TS
+  );
+}
+
+// src/parsers/decorator-parser.ts
+function line(sf, pos) {
+  return sf.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function decs(node) {
+  return ts2.canHaveDecorators(node) ? [...ts2.getDecorators(node) ?? []] : [];
+}
+function callName(d) {
+  const e = d.expression;
+  return ts2.isCallExpression(e) ? e.expression.getText() : e.getText();
+}
+function firstArg(d) {
+  const e = d.expression;
+  return ts2.isCallExpression(e) && e.arguments[0] ? e.arguments[0].getText() : "";
+}
+async function parseDecorators(repoPath, filePath) {
+  const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
+  const sf = createSourceFile(filePath, text);
+  const constants = /* @__PURE__ */ new Map();
+  const handlers = [];
+  function visit(node) {
+    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isStringLiteralLike(node.initializer))
+      constants.set(node.name.text, node.initializer.text);
+    if (ts2.isClassDeclaration(node)) {
+      const className = node.name?.text ?? "AnonymousHandler";
+      const hasHandler = decs(node).some((d) => callName(d) === "Handler");
+      const methods = node.members.filter(ts2.isMethodDeclaration).flatMap(
+        (m) => decs(m).filter(
+          (d) => ["Func", "Action", "On", "Event"].includes(callName(d))
+        ).map((d) => {
+          const raw = firstArg(d);
+          const value = raw.startsWith('"') || raw.startsWith("'") || raw.startsWith("`") ? stripQuotes(raw) : constants.get(raw) ?? (raw.endsWith(".name") ? raw.split(".").at(-2) : void 0);
+          return {
+            methodName: m.name.getText(),
+            decoratorKind: callName(d),
+            decoratorValue: value,
+            decoratorRawExpression: raw,
+            sourceFile: normalizePath(filePath),
+            sourceLine: line(sf, m.getStart())
+          };
+        })
+      );
+      if (hasHandler || methods.length > 0)
+        handlers.push({
+          className,
+          sourceFile: normalizePath(filePath),
+          sourceLine: line(sf, node.getStart()),
+          methods
+        });
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sf);
+  return handlers;
+}
+
+// src/parsers/handler-registration-parser.ts
+import fs5 from "fs/promises";
+import path6 from "path";
+function lineOf2(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+async function parseHandlerRegistrations(repoPath, filePath) {
+  const text = await fs5.readFile(path6.join(repoPath, filePath), "utf8");
+  const out = [];
+  for (const m of text.matchAll(
+    /createCombinedHandler\s*\(|srv\.prepend\s*\(|cds\.serve\s*\(/g
+  ))
+    out.push({
+      registrationFile: normalizePath(filePath),
+      registrationLine: lineOf2(text, m.index ?? 0),
+      registrationKind: m[0].startsWith("cds") ? "cds.serve" : "combined-handler",
+      confidence: 0.8
+    });
+  for (const m of text.matchAll(
+    /(?:const|export\s+const)\s+handlers\s*=\s*\[([\s\S]*?)\]/g
+  ))
+    for (const c of (m[1] ?? "").matchAll(/\b(\w+Handler)\b/g))
+      out.push({
+        className: c[1],
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf2(text, (m.index ?? 0) + (c.index ?? 0)),
+        registrationKind: "handler-array",
+        confidence: 0.9
+      });
+  return out;
+}
+
+// src/utils/redaction.ts
+var SENSITIVE = /authorization|cookie|token|secret|password|key|credential/i;
+function redactText(text) {
+  return text.replace(
+    /(authorization|cookie|token|secret|password|key|credential)\s*[:=]\s*(['"`]?)[^,'"`}\s]+\2/gi,
+    "$1: [REDACTED]"
+  );
+}
+function redactValue(value) {
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+      out[k] = SENSITIVE.test(k) ? "[REDACTED]" : redactValue(v);
+    return out;
+  }
+  return typeof value === "string" ? redactText(value) : value;
+}
+function summarizeExpression(text) {
+  return redactText(text).slice(0, 240);
+}
+
+// src/parsers/outbound-call-parser.ts
+import fs6 from "fs/promises";
+import path7 from "path";
+function lineOf3(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+function firstArg2(body, key) {
+  return new RegExp(`${key}\\s*:\\s*([^,}\\n]+)`).exec(body)?.[1]?.trim();
+}
+function matchingParen(text, open) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let i = open; i < text.length; i += 1) {
+    const ch = text[i] ?? "";
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === quote) quote = void 0;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(") depth += 1;
+    if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function argumentForCall(expr, marker) {
+  const idx = expr.indexOf(marker);
+  if (idx < 0) return void 0;
+  const open = expr.indexOf("(", idx + marker.length);
+  if (open < 0) return void 0;
+  const close = matchingParen(expr, open);
+  return close > open ? expr.slice(open + 1, close).trim() : void 0;
+}
+function entityFromArg(arg) {
+  if (!arg) return void 0;
+  const first = arg.split(",")[0]?.trim();
+  if (!first) return void 0;
+  return stripQuotes(first).replace(/^this\./, "");
+}
+function extractQueryEntity(expr) {
+  return entityFromArg(argumentForCall(expr, "SELECT.one.from")) ?? entityFromArg(argumentForCall(expr, "SELECT.from")) ?? entityFromArg(argumentForCall(expr, "INSERT.into")) ?? entityFromArg(argumentForCall(expr, "UPDATE")) ?? entityFromArg(argumentForCall(expr, "DELETE.from"));
+}
+async function parseOutboundCalls(repoPath, filePath) {
+  const text = await fs6.readFile(path7.join(repoPath, filePath), "utf8");
+  const out = [];
+  for (const m of text.matchAll(/(\w+)\.send\s*\(\s*\{([\s\S]*?)\}\s*\)/g)) {
+    const body = m[2] ?? "";
+    const query = firstArg2(body, "query");
+    const op = firstArg2(body, "path") ?? firstArg2(body, "event");
+    out.push({
+      callType: query ? "remote_query" : "remote_action",
+      serviceVariableName: m[1],
+      method: stripQuotes(firstArg2(body, "method") ?? "POST"),
+      operationPathExpr: op ? `/${stripQuotes(op).replace(/^\//, "")}` : void 0,
+      queryEntity: extractQueryEntity(query ?? ""),
+      payloadSummary: summarizeExpression(body),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: op || query ? 0.8 : 0.4
+    });
+  }
+  for (const m of text.matchAll(/cds\.run\s*\(/g)) {
+    const open = (m.index ?? 0) + m[0].lastIndexOf("(");
+    const close = matchingParen(text, open);
+    const expr = close > open ? text.slice(open + 1, close) : "";
+    const entity = extractQueryEntity(expr);
+    out.push({
+      callType: "local_db_query",
+      queryEntity: entity,
+      payloadSummary: summarizeExpression(expr),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: entity ? 0.9 : 0.55,
+      unresolvedReason: entity ? void 0 : "Could not resolve CAP query target entity from nested expression"
+    });
+  }
+  for (const m of text.matchAll(
+    /(\w+)\.(emit|publish|on)\s*\(\s*(['"`])([^'"`]+)\3/g
+  ))
+    out.push({
+      callType: m[2] === "on" ? "async_subscribe" : "async_emit",
+      serviceVariableName: m[1],
+      eventNameExpr: m[4],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.8
+    });
+  for (const m of text.matchAll(
+    /(?:axios\s*\(|executeHttpRequest\s*\(|useOrFetchDestination\s*\()([\s\S]*?)\)/g
+  ))
+    out.push({
+      callType: "external_http",
+      payloadSummary: summarizeExpression(m[1] ?? ""),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.7,
+      unresolvedReason: "External HTTP destination is outside indexed CAP services"
+    });
+  for (const m of text.matchAll(
+    /cds\.services(?:\[['"]([^'"]+)['"]\]|\.(\w+))\.(\w+)\s*\(/g
+  ))
+    out.push({
+      callType: "local_service_call",
+      operationPathExpr: `/${m[3] ?? ""}`,
+      payloadSummary: m[1] ?? m[2],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.75
+    });
+  return out;
+}
+
+// src/parsers/service-binding-parser.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+import ts3 from "typescript";
+function lineOf4(sf, node) {
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+function stringValue(node) {
+  if (!node) return void 0;
+  if (ts3.isStringLiteralLike(node) || ts3.isNoSubstitutionTemplateLiteral(node))
+    return node.text;
+  if (ts3.isTemplateExpression(node))
+    return node.getText().replace(/^`|`$/g, "");
+  return node.getText();
+}
+function placeholders(value) {
+  return [...(value ?? "").matchAll(/\$\{\s*(\w+)\s*\}/g)].map((m) => m[1] ?? "").filter(Boolean);
+}
+function connectFactFromCall(call) {
+  const expr = call.expression;
+  if (!ts3.isPropertyAccessExpression(expr) || expr.name.text !== "to")
+    return void 0;
+  const inner = expr.expression;
+  if (!ts3.isPropertyAccessExpression(inner) || inner.name.text !== "connect" || inner.expression.getText() !== "cds")
+    return void 0;
+  const first = call.arguments[0];
+  if (!first) return void 0;
+  const second = call.arguments[1];
+  const objectArg = ts3.isObjectLiteralExpression(first) ? first : second && ts3.isObjectLiteralExpression(second) ? second : void 0;
+  let alias;
+  let aliasExpr;
+  if (ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first))
+    alias = first.text;
+  else if (!ts3.isObjectLiteralExpression(first))
+    aliasExpr = stringValue(first);
+  if ((ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first)) && !objectArg)
+    return { alias: first.text, isDynamic: false, placeholders: [] };
+  if (!objectArg && aliasExpr)
+    return {
+      aliasExpr,
+      isDynamic: true,
+      placeholders: placeholders(aliasExpr)
+    };
+  let destinationExpr;
+  let servicePathExpr;
+  function visitObject(obj) {
+    for (const prop of obj.properties) {
+      if (!ts3.isPropertyAssignment(prop)) continue;
+      const name = ts3.isIdentifier(prop.name) || ts3.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+      if (name === "destination")
+        destinationExpr = stringValue(prop.initializer);
+      if (name === "path" || name === "servicePath")
+        servicePathExpr = stringValue(prop.initializer);
+      if (ts3.isObjectLiteralExpression(prop.initializer))
+        visitObject(prop.initializer);
+    }
+  }
+  if (objectArg) visitObject(objectArg);
+  const ph = [
+    ...placeholders(aliasExpr ?? alias),
+    ...placeholders(destinationExpr),
+    ...placeholders(servicePathExpr)
+  ];
+  return {
+    alias,
+    aliasExpr,
+    destinationExpr,
+    servicePathExpr,
+    isDynamic: ph.length > 0 || !destinationExpr && !servicePathExpr,
+    placeholders: ph
+  };
+}
+function unwrapCall(expr) {
+  if (ts3.isAwaitExpression(expr)) return unwrapCall(expr.expression);
+  if (ts3.isCallExpression(expr)) return expr;
+  return void 0;
+}
+function findConnectInExpression(expr) {
+  const direct = unwrapCall(expr);
+  if (direct) {
+    const fact = connectFactFromCall(direct);
+    if (fact) return fact;
+  }
+  let found;
+  function visit(node) {
+    if (found) return;
+    if (ts3.isCallExpression(node)) found = connectFactFromCall(node);
+    if (!found) ts3.forEachChild(node, visit);
+  }
+  visit(expr);
+  return found;
+}
+async function readSource(abs) {
+  try {
+    const text = await fs7.readFile(abs, "utf8");
+    return ts3.createSourceFile(
+      abs,
+      text,
+      ts3.ScriptTarget.Latest,
+      true,
+      ts3.ScriptKind.TS
+    );
+  } catch {
+    return void 0;
+  }
+}
+async function resolveImport(repoPath, fromFile, spec) {
+  if (!spec.startsWith(".")) return void 0;
+  const rawBase = path8.resolve(repoPath, path8.dirname(fromFile), spec);
+  const parsed = path8.parse(rawBase);
+  const base = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(parsed.ext) ? path8.join(parsed.dir, parsed.name) : rawBase;
+  for (const candidate of [
+    base,
+    `${base}.ts`,
+    `${base}.js`,
+    path8.join(base, "index.ts"),
+    path8.join(base, "index.js")
+  ]) {
+    try {
+      const st = await fs7.stat(candidate);
+      if (st.isFile()) return normalizePath(path8.relative(repoPath, candidate));
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function importsFor(repoPath, filePath, sf) {
+  const imports = [];
+  for (const stmt of sf.statements) {
+    if (!ts3.isImportDeclaration(stmt) || !ts3.isStringLiteralLike(stmt.moduleSpecifier))
+      continue;
+    const sourceFile = await resolveImport(
+      repoPath,
+      filePath,
+      stmt.moduleSpecifier.text
+    );
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name)
+      imports.push({
+        localName: clause.name.text,
+        exportedName: "default",
+        sourceFile
+      });
+    const bindings = clause.namedBindings;
+    if (bindings && ts3.isNamedImports(bindings))
+      for (const el of bindings.elements)
+        imports.push({
+          localName: el.name.text,
+          exportedName: el.propertyName?.text ?? el.name.text,
+          sourceFile
+        });
+  }
+  return imports;
+}
+function exportedLocalNames(sf) {
+  const exports = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    const direct = ts3.canHaveModifiers(stmt) ? ts3.getModifiers(stmt)?.some(
+      (m) => m.kind === ts3.SyntaxKind.ExportKeyword
+    ) ?? false : false;
+    if (direct && ts3.isFunctionDeclaration(stmt) && stmt.name)
+      exports.set(stmt.name.text, stmt.name.text);
+    if (direct && ts3.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations)
+        if (ts3.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
+    }
+    if (!ts3.isExportDeclaration(stmt) || !stmt.exportClause) continue;
+    if (!ts3.isNamedExports(stmt.exportClause)) continue;
+    for (const el of stmt.exportClause.elements)
+      exports.set(el.name.text, el.propertyName?.text ?? el.name.text);
+  }
+  return exports;
+}
+async function helperBindings(repoPath, filePath) {
+  const sf = await readSource(path8.join(repoPath, filePath));
+  if (!sf) return [];
+  const sourceFileAst = sf;
+  const out = [];
+  const exportedLocals = exportedLocalNames(sf);
+  const factsByLocal = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (ts3.isFunctionDeclaration(stmt) && stmt.name) {
+      let fact;
+      stmt.forEachChild(function visit(node) {
+        if (!fact && ts3.isReturnStatement(node) && node.expression)
+          fact = findConnectInExpression(node.expression);
+        if (!fact) ts3.forEachChild(node, visit);
+      });
+      if (fact) factsByLocal.set(stmt.name.text, { ...fact, sourceLine: lineOf4(sf, stmt) });
+    }
+    if (ts3.isVariableStatement(stmt))
+      for (const decl of stmt.declarationList.declarations) {
+        if (!ts3.isIdentifier(decl.name) || !decl.initializer) continue;
+        const fact = findConnectInExpression(decl.initializer);
+        if (fact)
+          factsByLocal.set(decl.name.text, {
+            ...fact,
+            sourceLine: lineOf4(sourceFileAst, decl)
+          });
+      }
+  }
+  for (const [exportedName, localName] of exportedLocals) {
+    const fact = factsByLocal.get(localName);
+    if (fact)
+      out.push({
+        ...fact,
+        exportedName,
+        sourceFile: normalizePath(filePath),
+        sourceLine: fact.sourceLine
+      });
+  }
+  return out;
+}
+async function parseServiceBindings(repoPath, filePath) {
+  const sf = await readSource(path8.join(repoPath, filePath));
+  if (!sf) return [];
+  const sourceFileAst = sf;
+  const out = [];
+  const imports = await importsFor(repoPath, filePath, sf);
+  const helperCache = /* @__PURE__ */ new Map();
+  const classHelpers = collectClassHelpers(sourceFileAst);
+  async function importedHelper(localName) {
+    const imp = imports.find((i) => i.localName === localName && i.sourceFile);
+    if (!imp?.sourceFile) return void 0;
+    if (!helperCache.has(imp.sourceFile))
+      helperCache.set(
+        imp.sourceFile,
+        await helperBindings(repoPath, imp.sourceFile)
+      );
+    const helper = helperCache.get(imp.sourceFile)?.find((h) => h.exportedName === imp.exportedName);
+    return helper ? { imp, helper } : void 0;
+  }
+  async function recordVariable(decl) {
+    if (!ts3.isIdentifier(decl.name) || !decl.initializer) return;
+    const call = unwrapCall(decl.initializer);
+    if (!call) return;
+    const direct = connectFactFromCall(call);
+    if (direct)
+      out.push({
+        variableName: decl.name.text,
+        ...direct,
+        sourceFile: normalizePath(filePath),
+        sourceLine: lineOf4(sourceFileAst, decl)
+      });
+    else if (ts3.isIdentifier(call.expression)) {
+      const resolved = await importedHelper(call.expression.text);
+      if (resolved)
+        out.push({
+          variableName: decl.name.text,
+          alias: resolved.helper.alias,
+          aliasExpr: resolved.helper.aliasExpr,
+          destinationExpr: resolved.helper.destinationExpr,
+          servicePathExpr: resolved.helper.servicePathExpr,
+          isDynamic: resolved.helper.isDynamic,
+          placeholders: resolved.helper.placeholders,
+          sourceFile: normalizePath(filePath),
+          sourceLine: lineOf4(sourceFileAst, decl),
+          helperChain: [
+            {
+              callerVariable: decl.name.text,
+              importedHelper: call.expression.text,
+              importSource: resolved.imp.sourceFile,
+              exportedSymbol: resolved.imp.exportedName,
+              helperSourceFile: resolved.helper.sourceFile,
+              helperSourceLine: resolved.helper.sourceLine
+            }
+          ]
+        });
+    }
+  }
+  function recordDestructuredClassHelper(decl) {
+    if (!ts3.isObjectBindingPattern(decl.name) || !decl.initializer) return;
+    const call = unwrapCall(decl.initializer);
+    if (!call || !ts3.isPropertyAccessExpression(call.expression)) return;
+    const target = call.expression;
+    if (target.expression.kind !== ts3.SyntaxKind.ThisKeyword) return;
+    for (const el of decl.name.elements) {
+      if (!ts3.isIdentifier(el.name)) continue;
+      const propertyName = el.propertyName && ts3.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const helper = classHelpers.find(
+        (h) => h.helperName === target.name.text && h.propertyName === propertyName
+      );
+      if (!helper) continue;
+      out.push({
+        variableName: el.name.text,
+        ...helper.fact,
+        sourceFile: normalizePath(filePath),
+        sourceLine: lineOf4(sourceFileAst, decl),
+        helperChain: [
+          {
+            callerVariable: el.name.text,
+            className: helper.className,
+            classHelper: helper.helperName,
+            returnedProperty: helper.propertyName,
+            helperVariable: helper.variableName,
+            helperSourceFile: normalizePath(filePath),
+            helperSourceLine: helper.sourceLine
+          }
+        ]
+      });
+    }
+  }
+  const declarations = [];
+  function collectDeclarations(node) {
+    if (ts3.isVariableDeclaration(node)) declarations.push(node);
+    ts3.forEachChild(node, collectDeclarations);
+  }
+  collectDeclarations(sourceFileAst);
+  for (const decl of declarations) {
+    recordDestructuredClassHelper(decl);
+    await recordVariable(decl);
+  }
+  return out;
+}
+function collectClassHelpers(sf) {
+  const helpers = [];
+  for (const stmt of sf.statements) {
+    if (!ts3.isClassDeclaration(stmt) || !stmt.name) continue;
+    for (const member of stmt.members) {
+      let visit2 = function(node) {
+        if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
+          const fact = findConnectInExpression(node.initializer);
+          if (fact) bindings.set(node.name.text, fact);
+        }
+        if (ts3.isReturnStatement(node) && node.expression && ts3.isObjectLiteralExpression(node.expression)) {
+          for (const prop of node.expression.properties) {
+            if (ts3.isShorthandPropertyAssignment(prop)) {
+              const fact = bindings.get(prop.name.text);
+              if (fact)
+                helpers.push({
+                  className,
+                  helperName,
+                  propertyName: prop.name.text,
+                  variableName: prop.name.text,
+                  fact,
+                  sourceLine: lineOf4(sf, prop)
+                });
+            }
+            if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.initializer)) {
+              const propertyName = ts3.isIdentifier(prop.name) || ts3.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+              const fact = propertyName ? bindings.get(prop.initializer.text) : void 0;
+              if (propertyName && fact)
+                helpers.push({
+                  className,
+                  helperName,
+                  propertyName,
+                  variableName: prop.initializer.text,
+                  fact,
+                  sourceLine: lineOf4(sf, prop)
+                });
+            }
+          }
+        }
+        ts3.forEachChild(node, visit2);
+      };
+      var visit = visit2;
+      if (!ts3.isPropertyDeclaration(member) || !member.initializer) continue;
+      if (!ts3.isIdentifier(member.name)) continue;
+      const className = stmt.name.text;
+      const helperName = member.name.text;
+      const initializer = member.initializer;
+      if (!ts3.isArrowFunction(initializer) && !ts3.isFunctionExpression(initializer))
+        continue;
+      const bindings = /* @__PURE__ */ new Map();
+      visit2(initializer);
+    }
+  }
+  return helpers;
+}
+
+// src/linker/dynamic-edge-resolver.ts
+function applyVariables(template, vars) {
+  if (!template) return void 0;
+  return template.replace(
+    /\$\{\s*(\w+)\s*\}/g,
+    (_m, key) => vars[key] ?? `\${${key}}`
+  );
+}
+
+// src/linker/service-resolver.ts
+function rows(db, operationPath, workspaceId) {
+  return db.prepare(
+    `SELECT o.id operationId,r.name repoName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score,'' reasons
+       FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
+       WHERE (? IS NULL OR r.workspace_id=?) AND (o.operation_path=? OR o.operation_name=?) ORDER BY r.name,s.service_path,o.operation_name`
+  ).all(
+    workspaceId,
+    workspaceId,
+    operationPath,
+    operationPath.replace(/^\//, "")
+  );
+}
+function resolveOperation(db, signals, workspaceId) {
+  if (!signals.operationPath)
+    return {
+      status: "unresolved",
+      candidates: [],
+      reasons: ["missing_operation_path"]
+    };
+  const candidates = rows(db, signals.operationPath, workspaceId).map((c) => ({
+    ...c,
+    score: 0.2,
+    reasons: ["operation_path_match"]
+  }));
+  if (candidates.length === 0)
+    return {
+      status: "unresolved",
+      candidates: [],
+      reasons: ["no_operation_candidates"]
+    };
+  const hasStrongSignal = Boolean(
+    signals.servicePath || signals.alias || signals.destination || signals.hasExplicitOverride
+  );
+  for (const c of candidates) {
+    if (signals.servicePath && c.servicePath === signals.servicePath) {
+      c.score += 0.75;
+      c.reasons.push("exact_service_path");
+    }
+    if (signals.servicePath && c.servicePath !== signals.servicePath) {
+      c.score -= 0.1;
+      c.reasons.push("service_path_mismatch");
+    }
+    if (signals.hasExplicitOverride) {
+      c.score += 0.2;
+      c.reasons.push("explicit_dynamic_override");
+    }
+  }
+  candidates.sort(
+    (a, b) => b.score - a.score || a.repoName.localeCompare(b.repoName)
+  );
+  const best = candidates[0];
+  const second = candidates[1];
+  if (signals.isDynamic && !signals.hasExplicitOverride && !signals.servicePath)
+    return {
+      status: "dynamic",
+      candidates,
+      reasons: ["dynamic_target_without_override"]
+    };
+  if (!hasStrongSignal)
+    return {
+      status: candidates.length > 1 ? "ambiguous" : "unresolved",
+      candidates,
+      reasons: ["operation_path_only_has_no_strong_target_signal"]
+    };
+  if (best && best.score >= 0.9 && (!second || best.score - second.score >= 0.25))
+    return {
+      status: "resolved",
+      target: best,
+      candidates,
+      reasons: best.reasons
+    };
+  return {
+    status: candidates.length > 1 ? "ambiguous" : "unresolved",
+    candidates,
+    reasons: ["candidate_score_below_resolution_threshold"]
+  };
+}
+
+// src/linker/helper-package-linker.ts
+function linkHelperPackages(db, workspaceId) {
+  const repos = db.prepare(
+    "SELECT id,name,dependencies_json FROM repositories WHERE workspace_id=?"
+  ).all(workspaceId);
+  let count = 0;
+  for (const repo of repos) {
+    const deps = JSON.parse(repo.dependencies_json);
+    for (const dep of Object.keys(deps)) {
+      const helper = repos.find((r) => r.name === dep || dep.endsWith(r.name));
+      if (helper) {
+        db.prepare(
+          "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic) VALUES(?,?,?,?,?,?,?,?,?)"
+        ).run(
+          workspaceId,
+          "REPO_IMPORTS_HELPER_PACKAGE",
+          "repo",
+          String(repo.id),
+          "repo",
+          String(helper.id),
+          0.9,
+          JSON.stringify({ dependency: dep }),
+          0
+        );
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+
+// src/linker/cross-repo-linker.ts
+function linkWorkspace(db, workspaceId, vars = {}) {
+  db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
+  let edges = linkHelperPackages(db, workspaceId);
+  let unresolved = 0;
+  const calls = db.prepare(
+    `SELECT c.*,r.name repoName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`
+  ).all(workspaceId);
+  for (const call of calls) {
+    const callType = String(call.call_type);
+    const op = applyVariables(String(call.operation_path_expr ?? ""), vars);
+    const servicePath = applyVariables(
+      call.servicePathExpr ?? call.requireServicePath,
+      vars
+    );
+    const destination = call.destinationExpr ?? call.requireDestination;
+    const isDynamic = Boolean(Number(call.isDynamic ?? 0));
+    const resolution = callType.startsWith("remote") ? resolveOperation(
+      db,
+      {
+        servicePath,
+        operationPath: op,
+        alias: call.alias,
+        destination,
+        isDynamic,
+        hasExplicitOverride: Object.keys(vars).length > 0
+      },
+      workspaceId
+    ) : { status: "unresolved", candidates: [], reasons: [] };
+    const target = resolution.target;
+    const evidence = {
+      sourceFile: call.source_file,
+      sourceLine: call.source_line,
+      file: call.source_file,
+      line: call.source_line,
+      repo: call.repoName,
+      serviceAlias: call.alias,
+      serviceAliasExpr: call.aliasExpr,
+      destination,
+      servicePath,
+      operationPath: op,
+      targetRepo: target?.repoName,
+      targetOperation: target?.operationName,
+      helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0,
+      candidates: resolution.candidates,
+      candidateCount: resolution.candidates.length,
+      resolutionStatus: resolution.status,
+      resolutionReasons: resolution.reasons
+    };
+    if (target) {
+      db.prepare(
+        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic) VALUES(?,?,?,?,?,?,?,?,?)"
+      ).run(
+        workspaceId,
+        "REMOTE_CALL_RESOLVES_TO_OPERATION",
+        "call",
+        String(call.id),
+        "operation",
+        String(target.operationId),
+        target.score,
+        JSON.stringify(evidence),
+        isDynamic ? 1 : 0
+      );
+      edges += 1;
+    } else {
+      const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
+      db.prepare(
+        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?)"
+      ).run(
+        workspaceId,
+        edgeType,
+        "call",
+        String(call.id),
+        callType.startsWith("async_") ? "event" : "external",
+        String(call.event_name_expr ?? call.query_entity ?? op ?? call.id),
+        Number(call.confidence ?? 0.2),
+        JSON.stringify(evidence),
+        isDynamic || resolution.status === "dynamic" ? 1 : 0,
+        String(
+          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? "Dynamic target requires runtime variable overrides" : "No indexed target operation matched")
+        )
+      );
+      edges += 1;
+      unresolved += edgeType === "UNRESOLVED_EDGE" ? 1 : 0;
+    }
+  }
+  return { edgeCount: edges, unresolvedCount: unresolved };
+}
+
+// src/trace/trace-engine.ts
+function normalizeOperation(value) {
+  if (!value) return void 0;
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function positiveDepth(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
+}
+function sourceFilesForStart(db, repoId, start) {
+  const handler = start.handler;
+  const operation = normalizeOperation(start.operation ?? start.operationPath);
+  if (!handler && !operation) return void 0;
+  const rows2 = db.prepare(
+    `SELECT DISTINCT hc.source_file sourceFile
+       FROM handler_classes hc LEFT JOIN handler_methods hm ON hm.handler_class_id=hc.id
+       WHERE (? IS NULL OR hc.repo_id=?) AND (? IS NULL OR hc.class_name=? OR hm.method_name=?)
+         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)`
+  ).all(
+    repoId,
+    repoId,
+    handler,
+    handler,
+    handler,
+    operation,
+    operation,
+    operation
+  );
+  if (rows2.length === 0) return void 0;
+  return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
+}
+function startScope(db, start) {
+  const repo = start.repo ? db.prepare(
+    "SELECT id,name FROM repositories WHERE name=? OR package_name=?"
+  ).get(start.repo, start.repo) : void 0;
+  if (start.repo && !repo) return { repo, selectorMatched: false };
+  const sourceFiles = sourceFilesForStart(db, repo?.id, start);
+  const hasSelector = Boolean(
+    start.handler ?? start.operation ?? start.operationPath
+  );
+  return {
+    repo,
+    sourceFiles,
+    selectorMatched: !hasSelector || sourceFiles !== void 0
+  };
+}
+function handlerFilesForOperation(db, operationId) {
+  const op = db.prepare(
+    `SELECT o.operation_name operationName,o.operation_path operationPath,s.repo_id repoId
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?`
+  ).get(operationId);
+  if (!op) return /* @__PURE__ */ new Set();
+  const operation = normalizeOperation(op.operationPath ?? op.operationName);
+  const rows2 = db.prepare(
+    `SELECT DISTINCT hc.source_file sourceFile FROM handler_classes hc
+    JOIN handler_methods hm ON hm.handler_class_id=hc.id
+    WHERE hc.repo_id=? AND (hm.decorator_value=? OR hm.method_name=? OR hm.decorator_value=?)`
+  ).all(op.repoId, operation, operation, op.operationName);
+  return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
+}
+function includeCall(type, options) {
+  if (!options.includeDb && type === "local_db_query") return false;
+  if (!options.includeExternal && type === "external_http") return false;
+  if (!options.includeAsync && type.startsWith("async_")) return false;
+  return true;
+}
+function graphForCalls(db, callIds) {
+  const map = /* @__PURE__ */ new Map();
+  if (callIds.length === 0) return map;
+  const rows2 = db.prepare(
+    `SELECT * FROM graph_edges WHERE from_kind='call' AND from_id IN (${callIds.map(() => "?").join(",")}) ORDER BY id`
+  ).all(...callIds);
+  for (const row of rows2) {
+    const id = Number(row.from_id);
+    map.set(id, [...map.get(id) ?? [], row]);
+  }
+  return map;
+}
+function candidatesFromEvidence(evidence) {
+  return Array.isArray(evidence.candidates) ? evidence.candidates.filter(
+    (candidate) => typeof candidate === "object" && candidate !== null
+  ) : [];
+}
+function evidenceWithRuntimeVariables(evidence, vars) {
+  if (!vars || Object.keys(vars).length === 0) return evidence;
+  const servicePath = typeof evidence.servicePath === "string" ? applyVariables(evidence.servicePath, vars) : void 0;
+  const operationPath = typeof evidence.operationPath === "string" ? applyVariables(evidence.operationPath, vars) : void 0;
+  const candidates = candidatesFromEvidence(evidence);
+  const matched = servicePath ? candidates.find((candidate) => candidate.servicePath === servicePath) : void 0;
+  return {
+    ...evidence,
+    servicePath: servicePath ?? evidence.servicePath,
+    operationPath: operationPath ?? evidence.operationPath,
+    runtimeVariablesApplied: true,
+    runtimeResolvedCandidate: matched ? {
+      repoName: matched.repoName,
+      servicePath: matched.servicePath,
+      operationPath: matched.operationPath,
+      operationName: matched.operationName,
+      score: matched.score
+    } : void 0
+  };
+}
+function edgeTarget(row, evidence) {
+  const runtimeCandidate = evidence.runtimeResolvedCandidate;
+  if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
+    return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
+  const servicePath = typeof evidence.servicePath === "string" ? evidence.servicePath : void 0;
+  const operationPath = typeof evidence.operationPath === "string" ? evidence.operationPath : void 0;
+  const targetOperation = typeof evidence.targetOperation === "string" ? evidence.targetOperation : void 0;
+  const targetRepo = typeof evidence.targetRepo === "string" ? evidence.targetRepo : "";
+  return servicePath && operationPath ? `${servicePath}${operationPath}` : targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
+}
+function trace(db, start, options) {
+  const scope = startScope(db, start);
+  const diagnostics = db.prepare(
+    "SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics WHERE (? IS NULL OR repo_id=?)"
+  ).all(scope.repo?.id, scope.repo?.id);
+  if (!scope.selectorMatched)
+    diagnostics.unshift({
+      severity: "warning",
+      code: "trace_start_not_found",
+      message: "No handler source matched the requested trace start selector"
+    });
+  const maxDepth = positiveDepth(options.depth);
+  const edges = [];
+  const nodes = /* @__PURE__ */ new Map();
+  const queue = scope.selectorMatched ? [{ repoId: scope.repo?.id, files: scope.sourceFiles, depth: 1 }] : [];
+  const seenScopes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || current.depth > maxDepth) continue;
+    const key = `${current.repoId ?? "*"}:${[...current.files ?? /* @__PURE__ */ new Set(["*"])].sort().join(",")}`;
+    if (seenScopes.has(key)) continue;
+    seenScopes.add(key);
+    const calls = db.prepare(
+      `SELECT c.*,r.name repoName FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE (? IS NULL OR c.repo_id=?) ORDER BY c.source_file,c.source_line`
+    ).all(current.repoId, current.repoId);
+    const filtered = calls.filter(
+      (c) => (!current.files || current.files.has(String(c.source_file))) && includeCall(String(c.call_type), options)
+    );
+    const graph = graphForCalls(
+      db,
+      filtered.map((c) => Number(c.id))
+    );
+    for (const call of filtered) {
+      const callNode = `call:${call.id}`;
+      nodes.set(callNode, {
+        id: callNode,
+        kind: "outbound_call",
+        repo: call.repoName,
+        file: call.source_file,
+        line: call.source_line,
+        callType: call.call_type
+      });
+      const graphRows = graph.get(Number(call.id)) ?? [];
+      for (const row of graphRows) {
+        if (seenEdges.has(Number(row.id))) continue;
+        seenEdges.add(Number(row.id));
+        const rawEvidence = JSON.parse(
+          String(row.evidence_json || "{}")
+        );
+        const evidence = evidenceWithRuntimeVariables(
+          rawEvidence,
+          options.vars
+        );
+        const targetNode = `${row.to_kind}:${row.to_id}`;
+        nodes.set(targetNode, {
+          id: targetNode,
+          kind: row.to_kind,
+          label: row.to_id,
+          ...evidence
+        });
+        const to = edgeTarget(row, evidence);
+        edges.push({
+          step: current.depth,
+          type: String(call.call_type),
+          from: `${call.repoName}:${call.source_file}`,
+          to,
+          evidence,
+          confidence: Number(row.confidence ?? call.confidence),
+          unresolvedReason: row.unresolved_reason
+        });
+        if (row.to_kind === "operation" && current.depth < maxDepth) {
+          const files = handlerFilesForOperation(db, row.to_id);
+          if (files.size > 0) {
+            const targetRepoId = db.prepare(
+              "SELECT s.repo_id repoId FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?"
+            ).get(row.to_id)?.repoId;
+            const nextKey = `${targetRepoId ?? "*"}:${[...files].sort().join(",")}`;
+            if (seenScopes.has(nextKey))
+              edges.push({
+                step: current.depth + 1,
+                type: "cycle",
+                from: to,
+                to: nextKey,
+                evidence: { ...evidence, cycle: true },
+                confidence: 1,
+                unresolvedReason: "Cycle detected; downstream scope already visited"
+              });
+            else
+              queue.push({
+                repoId: targetRepoId,
+                files,
+                depth: current.depth + 1
+              });
+          }
+        }
+      }
+    }
+  }
+  return { start, nodes: [...nodes.values()], edges, diagnostics };
+}
+
+export {
+  normalizePath,
+  stripQuotes,
+  discoverRepositories,
+  parsePackageJson,
+  parseCdsFile,
+  parseDecorators,
+  parseHandlerRegistrations,
+  redactText,
+  redactValue,
+  parseOutboundCalls,
+  parseServiceBindings,
+  applyVariables,
+  linkWorkspace,
+  trace
+};
+//# sourceMappingURL=chunk-JY6GBGZT.js.map