@saptools/service-flow 0.1.7 → 0.1.9

package/dist/{chunk-YFT57U54.js → chunk-HQMAFSRR.js}

@@ -328,45 +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 = [];
-  const imports = /* @__PURE__ */ new Map();
-  for (const m of text.matchAll(/import\s+\{?\s*([A-Za-z0-9_,\s]+)\s*\}?\s+from\s+['"]([^'"]+)['"]/g)) {
-    const source = m[2];
-    for (const name of (m[1] ?? "").split(",")) {
-      const symbol = name.trim().split(/\s+as\s+/).pop()?.trim();
-      if (symbol) imports.set(symbol, source);
+  function emitFromExpression(expression, call) {
+    const classes = resolveArrayExpression(expression, localArrays, imports, repoPath, filePath, /* @__PURE__ */ new Set());
+    for (const cls of classes) {
+      out.push({
+        className: cls.className,
+        importSource: cls.importSource,
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf2(sourceFile, call),
+        registrationKind: "combined-handler-class",
+        confidence: 0.95
+      });
     }
-  }
-  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))
+    if (classes.length === 0) {
       out.push({
-        className: c[1],
-        importSource: imports.get(c[1]),
         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",
+        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;
@@ -513,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();
 }
@@ -530,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 {
@@ -557,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);
     }
   }
@@ -583,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) {
@@ -596,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;
@@ -605,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;
@@ -639,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,
@@ -655,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,
@@ -668,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);
   }
@@ -692,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, {
@@ -744,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);
@@ -755,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({
@@ -782,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
       );
@@ -815,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) {
@@ -828,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({
@@ -849,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({
@@ -864,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);
@@ -1094,23 +1225,176 @@ 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);
+  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.name modelRepo,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);
+    const candidates = rankedImplementationCandidates(db, workspaceId, operation);
+    const accepted = candidates.filter((candidate) => candidate.accepted);
+    if (accepted.length === 0) continue;
+    const topScore = accepted[0]?.score ?? 0;
+    const winners = accepted.filter((candidate) => candidate.score === topScore);
+    const unique = winners.length === 1 ? winners[0] : void 0;
+    const evidence = {
+      servicePath: operation.servicePath,
+      operationPath: operation.operationPath,
+      operationName: operation.operationName,
+      modelPackage: { id: operation.modelRepoId, name: operation.modelRepo, packageName: operation.modelPackage },
+      candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
+    };
+    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", graphId(operation.operationId), unique ? "handler_method" : "handler_method_candidates", unique ? graphId(unique.methodId) : winners.map((row) => graphId(row.methodId)).join(","), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : "Ambiguous registered handler implementation candidates", generation);
     edgeCount += 1;
     if (unique) resolvedCount += 1;
     else ambiguousCount += 1;
   }
   return { edgeCount, resolvedCount, ambiguousCount };
 }
