@saptools/service-flow 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -1,14 +1,15 @@
 # Changelog
 
-## 0.1.7
-
-- Added atomic last-good repository publication so failed source reads preserve the previous complete snapshot and fingerprint.
-- Added explicit graph freshness metadata and stale diagnostics after successful fact changes until relink.
-- Persisted handler registration class/import evidence and linked registered cross-package implementation handlers through application dependency evidence.
-- Made service-only trace selectors return a typed narrowing diagnostic instead of workspace-wide traversal.
-- Expanded link summaries with dependency and implementation categories whose totals reconcile with persisted graph edges.
-- Preserved terminal parser warning evidence separately from routing status.
-
+## 0.1.8
+
+- Replaced regex-only handler registration extraction with TypeScript AST evidence for direct handler arrays, identifier arrays, spreads, imported arrays, default exports, aliases, and safe relative re-exports.
+- Persisted class-level `handler_registrations` rows with registration file/line and import evidence so registered handlers can be resolved across same-repository and cross-package layouts.
+- Relaxed implementation linking to support same-repository registrations, handler-package-owned registrations, and application registrations while preserving ambiguous candidate evidence.
+- Continued trace traversal from static and runtime-resolved operations into registered implementation handlers via `OPERATION_IMPLEMENTED_BY_HANDLER` edges.
+- Moved source discovery, reads, and fingerprinting into the protected repository indexing flow so failed reads preserve last-good facts/fingerprints and produce doctor-visible diagnostics.
+- Added a legacy-schema doctor warning when migrated stores lack fresh foreign-key metadata for key tables.
+- Suppressed the known `node:sqlite` experimental warning for normal supported-runtime database commands without suppressing application errors.
+- Changed `index_run_abandoned` doctor policy to report only running index runs older than the documented 60-minute threshold, including run id and start time.
 
 ## 0.1.6
 

package/README.md

