@saptools/service-flow 0.1.6 → 0.1.8

package/dist/{chunk-6C5HZ6IR.js → chunk-NBAO2R2H.js}

@@ -328,36 +328,176 @@ async function parseDecorators(repoPath, filePath) {
 }
 
 // src/parsers/handler-registration-parser.ts
+import fsSync from "fs";
 import fs5 from "fs/promises";
 import path6 from "path";
-function lineOf2(text, idx) {
-  return text.slice(0, idx).split("\n").length;
+import ts3 from "typescript";
+var MAX_EXPORT_DEPTH = 5;
+function lineOf2(sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function isRelative(source) {
+  return source.startsWith("./") || source.startsWith("../");
+}
+function sourceText(node, sourceFile) {
+  if (ts3.isIdentifier(node) || ts3.isStringLiteral(node) || ts3.isNumericLiteral(node)) return node.text;
+  return node.getText(sourceFile);
+}
+function importSourceFor(identifier, imports) {
+  const evidence = imports.get(identifier);
+  return evidence ? `${evidence.source}#${evidence.importedName}` : void 0;
 }
 async function parseHandlerRegistrations(repoPath, filePath) {
-  const text = await fs5.readFile(path6.join(repoPath, filePath), "utf8");
+  const absolutePath = path6.join(repoPath, filePath);
+  const text = await fs5.readFile(absolutePath, "utf8");
+  const sourceFile = ts3.createSourceFile(filePath, text, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  const imports = collectImports(sourceFile);
+  const localArrays = collectLocalArrays(sourceFile, imports, /* @__PURE__ */ new Map(), repoPath, filePath);
   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))
+  function emitFromExpression(expression, call) {
+    const classes = resolveArrayExpression(expression, localArrays, imports, repoPath, filePath, /* @__PURE__ */ new Set());
+    for (const cls of classes) {
       out.push({
-        className: c[1],
+        className: cls.className,
+        importSource: cls.importSource,
         registrationFile: normalizePath(filePath),
-        registrationLine: lineOf2(text, (m.index ?? 0) + (c.index ?? 0)),
-        registrationKind: "handler-array",
-        confidence: 0.9
+        registrationLine: lineOf2(sourceFile, call),
+        registrationKind: "combined-handler-class",
+        confidence: 0.95
       });
+    }
+    if (classes.length === 0) {
+      out.push({
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf2(sourceFile, call),
+        registrationKind: "combined-handler",
+        confidence: 0.75
+      });
+    }
+  }
+  function visit(node) {
+    if (ts3.isCallExpression(node) && isRegistrationCall(node)) {
+      const handlerExpr = handlerExpression(node, sourceFile);
+      if (handlerExpr) emitFromExpression(handlerExpr, node);
+      else out.push({ registrationFile: normalizePath(filePath), registrationLine: lineOf2(sourceFile, node), registrationKind: "combined-handler", confidence: 0.75 });
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return out;
+}
+function isRegistrationCall(call) {
+  const text = call.expression.getText();
+  return text.endsWith("createCombinedHandler") || text.endsWith("srv.prepend") || text.endsWith("cds.serve");
+}
+function handlerExpression(call, sourceFile) {
+  for (const arg of call.arguments) {
+    if (!ts3.isObjectLiteralExpression(arg)) continue;
+    for (const prop of arg.properties) {
+      if (!ts3.isPropertyAssignment(prop)) continue;
+      if (sourceText(prop.name, sourceFile) === "handler") return prop.initializer;
+    }
+  }
+  return void 0;
+}
+function collectImports(sourceFile) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (!ts3.isImportDeclaration(statement) || !ts3.isStringLiteral(statement.moduleSpecifier)) continue;
+    const source = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause) continue;
+    if (clause.name) imports.set(clause.name.text, { importedName: "default", source });
+    const named = clause.namedBindings;
+    if (named && ts3.isNamedImports(named)) {
+      for (const element of named.elements) imports.set(element.name.text, { importedName: element.propertyName?.text ?? element.name.text, source });
+    }
+    if (named && ts3.isNamespaceImport(named)) imports.set(named.name.text, { importedName: "*", source });
+  }
+  return imports;
+}
+function collectLocalArrays(sourceFile, imports, seed, repoPath = "", fromFile = "") {
+  const arrays = new Map(seed);
+  for (const statement of sourceFile.statements) {
+    if (ts3.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (ts3.isIdentifier(decl.name) && decl.initializer && ts3.isArrayLiteralExpression(decl.initializer)) {
+          arrays.set(decl.name.text, resolveArrayLiteral(decl.initializer, arrays, imports, repoPath, fromFile, /* @__PURE__ */ new Set()));
+        }
+      }
+    }
+  }
+  return arrays;
+}
+function resolveArrayExpression(expr, arrays, imports, repoPath, fromFile, seen) {
+  if (ts3.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen);
+  if (ts3.isIdentifier(expr)) {
+    const local = arrays.get(expr.text);
+    if (local) return local;
+    const evidence = imports.get(expr.text);
+    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen);
+    if (evidence) return [{ className: evidence.importedName === "default" ? expr.text : evidence.importedName, importSource: `${evidence.source}#${evidence.importedName}` }];
+  }
+  return [];
+}
+function resolveArrayLiteral(array, arrays, imports, repoPath, fromFile, seen) {
+  const out = [];
+  for (const element of array.elements) {
+    if (ts3.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen));
+    else if (ts3.isIdentifier(element)) out.push({ className: element.text, importSource: importSourceFor(element.text, imports) });
+  }
   return out;
 }