+function rankedImplementationCandidates(db, workspaceId, operation) {
+  const rows2 = implementationCandidates(db, workspaceId, operation);
+  return rows2.map((row) => scoreImplementationCandidate(row, operation)).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+}
 function implementationCandidates(db, workspaceId, operation) {
-  return 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,handlerRepo.name handlerRepo,appRepo.name applicationRepo 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.class_name=hc.class_name JOIN repositories appRepo ON appRepo.id=hr.repo_id JOIN graph_edges modelDep ON modelDep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND modelDep.status='resolved' AND modelDep.from_kind='repo' AND modelDep.from_id=CAST(appRepo.id AS TEXT) AND modelDep.to_id=CAST(? AS TEXT) JOIN graph_edges handlerDep ON handlerDep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND handlerDep.status='resolved' AND handlerDep.from_kind='repo' AND handlerDep.from_id=CAST(appRepo.id AS TEXT) AND handlerDep.to_id=CAST(handlerRepo.id AS TEXT) WHERE appRepo.workspace_id=? AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=?)`).all(operation.modelRepoId, workspaceId, normalizedOperation(String(operation.operationPath ?? "")), operation.operationName, operation.operationName);
+  const modelRepoGraphId = graphId(operation.modelRepoId);
+  return 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.registration_kind registrationKind,
+      hr.import_source importSource,
+      handlerRepo.id handlerRepoId,
+      handlerRepo.name handlerRepo,
+      handlerRepo.package_name handlerPackage,
+      appRepo.name applicationRepo,
+      appRepo.package_name applicationPackage,
+      ? modelRepoId,
+      ? modelRepo,
+      ? modelPackage,
+      ? servicePath,
+      ? operationPath,
+      ? operationName,
+      CASE WHEN appRepo.id=? THEN 1 ELSE 0 END modelIsApplicationRepo,
+      CASE WHEN handlerRepo.id=? THEN 1 ELSE 0 END modelIsHandlerRepo,
+      CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
+      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
+      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
+      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=?) 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(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
+      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=?) 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.modelRepo,
+    operation.modelPackage,
+    operation.servicePath,
+    operation.operationPath,
+    operation.operationName,
+    operation.modelRepoId,
+    operation.modelRepoId,
+    operation.servicePath,
+    modelRepoGraphId,
+    modelRepoGraphId,
+    workspaceId,
+    normalizedOperation(String(operation.operationPath ?? "")),
+    operation.operationName,
+    operation.operationName
+  );
+}
+function scoreImplementationCandidate(row, operation) {
+  const acceptedReasons = [];
+  const rejectedReasons = [];
+  let score = 0;
+  const modelIsApplicationRepo = flag(row.modelIsApplicationRepo);
+  const modelIsHandlerRepo = flag(row.modelIsHandlerRepo);
+  const localServicePathMatch = flag(row.localServicePathMatch);
+  const applicationHasLocalServices = flag(row.applicationHasLocalServices);
+  const appDependsOnModel = flag(row.appDependsOnModel);
+  const appDependsOnHandler = flag(row.appDependsOnHandler);
+  const handlerDependsOnModel = flag(row.handlerDependsOnModel);
+  const importSource = typeof row.importSource === "string" && row.importSource.length > 0;
+  if (modelIsApplicationRepo) {
+    score += 100;
+    acceptedReasons.push("model package equals registration package");
+  }
+  if (modelIsHandlerRepo) {
+    score += 100;
+    acceptedReasons.push("model package equals handler package");
+  }
+  if (localServicePathMatch) {
+    score += 80;
+    acceptedReasons.push("registration package contains exact local service path");
+  } else if (applicationHasLocalServices && !appDependsOnModel && !modelIsApplicationRepo) {
+    rejectedReasons.push(`registration package has local services but none match ${String(operation.servicePath ?? "")}`);
+  }
+  if (appDependsOnModel) {
+    score += 70;
+    acceptedReasons.push("registration package depends on model package");
+  }
+  if (appDependsOnHandler) {
+    score += 30;
+    acceptedReasons.push("registration package depends on handler package");
+  }
+  if (handlerDependsOnModel) {
+    score += 20;
+    acceptedReasons.push("handler package depends on model package");
+  }
+  if (importSource) {
+    score += 10;
+    acceptedReasons.push("registration imports handler class");
+  }
+  const hasOwnership = modelIsApplicationRepo || modelIsHandlerRepo;
+  const hasCrossPackage = appDependsOnModel && (modelIsHandlerRepo || appDependsOnHandler || !importSource);
+  const contradicted = applicationHasLocalServices && !localServicePathMatch && !appDependsOnModel && !hasOwnership;
+  if (!hasOwnership && !localServicePathMatch && !hasCrossPackage) rejectedReasons.push("missing direct ownership, exact local service path, or validated cross-package dependency evidence");
+  const accepted = !contradicted && (hasOwnership || localServicePathMatch || hasCrossPackage || handlerDependsOnModel);
+  if (!accepted && rejectedReasons.length === 0) rejectedReasons.push("candidate did not meet implementation ownership policy");
+  return { ...row, methodId: Number(row.methodId), score, accepted, acceptedReasons, rejectedReasons };
+}
+function candidateEvidence(candidate, rank) {
+  return {
+    rank,
+    score: candidate.score,
+    accepted: candidate.accepted,
+    acceptedReasons: candidate.acceptedReasons,
+    rejectedReasons: candidate.rejectedReasons,
+    methodId: candidate.methodId,
+    classId: candidate.classId,
+    className: candidate.className,
+    sourceFile: candidate.sourceFile,
+    sourceLine: candidate.sourceLine,
+    registration: { file: candidate.registrationFile, line: candidate.registrationLine, kind: candidate.registrationKind, importSource: candidate.importSource },
+    applicationPackage: { id: candidate.applicationRepoId, name: candidate.applicationRepo, packageName: candidate.applicationPackage },
+    handlerPackage: { id: candidate.handlerRepoId, name: candidate.handlerRepo, packageName: candidate.handlerPackage },
+    modelPackage: { id: candidate.modelRepoId, name: candidate.modelRepo, packageName: candidate.modelPackage },
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    operationName: candidate.operationName,
+    signals: {
+      directOwnership: { modelIsApplicationRepo: flag(candidate.modelIsApplicationRepo), modelIsHandlerRepo: flag(candidate.modelIsHandlerRepo) },
+      localServicePathMatch: flag(candidate.localServicePathMatch),
+      applicationHasLocalServices: flag(candidate.applicationHasLocalServices),
+      appDependsOnModel: flag(candidate.appDependsOnModel),
+      appDependsOnHandler: flag(candidate.appDependsOnHandler),
+      handlerDependsOnModel: flag(candidate.handlerDependsOnModel),
+      sameRepoRegistration: flag(candidate.sameRepoRegistration)
+    }
+  };
+}
+function flag(value) {
+  return Boolean(Number(value ?? 0));
+}
+function graphId(value) {
+  return String(value);
 }
 function normalizedOperation(value) {
   return value.startsWith("/") ? value.slice(1) : value;
@@ -1394,4 +1678,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-YFT57U54.js.map
+//# sourceMappingURL=chunk-HQMAFSRR.js.map