@@ -47,19 +47,26 @@ npm install @saptools/service-flow
 ```
 
 > [!NOTE]
-> Requires **Node.js ≥ 24.0.0** for the bundled `node:sqlite` runtime. Version 0.1.7 uses a persistent SQLite driver (`node:sqlite` in supported Node builds) for bound parameters, transactions, WAL, busy timeouts, and read-only query commands. The analyzer is static: it reads files and package metadata, but it does not start CAP services, connect to SAP BTP, or execute application code.
+> Requires **Node.js ≥ 24.0.0** for the bundled `node:sqlite` runtime. Version 0.1.8 uses a persistent SQLite driver (`node:sqlite` in supported Node builds) for bound parameters, transactions, WAL, busy timeouts, and read-only query commands. The analyzer is static: it reads files and package metadata, but it does not start CAP services, connect to SAP BTP, or execute application code.
 
 ---
 
 
-### Correctness notes for 0.1.7
+### Correctness notes for 0.1.8
 
 - Runtime `--var` values are considered only for dynamic, ambiguous, or unresolved **remote** graph edges whose alias, destination, service path, or operation path expressions contain supplied placeholders. Local database, external HTTP, event, and already resolved static edges keep their persisted status, target, reason, and confidence. Partial substitutions remain dynamic and report the missing placeholder names.
 - `trace` and `graph` both accept repeatable `--var key=value` options. Effective substitutions are rendered in trace evidence without mutating the persisted graph. Confidence values are bounded to `[0, 1]`.
 - Repository selectors on list, trace, graph, and inspect commands narrow scope. Unknown selectors return empty machine-readable diagnostics instead of falling back to the whole workspace.
 - Helper-package dependency edges prefer exact indexed package names. Duplicate package-name candidates are persisted as ambiguous evidence rather than silently selecting one repository.
+- Handler registration parsing is AST-based for common `createCombinedHandler({ handler: ... })` forms: direct arrays, arrays assembled with spreads, non-`handlers` array names, aliased class imports, default-imported arrays, named exported arrays, and safe relative re-exports. Class-level rows keep registration file/line and import evidence.
+- Implementation edges require both operation compatibility and registration evidence. Same-repository registrations do not need a self-dependency edge; cross-package matches use registration or handler-package dependencies on the model package. Duplicate strong candidates are stored as ambiguous implementation edges.
+- Traces prefer persisted `OPERATION_IMPLEMENTED_BY_HANDLER` edges after static or runtime remote operation resolution, then fall back to same-repository decorator matching for simple projects.
 - Repository fingerprints include source content, package name/version, dependencies and devDependencies, scripts, normalized `cds.requires` (including nested credentials), package file content, and the analyzer version. Metadata-only changes therefore trigger reindexing.
 - Index publication is designed around the last-good snapshot: failed parse or persistence attempts are recorded as diagnostics and must not be mixed with older graph facts. After indexing changes, relink before relying on graph/trace output; doctor reports stale or inconsistent stores where detectable.
+- Source discovery, file reads, hashing, parsing, and publication are all inside the repository-level protected indexing flow. A failed read keeps the previous fingerprint and facts, marks the repository failed, and records a `source_read_failed` diagnostic; a later successful index clears superseded read-failure diagnostics during fact publication.
+- Normal successful database commands on supported Node 24 runtimes suppress the known `node:sqlite` experimental warning so JSON stdout remains parseable and stderr-clean. Real service-flow errors still use stderr and non-zero exit codes.
+- Doctor treats a `running` index run as abandoned only after 60 minutes and includes the run id/start time. Active short-lived concurrent runs are not default warnings.
+- Fresh databases include foreign keys for key graph, run, and diagnostic tables. Migrated legacy stores that still lack that metadata are reported by doctor with `legacy_schema_weaker_foreign_keys`; rebuild into a fresh database if strict structural parity is required.
 - Parser warnings describe analysis completeness, while routing status describes graph behavior. A terminal DB edge can remain terminal while still exposing parser warning evidence about an unknown entity.
 
 ## 🚀 Quick Start

package/TECHNICAL-NOTE.md

@@ -1,4 +1,4 @@
-# Service Flow 0.1.7 Resolution Notes
+# Service Flow 0.1.8 Resolution Notes
 
 - Imported helper bindings: TypeScript imports are resolved for relative modules. When a caller assigns `const client = await connectToService()`, the analyzer follows the imported symbol to an exported helper that returns `cds.connect.to(...)` and persists caller-variable evidence plus the helper source/export chain.
 - Candidate ranking: operation-path matches start as weak candidates. A resolved operation edge requires a strong signal such as exact service path, CDS alias/destination context, or explicit dynamic variable overrides. Otherwise candidates are preserved in edge evidence as ambiguous or unresolved.
@@ -21,7 +21,22 @@
 - Repository-level fingerprints include source paths/hashes, package dependencies, and analyzer schema version. Unchanged repositories are skipped unless `--force` is used.
 
 
-## 0.1.7 correctness additions
+## 0.1.8 implementation resolver model
+
+- Facts: indexing records CDS operations, decorated handler classes/methods, package dependencies, service bindings, outbound calls, and class-level handler registration facts. Registration facts include class name, import source where known, registration file, registration line, kind, and confidence.
+- Dependency evidence: helper-package linking creates repository dependency edges from package metadata. Implementation linking treats same-repository registration/handler evidence as strong without requiring a self-dependency edge, and treats registration-package or handler-package dependencies on the model package as strong cross-package evidence.
+- Registration evidence: the registration parser uses the TypeScript AST for `createCombinedHandler({ handler: ... })` and resolves direct arrays, identifier arrays, spreads, imported aggregate arrays, default exports, named exports, aliases, and safe relative re-exports. Decorator-only matches are not resolved as strong implementation edges.
+- Implementation edges: an operation-to-handler edge requires an exact operation path/name or method-name match plus registration evidence. One strong candidate becomes a resolved `OPERATION_IMPLEMENTED_BY_HANDLER` edge; multiple strong candidates become an ambiguous edge with candidate evidence.
+- Trace traversal: trace follows remote-call graph edges to operations, applies runtime `--var` substitutions only to eligible dynamic/ambiguous/unresolved remote edges, and then prefers persisted implementation edges to enqueue the registered handler scope. Depth limits and visited-scope keys continue to bound recursion and report cycles.
+
+## 0.1.8 operational notes
+
+- The known Node 24 `node:sqlite` experimental warning is filtered before loading the database driver for normal service-flow database commands. This filter targets only that runtime warning and does not convert application errors into success.
+- Repository indexing protects discovery, reads, hashing, parsing, and publication in one repository-level failure boundary. Failed attempts keep last-good facts and fingerprints and produce `source_read_failed` diagnostics visible in doctor.
+- Doctor reports `index_run_abandoned` only for running rows older than 60 minutes, including run id and start time.
+- Fresh schema version 3 stores define foreign keys for `graph_edges`, `index_runs`, and `diagnostics`. If a migrated legacy store is structurally weaker, doctor reports `legacy_schema_weaker_foreign_keys` rather than implying parity.
+
+## 0.1.8 correctness additions
 
 - Runtime resolution now has an explicit eligibility gate: only remote dynamic/ambiguous/unresolved graph edges with affected placeholders are re-resolved in memory. Terminal and resolved static edges are copied through unchanged, and substitutions keep original expressions, effective values, supplied variables, and missing variables separate.
 - Operation candidate scores are clamped into `[0, 1]` before graph or trace rendering.

package/dist/{chunk-YFT57U54.js → chunk-NBAO2R2H.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);
@@ -1110,7 +1241,30 @@ function linkImplementations(db, workspaceId, generation) {
   return { edgeCount, resolvedCount, ambiguousCount };
 }
 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 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;
@@ -1394,4 +1548,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-YFT57U54.js.map
+//# sourceMappingURL=chunk-NBAO2R2H.js.map