+function resolveImportedArray(repoPath, fromFile, evidence, seen) {
+  const moduleFile = resolveRelativeModule(repoPath, fromFile, evidence.source);
+  if (!moduleFile) return [];
+  const key = `${moduleFile}:${evidence.importedName}`;
+  if (seen.has(key) || seen.size > MAX_EXPORT_DEPTH) return [];
+  seen.add(key);
+  const exports = readExports(repoPath, moduleFile, seen);
+  if (evidence.importedName === "default") return exports.defaultArray ?? [];
+  return exports.arrays.get(evidence.importedName) ?? exports.arrays.get(exports.aliases.get(evidence.importedName) ?? evidence.importedName) ?? [];
+}
+function resolveRelativeModule(repoPath, fromFile, specifier) {
+  const base = path6.resolve(repoPath, path6.dirname(fromFile), specifier);
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path6.join(base, "index.ts"), path6.join(base, "index.js")]) {
+    try {
+      const stat = fsSync.statSync(candidate);
+      if (stat.isFile()) return normalizePath(path6.relative(repoPath, candidate));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function readExports(repoPath, filePath, seen) {
+  const absolute = path6.join(repoPath, filePath);
+  let text;
+  try {
+    text = fsSync.readFileSync(absolute, "utf8");
+  } catch {
+    return { arrays: /* @__PURE__ */ new Map(), aliases: /* @__PURE__ */ new Map() };
+  }
+  const sourceFile = ts3.createSourceFile(filePath, text, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  const imports = collectImports(sourceFile);
+  const arrays = collectLocalArrays(sourceFile, imports, /* @__PURE__ */ new Map(), repoPath, filePath);
+  const aliases = /* @__PURE__ */ new Map();
+  let defaultArray;
+  for (const statement of sourceFile.statements) {
+    if (ts3.isExportAssignment(statement) && ts3.isIdentifier(statement.expression)) defaultArray = arrays.get(statement.expression.text);
+    if (ts3.isExportDeclaration(statement) && statement.exportClause && ts3.isNamedExports(statement.exportClause)) {
+      const module = statement.moduleSpecifier && ts3.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : void 0;
+      for (const element of statement.exportClause.elements) {
+        const local = element.propertyName?.text ?? element.name.text;
+        aliases.set(element.name.text, local);
+        if (module && isRelative(module)) {
+          const imported = resolveImportedArray(repoPath, filePath, { source: module, importedName: local }, seen);
+          if (imported.length > 0) arrays.set(element.name.text, imported);
+        }
+      }
+    }
+  }
+  return { arrays, defaultArray, aliases };
+}
 
 // src/utils/redaction.ts
 var SENSITIVE = /authorization|cookie|token|secret|password|key|credential/i;
@@ -504,15 +644,15 @@ async function parseOutboundCalls(repoPath, filePath) {
 // src/parsers/service-binding-parser.ts
 import fs7 from "fs/promises";
 import path8 from "path";
-import ts3 from "typescript";
+import ts4 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))
+  if (ts4.isStringLiteralLike(node) || ts4.isNoSubstitutionTemplateLiteral(node))
     return node.text;
-  if (ts3.isTemplateExpression(node))
+  if (ts4.isTemplateExpression(node))
     return node.getText().replace(/^`|`$/g, "");
   return node.getText();
 }
@@ -521,22 +661,22 @@ function placeholders(value) {
 }
 function connectFactFromCall(call) {
   const expr = call.expression;
-  if (!ts3.isPropertyAccessExpression(expr) || expr.name.text !== "to")
+  if (!ts4.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")
+  if (!ts4.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;
+  const objectArg = ts4.isObjectLiteralExpression(first) ? first : second && ts4.isObjectLiteralExpression(second) ? second : void 0;
   let alias;
   let aliasExpr;
-  if (ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first))
+  if (ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first))
     alias = first.text;
-  else if (!ts3.isObjectLiteralExpression(first))
+  else if (!ts4.isObjectLiteralExpression(first))
     aliasExpr = stringValue(first);
-  if ((ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first)) && !objectArg)
+  if ((ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first)) && !objectArg)
     return { alias: first.text, isDynamic: false, placeholders: [] };
   if (!objectArg && aliasExpr)
     return {
@@ -548,13 +688,13 @@ function connectFactFromCall(call) {
   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 (!ts4.isPropertyAssignment(prop)) continue;
+      const name = ts4.isIdentifier(prop.name) || ts4.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))
+      if (ts4.isObjectLiteralExpression(prop.initializer))
         visitObject(prop.initializer);
     }
   }
@@ -574,8 +714,8 @@ function connectFactFromCall(call) {
   };
 }
 function unwrapCall(expr) {
-  if (ts3.isAwaitExpression(expr)) return unwrapCall(expr.expression);
-  if (ts3.isCallExpression(expr)) return expr;
+  if (ts4.isAwaitExpression(expr)) return unwrapCall(expr.expression);
+  if (ts4.isCallExpression(expr)) return expr;
   return void 0;
 }
 function findConnectInExpression(expr) {
@@ -587,8 +727,8 @@ function findConnectInExpression(expr) {
   let found;
   function visit(node) {
     if (found) return;
-    if (ts3.isCallExpression(node)) found = connectFactFromCall(node);
-    if (!found) ts3.forEachChild(node, visit);
+    if (ts4.isCallExpression(node)) found = connectFactFromCall(node);
+    if (!found) ts4.forEachChild(node, visit);
   }
   visit(expr);
   return found;
@@ -596,12 +736,12 @@ function findConnectInExpression(expr) {
 async function readSource(abs) {
   try {
     const text = await fs7.readFile(abs, "utf8");
-    return ts3.createSourceFile(
+    return ts4.createSourceFile(
       abs,
       text,
-      ts3.ScriptTarget.Latest,
+      ts4.ScriptTarget.Latest,
       true,
-      ts3.ScriptKind.TS
+      ts4.ScriptKind.TS
     );
   } catch {
     return void 0;
@@ -630,7 +770,7 @@ async function resolveImport(repoPath, fromFile, spec) {
 async function importsFor(repoPath, filePath, sf) {
   const imports = [];
   for (const stmt of sf.statements) {
-    if (!ts3.isImportDeclaration(stmt) || !ts3.isStringLiteralLike(stmt.moduleSpecifier))
+    if (!ts4.isImportDeclaration(stmt) || !ts4.isStringLiteralLike(stmt.moduleSpecifier))
       continue;
     const sourceFile = await resolveImport(
       repoPath,
@@ -646,7 +786,7 @@ async function importsFor(repoPath, filePath, sf) {
         sourceFile
       });
     const bindings = clause.namedBindings;
-    if (bindings && ts3.isNamedImports(bindings))
+    if (bindings && ts4.isNamedImports(bindings))
       for (const el of bindings.elements)
         imports.push({
           localName: el.name.text,
@@ -659,17 +799,17 @@ async function importsFor(repoPath, filePath, sf) {
 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
+    const direct = ts4.canHaveModifiers(stmt) ? ts4.getModifiers(stmt)?.some(
+      (m) => m.kind === ts4.SyntaxKind.ExportKeyword
     ) ?? false : false;
-    if (direct && ts3.isFunctionDeclaration(stmt) && stmt.name)
+    if (direct && ts4.isFunctionDeclaration(stmt) && stmt.name)
       exports.set(stmt.name.text, stmt.name.text);
-    if (direct && ts3.isVariableStatement(stmt)) {
+    if (direct && ts4.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
-        if (ts3.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
+        if (ts4.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
     }
-    if (!ts3.isExportDeclaration(stmt) || !stmt.exportClause) continue;
-    if (!ts3.isNamedExports(stmt.exportClause)) continue;
+    if (!ts4.isExportDeclaration(stmt) || !stmt.exportClause) continue;
+    if (!ts4.isNamedExports(stmt.exportClause)) continue;
     for (const el of stmt.exportClause.elements)
       exports.set(el.name.text, el.propertyName?.text ?? el.name.text);
   }
@@ -683,18 +823,18 @@ async function helperBindings(repoPath, filePath) {
   const exportedLocals = exportedLocalNames(sf);
   const factsByLocal = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    if (ts3.isFunctionDeclaration(stmt) && stmt.name) {
+    if (ts4.isFunctionDeclaration(stmt) && stmt.name) {
       let fact;
       stmt.forEachChild(function visit(node) {
-        if (!fact && ts3.isReturnStatement(node) && node.expression)
+        if (!fact && ts4.isReturnStatement(node) && node.expression)
           fact = findConnectInExpression(node.expression);
-        if (!fact) ts3.forEachChild(node, visit);
+        if (!fact) ts4.forEachChild(node, visit);
       });
       if (fact) factsByLocal.set(stmt.name.text, { ...fact, sourceLine: lineOf4(sf, stmt) });
     }
-    if (ts3.isVariableStatement(stmt))
+    if (ts4.isVariableStatement(stmt))
       for (const decl of stmt.declarationList.declarations) {
-        if (!ts3.isIdentifier(decl.name) || !decl.initializer) continue;
+        if (!ts4.isIdentifier(decl.name) || !decl.initializer) continue;
         const fact = findConnectInExpression(decl.initializer);
         if (fact)
           factsByLocal.set(decl.name.text, {
@@ -735,7 +875,7 @@ async function parseServiceBindings(repoPath, filePath) {
     return helper ? { imp, helper } : void 0;
   }
   async function recordVariable(decl) {
-    if (!ts3.isIdentifier(decl.name) || !decl.initializer) return;
+    if (!ts4.isIdentifier(decl.name) || !decl.initializer) return;
     const call = unwrapCall(decl.initializer);
     if (!call) return;
     const direct = connectFactFromCall(call);
@@ -746,7 +886,7 @@ async function parseServiceBindings(repoPath, filePath) {
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf4(sourceFileAst, decl)
       });
-    else if (ts3.isIdentifier(call.expression)) {
+    else if (ts4.isIdentifier(call.expression)) {
       const resolved = await importedHelper(call.expression.text);
       if (resolved)
         out.push({
@@ -773,14 +913,14 @@ async function parseServiceBindings(repoPath, filePath) {
     }
   }
   function recordDestructuredClassHelper(decl) {
-    if (!ts3.isObjectBindingPattern(decl.name) || !decl.initializer) return;
+    if (!ts4.isObjectBindingPattern(decl.name) || !decl.initializer) return;
     const call = unwrapCall(decl.initializer);
-    if (!call || !ts3.isPropertyAccessExpression(call.expression)) return;
+    if (!call || !ts4.isPropertyAccessExpression(call.expression)) return;
     const target = call.expression;
-    if (target.expression.kind !== ts3.SyntaxKind.ThisKeyword) return;
+    if (target.expression.kind !== ts4.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;
+      if (!ts4.isIdentifier(el.name)) continue;
+      const propertyName = el.propertyName && ts4.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const helper = classHelpers.find(
         (h) => h.helperName === target.name.text && h.propertyName === propertyName
       );
@@ -806,8 +946,8 @@ async function parseServiceBindings(repoPath, filePath) {
   }
   const declarations = [];
   function collectDeclarations(node) {
-    if (ts3.isVariableDeclaration(node)) declarations.push(node);
-    ts3.forEachChild(node, collectDeclarations);
+    if (ts4.isVariableDeclaration(node)) declarations.push(node);
+    ts4.forEachChild(node, collectDeclarations);
   }
   collectDeclarations(sourceFileAst);
   for (const decl of declarations) {
@@ -819,16 +959,16 @@ async function parseServiceBindings(repoPath, filePath) {
 function collectClassHelpers(sf) {
   const helpers = [];
   for (const stmt of sf.statements) {
-    if (!ts3.isClassDeclaration(stmt) || !stmt.name) continue;
+    if (!ts4.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) {
+        if (ts4.isVariableDeclaration(node) && ts4.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)) {
+        if (ts4.isReturnStatement(node) && node.expression && ts4.isObjectLiteralExpression(node.expression)) {
           for (const prop of node.expression.properties) {
-            if (ts3.isShorthandPropertyAssignment(prop)) {
+            if (ts4.isShorthandPropertyAssignment(prop)) {
               const fact = bindings.get(prop.name.text);
               if (fact)
                 helpers.push({
@@ -840,8 +980,8 @@ function collectClassHelpers(sf) {
                   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;
+            if (ts4.isPropertyAssignment(prop) && ts4.isIdentifier(prop.initializer)) {
+              const propertyName = ts4.isIdentifier(prop.name) || ts4.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
               const fact = propertyName ? bindings.get(prop.initializer.text) : void 0;
               if (propertyName && fact)
                 helpers.push({
@@ -855,15 +995,15 @@ function collectClassHelpers(sf) {
             }
           }
         }
-        ts3.forEachChild(node, visit2);
+        ts4.forEachChild(node, visit2);
       };
       var visit = visit2;
-      if (!ts3.isPropertyDeclaration(member) || !member.initializer) continue;
-      if (!ts3.isIdentifier(member.name)) continue;
+      if (!ts4.isPropertyDeclaration(member) || !member.initializer) continue;
+      if (!ts4.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))
+      if (!ts4.isArrowFunction(initializer) && !ts4.isFunctionExpression(initializer))
         continue;
       const bindings = /* @__PURE__ */ new Map();
       visit2(initializer);
@@ -992,149 +1132,143 @@ function normalizeName(value) {
 }
 function candidatesForDependency(repos, dep, sourceId) {
   const exact = repos.filter((repo) => repo.id !== sourceId && repo.package_name === dep);
-  if (exact.length > 0) return exact;
+  if (exact.length > 0) return { candidates: exact, strategy: "exact_package_name" };
   const normalized = normalizeName(dep);
-  return repos.filter((repo) => repo.id !== sourceId && normalizeName(repo.name) === normalized);
+  return { candidates: repos.filter((repo) => repo.id !== sourceId && normalizeName(repo.name) === normalized), strategy: "normalized_directory" };
 }
-function linkHelperPackages(db, workspaceId) {
-  const repos = db.prepare(
-    "SELECT id,name,package_name,dependencies_json FROM repositories WHERE workspace_id=?"
-  ).all(workspaceId);
-  let count = 0;
+function linkHelperPackages(db, workspaceId, generation) {
+  const repos = db.prepare("SELECT id,name,package_name,dependencies_json FROM repositories WHERE workspace_id=?").all(workspaceId);
+  const summary = { edgeCount: 0, resolvedCount: 0, ambiguousCount: 0 };
   for (const repo of repos) {
     const deps = JSON.parse(repo.dependencies_json);
     for (const dep of Object.keys(deps)) {
-      const candidates = candidatesForDependency(repos, dep, repo.id);
-      if (candidates.length === 0) continue;
-      const status = candidates.length === 1 ? "resolved" : "ambiguous";
-      const helper = candidates.length === 1 ? candidates[0] : void 0;
-      db.prepare(
-        "INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?)"
-      ).run(
+      const result = candidatesForDependency(repos, dep, repo.id);
+      if (result.candidates.length === 0) continue;
+      const status = result.candidates.length === 1 ? "resolved" : "ambiguous";
+      const helper = status === "resolved" ? result.candidates[0] : void 0;
+      db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(
         workspaceId,
         "REPO_IMPORTS_HELPER_PACKAGE",
         status,
         "repo",
         String(repo.id),
         helper ? "repo" : "repo_candidates",
-        helper ? String(helper.id) : candidates.map((candidate) => candidate.id).join(","),
+        helper ? String(helper.id) : result.candidates.map((candidate) => candidate.id).join(","),
         helper ? 1 : 0.5,
-        JSON.stringify({
-          dependency: dep,
-          candidates: candidates.map((candidate) => ({ id: candidate.id, name: candidate.name, packageName: candidate.package_name })),
-          match: helper?.package_name === dep ? "package_name" : "normalized_directory"
-        }),
+        JSON.stringify({ dependency: dep, candidates: result.candidates.map((candidate) => ({ id: candidate.id, name: candidate.name, packageName: candidate.package_name })), match: result.strategy }),
         0,
-        helper ? null : "Ambiguous dependency package candidates"
+        helper ? null : "Ambiguous dependency package candidates",
+        generation
       );
-      count += 1;
+      summary.edgeCount += 1;
+      if (helper) summary.resolvedCount += 1;
+      else summary.ambiguousCount += 1;
     }
   }
-  return count;
+  return summary;
 }
 
 // src/linker/cross-repo-linker.ts
 function linkWorkspace(db, workspaceId, vars = {}) {
   return db.transaction(() => {
+    const generation = nextGraphGeneration(db, workspaceId);
     db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
-    let edges = linkHelperPackages(db, workspaceId);
-    let unresolved = 0;
-    let resolvedCount = 0;
-    let ambiguousCount = 0;
-    let dynamicCount = 0;
-    let terminalCount = 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: applyVariables(call.aliasExpr ?? call.alias, vars),
-          destination: applyVariables(destination, vars),
-          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: applyVariables(destination, vars),
-        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,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic) VALUES(?,?,?,?,?,?,?,?,?,?)"
-        ).run(
-          workspaceId,
-          "REMOTE_CALL_RESOLVES_TO_OPERATION",
-          "resolved",
-          "call",
-          String(call.id),
-          "operation",
-          String(target.operationId),
-          target.score,
-          JSON.stringify(evidence),
-          isDynamic ? 1 : 0
-        );
-        edges += 1;
-        resolvedCount += 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";
-        const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
-        const unresolvedReason = status === "terminal" ? null : String(
-          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}` : "No indexed target operation matched")
-        );
-        db.prepare(
-          "INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?)"
-        ).run(
-          workspaceId,
-          edgeType,
-          status,
-          "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,
-          unresolvedReason
-        );
-        edges += 1;
-        unresolved += status === "unresolved" ? 1 : 0;
-        ambiguousCount += status === "ambiguous" ? 1 : 0;
-        dynamicCount += status === "dynamic" ? 1 : 0;
-        terminalCount += status === "terminal" ? 1 : 0;
-      }
-    }
-    return { edgeCount: edges, unresolvedCount: unresolved, resolvedCount, ambiguousCount, dynamicCount, terminalCount };
+    const deps = linkHelperPackages(db, workspaceId, generation);
+    const callSummary = linkCalls(db, workspaceId, vars, generation);
+    const impl = linkImplementations(db, workspaceId, generation);
+    db.prepare("UPDATE repositories SET graph_generation=?, graph_stale_reason=NULL, graph_stale_at=NULL WHERE workspace_id=?").run(generation, workspaceId);
+    return { ...callSummary, edgeCount: deps.edgeCount + callSummary.edgeCount + impl.edgeCount, dependencyResolvedCount: deps.resolvedCount, dependencyAmbiguousCount: deps.ambiguousCount, implementationResolvedCount: impl.resolvedCount, implementationAmbiguousCount: impl.ambiguousCount };
   });
 }
+function nextGraphGeneration(db, workspaceId) {
+  const row = db.prepare("SELECT COALESCE(MAX(graph_generation),0) generation FROM repositories WHERE workspace_id=?").get(workspaceId);
+  return Number(row?.generation ?? 0) + 1;
+}
+function linkCalls(db, workspaceId, vars, generation) {
+  let edgeCount = 0;
+  let unresolvedCount = 0;
+  let resolvedCount = 0;
+  let ambiguousCount = 0;
+  let dynamicCount = 0;
+  let terminalCount = 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 result = insertCallEdge(db, workspaceId, call, vars, generation);
+    edgeCount += 1;
+    resolvedCount += result.status === "resolved" ? 1 : 0;
+    unresolvedCount += result.status === "unresolved" ? 1 : 0;
+    ambiguousCount += result.status === "ambiguous" ? 1 : 0;
+    dynamicCount += result.status === "dynamic" ? 1 : 0;
+    terminalCount += result.status === "terminal" ? 1 : 0;
+  }
+  return { edgeCount, unresolvedCount, resolvedCount, ambiguousCount, dynamicCount, terminalCount };
+}
+function insertCallEdge(db, workspaceId, call, vars, generation) {
+  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: applyVariables(call.aliasExpr ?? call.alias, vars), destination: destination ? applyVariables(destination, vars) : void 0, isDynamic, hasExplicitOverride: Object.keys(vars).length > 0 }, workspaceId) : { status: "unresolved", candidates: [], reasons: [] };
+  const evidence = callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0);
+  if (resolution.target) {
+    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "REMOTE_CALL_RESOLVES_TO_OPERATION", "resolved", "call", String(call.id), "operation", String(resolution.target.operationId), resolution.target.score, JSON.stringify(evidence), isDynamic ? 1 : 0, generation);
+    return { status: "resolved" };
+  }
+  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";
+  const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
+  const unresolvedReason = status === "terminal" ? null : String(call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}` : "No indexed target operation matched"));
+  db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, edgeType, status, "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, unresolvedReason, generation);
+  return { status };
+}
+function callEvidence(call, resolution, servicePath, op, destination) {
+  return { 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: resolution.target?.repoName, targetOperation: resolution.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, analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
+}
+function linkImplementations(db, workspaceId, generation) {
+  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,s.service_path servicePath,s.repo_id modelRepoId,r.package_name modelPackage FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId);
+  let edgeCount = 0;
+  let resolvedCount = 0;
+  let ambiguousCount = 0;
+  for (const operation of operations) {
+    const rows2 = implementationCandidates(db, workspaceId, operation);
+    if (rows2.length === 0) continue;
+    const unique = rows2.length === 1 ? rows2[0] : void 0;
+    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", unique ? "resolved" : "ambiguous", "operation", String(operation.operationId), unique ? "handler_method" : "handler_method_candidates", unique ? String(unique.methodId) : rows2.map((row) => row.methodId).join(","), unique ? 0.95 : 0.5, JSON.stringify({ servicePath: operation.servicePath, operationPath: operation.operationPath, operationName: operation.operationName, candidates: rows2, evidence: "registered_application_dependency" }), 0, unique ? null : "Ambiguous registered handler implementation candidates", generation);
+    edgeCount += 1;
+    if (unique) resolvedCount += 1;
+    else ambiguousCount += 1;
+  }
+  return { edgeCount, resolvedCount, ambiguousCount };
+}
+function implementationCandidates(db, workspaceId, operation) {
+  const rows2 = db.prepare(`SELECT DISTINCT
+      hm.id methodId,
+      hc.id classId,
+      hc.class_name className,
+      hc.source_file sourceFile,
+      hc.source_line sourceLine,
+      hr.repo_id applicationRepoId,
+      hr.registration_file registrationFile,
+      hr.registration_line registrationLine,
+      hr.import_source importSource,
+      handlerRepo.id handlerRepoId,
+      handlerRepo.name handlerRepo,
+      appRepo.name applicationRepo,
+      CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
+      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(? AS TEXT)) THEN 1 ELSE 0 END appDependsOnModel,
+      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=CAST(? AS TEXT)) THEN 1 ELSE 0 END handlerDependsOnModel
+    FROM handler_methods hm
+    JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
+    JOIN handler_registrations hr ON (hr.handler_class_id=hc.id OR (hr.class_name=hc.class_name AND (hr.repo_id=hc.repo_id OR hr.import_source IS NOT NULL)))
+    JOIN repositories appRepo ON appRepo.id=hr.repo_id
+    WHERE appRepo.workspace_id=?
+      AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=?)`).all(operation.modelRepoId, operation.modelRepoId, workspaceId, normalizedOperation(String(operation.operationPath ?? "")), operation.operationName, operation.operationName);
+  return rows2.filter((row) => Boolean(Number(row.sameRepoRegistration)) || Boolean(Number(row.appDependsOnModel)) || Boolean(Number(row.handlerDependsOnModel)));
+}
+function normalizedOperation(value) {
+  return value.startsWith("/") ? value.slice(1) : value;
+}
 
 // src/trace/trace-engine.ts
 function normalizeOperation(value) {
@@ -1182,8 +1316,10 @@ function startScope(db, start) {
   if (start.repo && !repo) return { repo, selectorMatched: false };
   const sourceFiles = sourceFilesForStart(db, repo?.id, start);
   const hasSelector = Boolean(
-    start.handler ?? start.operation ?? start.operationPath
+    start.handler ?? start.operation ?? start.operationPath ?? start.servicePath
   );
+  if (start.servicePath && !start.operation && !start.operationPath && !start.handler)
+    return { repo, selectorMatched: false };
   return {
     repo,
     sourceFiles,
@@ -1204,6 +1340,12 @@ function handlerFilesForOperation(db, operationId) {
   ).all(op.repoId, operation, operation, op.operationName);
   return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
 }
+function implementationScope(db, operationId) {
+  const edge = db.prepare("SELECT * FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND status='resolved' AND from_kind='operation' AND from_id=? ORDER BY id LIMIT 1").get(operationId);
+  if (!edge) return { files: /* @__PURE__ */ new Set() };
+  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id WHERE hm.id=?").get(edge.to_id);
+  return { repoId: row?.repoId, files: new Set(row?.sourceFile ? [row.sourceFile] : []) };
+}
 function includeCall(type, options) {
   if (!options.includeDb && type === "local_db_query") return false;
   if (!options.includeExternal && type === "external_http") return false;
@@ -1288,11 +1430,14 @@ function trace(db, start, options) {
   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);
+  const stale = db.prepare("SELECT name,graph_stale_reason reason FROM repositories WHERE graph_stale_reason IS NOT NULL AND (? IS NULL OR id=?)").all(scope.repo?.id, scope.repo?.id);
+  for (const row of stale)
+    diagnostics.unshift({ severity: "warning", code: "graph_stale", message: `Graph is stale for ${row.name ?? "repository"}: ${row.reason ?? "facts_changed"}. Run service-flow link.` });
   if (!scope.selectorMatched)
     diagnostics.unshift({
       severity: "warning",
       code: "trace_start_not_found",
-      message: "No handler source matched the requested trace start selector"
+      message: start.servicePath && !start.operation && !start.operationPath && !start.handler ? "Service-only trace requires --operation or --path and will not broaden to the whole workspace" : "No handler source matched the requested trace start selector"
     });
   const maxDepth = positiveDepth(options.depth);
   const edges = [];
@@ -1354,9 +1499,10 @@ function trace(db, start, options) {
           unresolvedReason: effective.unresolvedReason
         });
         if (effectiveRow.to_kind === "operation" && current.depth < maxDepth) {
-          const files = handlerFilesForOperation(db, effectiveRow.to_id);
+          const implementation = implementationScope(db, effectiveRow.to_id);
+          const files = implementation.files.size > 0 ? implementation.files : handlerFilesForOperation(db, effectiveRow.to_id);
           if (files.size > 0) {
-            const targetRepoId = db.prepare(
+            const targetRepoId = implementation.repoId ?? 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(effectiveRow.to_id)?.repoId;
             const nextKey = `${targetRepoId ?? "*"}:${[...files].sort().join(",")}`;
@@ -1402,4 +1548,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-6C5HZ6IR.js.map
+//# sourceMappingURL=chunk-NBAO2R2H.js.map