@saptools/service-flow 0.1.43 → 0.1.44

package/src/indexer/repository-indexer.ts

@@ -42,42 +42,68 @@ interface ParsedFacts {
   symbolCalls: SymbolCallFact[];
   fileRecords: Array<{ relativePath: string; extension: string; sha256: string; sizeBytes: number }>;
 }
+export interface PreparedRepositoryIndex extends IndexRepoResult {
+  repo: RepoRow;
+  packageFacts?: Awaited<ReturnType<typeof parsePackageJson>>;
+  fingerprint?: string;
+  kind?: string;
+  parsed?: ParsedFacts;
+}
 export async function indexRepository(
   db: Db,
   repo: RepoRow,
   force: boolean,
 ): Promise<IndexRepoResult> {
   try {
-    const sourceFiles = await findSourceFiles(repo.absolute_path);
-    const packageFacts = await parsePackageJson(repo.absolute_path);
-    const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
-    if (!force && repo.fingerprint === fingerprint) return { fileCount: 0, diagnosticCount: 0, skipped: true };
-    const kind = await classifyRepository(repo.absolute_path, packageFacts);
-    const parsed = await parseAllSourceFacts(repo.absolute_path, sourceFiles);
-    db.transaction(() => {
-      db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(packageFacts.packageName, packageFacts.packageVersion, JSON.stringify(packageFacts.dependencies), kind, 'indexing', repo.id);
-      clearRepoFacts(db, repo.id);
-      insertRequires(db, repo.id, packageFacts.cdsRequires);
-      const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
-      for (const file of parsed.fileRecords) fileStmt.run(repo.id, file.relativePath, file.extension, file.sha256, file.sizeBytes, new Date().toISOString());
-      for (const s of parsed.services) insertService(db, repo.id, s);
-      for (const h of parsed.handlers) insertHandler(db, repo.id, h);
-      insertExecutableSymbols(db, repo.id, parsed.symbols);
-      insertSymbolCalls(db, repo.id, parsed.symbolCalls);
-      insertRegistrations(db, repo.id, parsed.registrations);
-      insertBindings(db, repo.id, parsed.bindings);
-      insertCalls(db, repo.id, parsed.calls);
-      db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(new Date().toISOString(), fingerprint, new Date().toISOString(), ANALYZER_VERSION, repo.id);
-    });
-    return { fileCount: sourceFiles.length, diagnosticCount: 0, skipped: false };
+    const prepared = await prepareRepositoryIndex(repo, force);
+    if (!prepared.skipped) db.transaction(() => publishPreparedRepositoryIndex(db, prepared));
+    return { fileCount: prepared.fileCount, diagnosticCount: prepared.diagnosticCount, skipped: prepared.skipped };
   } catch (error) {
-    const message = errorMessage(error);
-    db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repo.id);
-    db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repo.id);
-    db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repo.id, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+    recordIndexFailure(db, repo.id, error);
     return { fileCount: 0, diagnosticCount: 1, skipped: false };
   }
 }
+export async function prepareRepositoryIndex(repo: RepoRow, force: boolean): Promise<PreparedRepositoryIndex> {
+  const sourceFiles = await findSourceFiles(repo.absolute_path);
+  const packageFacts = await parsePackageJson(repo.absolute_path);
+  const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
+  if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
+  return {
+    repo,
+    packageFacts,
+    fingerprint,
+    kind: await classifyRepository(repo.absolute_path, packageFacts),
+    parsed: await parseAllSourceFacts(repo.absolute_path, sourceFiles),
+    fileCount: sourceFiles.length,
+    diagnosticCount: 0,
+    skipped: false,
+  };
+}
+export function publishPreparedRepositoryIndex(db: Db, prepared: PreparedRepositoryIndex): void {
+  if (prepared.skipped) return;
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind) throw new Error('Prepared repository index is missing publication facts');
+  const now = new Date().toISOString();
+  const repoId = prepared.repo.id;
+  db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(prepared.packageFacts.packageName, prepared.packageFacts.packageVersion, JSON.stringify(prepared.packageFacts.dependencies), prepared.kind, 'indexing', repoId);
+  clearRepoFacts(db, repoId);
+  insertRequires(db, repoId, prepared.packageFacts.cdsRequires);
+  const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
+  for (const file of prepared.parsed.fileRecords) fileStmt.run(repoId, file.relativePath, file.extension, file.sha256, file.sizeBytes, now);
+  for (const service of prepared.parsed.services) insertService(db, repoId, service);
+  for (const handler of prepared.parsed.handlers) insertHandler(db, repoId, handler);
+  insertExecutableSymbols(db, repoId, prepared.parsed.symbols);
+  insertSymbolCalls(db, repoId, prepared.parsed.symbolCalls);
+  insertRegistrations(db, repoId, prepared.parsed.registrations);
+  insertBindings(db, repoId, prepared.parsed.bindings);
+  insertCalls(db, repoId, prepared.parsed.calls);
+  db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
+}
+export function recordIndexFailure(db: Db, repoId: number, error: unknown): void {
+  const message = errorMessage(error);
+  db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
+  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repoId, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+}
 async function parseAllSourceFacts(root: string, files: string[]): Promise<ParsedFacts> {
   const facts: ParsedFacts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
   for (const file of files) {

package/src/indexer/workspace-indexer.ts

@@ -1,12 +1,12 @@
 import type { Db } from '../db/connection.js';
 import { listRepositories, repoByName } from '../db/repositories.js';
 import { errorMessage } from '../utils/diagnostics.js';
-import { indexRepository } from './repository-indexer.js';
+import { prepareRepositoryIndex, publishPreparedRepositoryIndex, recordIndexFailure, type PreparedRepositoryIndex } from './repository-indexer.js';
 import { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
-  options: { repo?: string; force: boolean },
+  options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
 ): Promise<{ repoCount: number; indexedCount: number; skippedCount: number; fileCount: number; diagnosticCount: number }> {
   const started = new Date().toISOString();
   const repos = options.repo ? [repoByName(db, options.repo)].filter((r) => r !== undefined) : listRepositories(db);
@@ -14,17 +14,29 @@ export async function indexWorkspace(
   let fileCount = 0;
   let diagnosticCount = 0;
   let skippedCount = 0;
+  const preparedRows: PreparedRepositoryIndex[] = [];
+  let activeRepoId: number | undefined;
   try {
     for (const repo of repos) {
-      const result = await indexRepository(db, repo, options.force);
+      activeRepoId = repo.id;
+      const result = await prepareRepositoryIndex(repo, options.force);
+      preparedRows.push(result);
       fileCount += result.fileCount;
       diagnosticCount += result.diagnosticCount;
       skippedCount += result.skipped ? 1 : 0;
     }
-    materializeCdsExtensionOperations(db, workspaceId);
-    db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    db.transaction(() => {
+      for (const row of preparedRows) {
+        activeRepoId = row.repo.id;
+        publishPreparedRepositoryIndex(db, row);
+      }
+      if (options.injectDerivedMaterializationFailure) throw new Error('Injected derived materialization failure');
+      materializeCdsExtensionOperations(db, workspaceId);
+      db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    });
     return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
   } catch (error) {
+    if (activeRepoId && preparedRows.length < repos.length) recordIndexFailure(db, activeRepoId, error);
     db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run(new Date().toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
     throw error;
   }

package/src/linker/cross-repo-linker.ts

@@ -162,7 +162,11 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
     const winners = accepted.filter((candidate) => candidate.score === topScore);
-    const unique = winners.length === 1 ? winners[0] : undefined;
+    const duplicateFamilies = duplicatePackageFamilies(accepted);
+    const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
+    const selected = duplicatePackageAmbiguous ? accepted : winners;
+    const unique = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : undefined;
+    const ambiguityReasons = duplicatePackageAmbiguous ? ['duplicate_package_name_candidates'] : winners.length > 1 ? ['multiple_equal_score_implementation_candidates'] : [];
     const evidence = {
       servicePath: operation.servicePath,
       operationPath: operation.operationPath,
@@ -171,6 +175,8 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       implementationSource: implementationContext.operationId === operation.operationId ? 'direct_or_concrete_override' : 'inherited_from_base_operation',
       baseOperationId: operation.baseOperationId,
       implementationOperationId: implementationContext.operationId,
+      ambiguityReasons,
+      candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
     };
     if (accepted.length === 0) {
@@ -179,7 +185,7 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       unresolvedCount += 1;
       continue;
     }
-    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);
+    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) : selected.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;
@@ -232,6 +238,20 @@ function uniqueRegistrations(rows: Array<Record<string, unknown>>): Array<Record
     return true;
   });
 }
+function duplicatePackageFamilies(candidates: ImplementationCandidate[]): Array<Record<string, unknown>> {
+  const byPackage = new Map<string, ImplementationCandidate[]>();
+  for (const candidate of candidates) {
+    const packageName = typeof candidate.handlerPackage === 'string' ? candidate.handlerPackage : undefined;
+    if (!packageName) continue;
+    byPackage.set(packageName, [...(byPackage.get(packageName) ?? []), candidate]);
+  }
+  return [...byPackage.entries()]
+    .filter(([, rows]) => new Set(rows.map((row) => Number(row.handlerRepoId))).size > 1)
+    .map(([packageName, rows]) => ({ reason: 'duplicate_package_name_candidates', packageName, count: rows.length, repositories: rows.map((row) => row.handlerRepo).sort() }));
+}
+function hasDirectOwnershipEvidence(candidate: ImplementationCandidate): boolean {
+  return candidate.acceptedReasons.some((reason) => reason === 'model package equals registration package' || reason === 'model package equals handler package' || reason === 'registration package contains exact local service path');
+}
 function implementationCandidates(db: Db, workspaceId: number, operation: Record<string, unknown>): Array<Record<string, unknown>> {
   const modelRepoGraphId = graphId(operation.modelRepoId);
   return db.prepare(`SELECT DISTINCT

package/src/parsers/outbound-call-parser.ts

@@ -338,7 +338,7 @@ function isSupportedEventReceiver(receiver: string | undefined, rootReceiver: st
   if (/^(srv|service|serviceClient|messaging|messageClient|eventClient)$/.test(candidate)) return true;
   return false;
 }
-interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; definitionLine: number; internalStart: number; internalEnd: number }
+interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; nestedWrapperFunction?: string; definitionLine: number; internalStart: number; internalEnd: number }
 function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const specs = new Map<string, WrapperSpec>();
   const serviceVariables = collectServiceVariables(source);
@@ -354,7 +354,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const scanFunction = (name: string, fn: ts.FunctionLikeDeclaration): void => {
     if (!calledNames.has(name)) return;
     const params = fn.parameters.map((param) => ts.isIdentifier(param.name) ? param.name.text : undefined);
-    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; start: number; end: number }> = [];
+    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; nestedWrapperFunction?: string; start: number; end: number }> = [];
     const visit = (node: ts.Node): void => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'send' && ts.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
@@ -367,6 +367,14 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+        const nested = specs.get(node.expression.text);
+        const pathArg = nested ? node.arguments[nested.pathIndex] : undefined;
+        const clientArg = nested?.clientIndex === undefined ? undefined : node.arguments[nested.clientIndex];
+        const pathName = pathArg && ts.isIdentifier(pathArg) ? pathArg.text : undefined;
+        const clientName = clientArg && ts.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        if (nested && pathName && clientName) sends.push({ client: clientName, path: pathName, method: nested.methodName, methodLiteral: nested.methodLiteral, nestedWrapperFunction: node.expression.text, start: node.getStart(source), end: node.getEnd() });
+      }
       ts.forEachChild(node, visit);
     };
     visit(fn);
@@ -376,7 +384,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
     const pathIndex = params.indexOf(found.path);
     const methodIndex = found.method ? params.indexOf(found.method) : -1;
     const capturesKnownClient = serviceVariables.has(found.client) || /^(srv|service|serviceClient|client|.*Client)$/.test(found.client);
-    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
+    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, nestedWrapperFunction: found.nestedWrapperFunction, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node: ts.Node): void => {
     if (ts.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
@@ -456,7 +464,7 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const operationPathExpr = operationPathFromStatic(resolvedPath.text);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : undefined;
         if (spec && receiver && operationPathExpr) {
-          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
+          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
         } else if (spec && receiver) {
           add(node, { callType: 'remote_action', serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason: 'dynamic_operation_path_identifier' }, { receiver, classifier: 'higher_order_wrapper_dynamic_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: 'dynamic_operation_path_identifier' });
         }

package/src/parsers/service-binding-parser-helpers.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { normalizePath } from '../utils/path-utils.js';
+
+export interface HelperBinding {
+  exportedName: string;
+  returnedProperty?: string;
+  alias?: string;
+  aliasExpr?: string;
+  destinationExpr?: string;
+  servicePathExpr?: string;
+  isDynamic: boolean;
+  placeholders: string[];
+  helperChain?: Array<Record<string, unknown>>;
+  sourceFile: string;
+  sourceLine: number;
+}
+export interface ImportBinding {
+  localName: string;
+  exportedName: string;
+  sourceFile?: string;
+}
+export interface ClassHelperReturn {
+  className: string;
+  helperName: string;
+  propertyName: string;
+  variableName: string;
+  fact: Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'>;
+  sourceLine: number;
+}
+
+export function lineOf(sf: ts.SourceFile, node: ts.Node): number {
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+
+function stringValue(node: ts.Expression | undefined): string | undefined {
+  if (!node) return undefined;
+  if (ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isTemplateExpression(node)) return node.getText().replace(/^`|`$/g, '');
+  return node.getText();
+}
+
+function placeholders(value?: string): string[] {
+  return [...(value ?? '').matchAll(/\$\{([^}]*)\}/g)].map((m) => (m[1] ?? '').trim()).filter(Boolean);
+}
+
+export function connectFactFromCall(call: ts.CallExpression): Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined {
+  const expr = call.expression;
+  if (!ts.isPropertyAccessExpression(expr) || expr.name.text !== 'to') return undefined;
+  const inner = expr.expression;
+  if (!ts.isPropertyAccessExpression(inner) || inner.name.text !== 'connect' || inner.expression.getText() !== 'cds') return undefined;
+  const first = call.arguments[0];
+  if (!first) return undefined;
+  const second = call.arguments[1];
+  const objectArg = ts.isObjectLiteralExpression(first) ? first : second && ts.isObjectLiteralExpression(second) ? second : undefined;
+  let alias: string | undefined;
+  let aliasExpr: string | undefined;
+  if (ts.isStringLiteralLike(first) || ts.isNoSubstitutionTemplateLiteral(first)) alias = first.text;
+  else if (!ts.isObjectLiteralExpression(first)) aliasExpr = stringValue(first);
+  if ((ts.isStringLiteralLike(first) || ts.isNoSubstitutionTemplateLiteral(first)) && !objectArg) return { alias: first.text, isDynamic: false, placeholders: [] };
+  if (!objectArg && aliasExpr) return { aliasExpr, isDynamic: true, placeholders: placeholders(aliasExpr) };
+  const expressions = objectArg ? objectExpressions(objectArg) : {};
+  const ph = [...placeholders(aliasExpr ?? alias), ...placeholders(expressions.destinationExpr), ...placeholders(expressions.servicePathExpr)];
+  return { alias, aliasExpr, ...expressions, isDynamic: ph.length > 0 || (!expressions.destinationExpr && !expressions.servicePathExpr), placeholders: ph };
+}
+
+function objectExpressions(objectArg: ts.ObjectLiteralExpression): { destinationExpr?: string; servicePathExpr?: string } {
+  const out: { destinationExpr?: string; servicePathExpr?: string } = {};
+  function visitObject(obj: ts.ObjectLiteralExpression): void {
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+      const name = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : undefined;
+      if (name === 'destination') out.destinationExpr = stringValue(prop.initializer);
+      if (name === 'path' || name === 'servicePath') out.servicePathExpr = stringValue(prop.initializer);
+      if (ts.isObjectLiteralExpression(prop.initializer)) visitObject(prop.initializer);
+    }
+  }
+  visitObject(objectArg);
+  return out;
+}
+
+export function unwrapCall(expr: ts.Expression): ts.CallExpression | undefined {
+  if (ts.isAwaitExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isParenthesizedExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isTypeAssertionExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isCallExpression(expr)) return expr;
+  return undefined;
+}
+
+export function unwrapIdentityExpression(expr: ts.Expression): ts.Expression {
+  if (ts.isAwaitExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isParenthesizedExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isTypeAssertionExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  return expr;
+}
+
+export function transactionReceiverName(expr: ts.Expression): string | undefined {
+  const call = unwrapCall(expr);
+  if (call && ts.isPropertyAccessExpression(call.expression) && ['tx', 'transaction'].includes(call.expression.name.text) && ts.isIdentifier(call.expression.expression)) return call.expression.expression.text;
+  const unwrapped = unwrapIdentityExpression(expr);
+  if (!ts.isConditionalExpression(unwrapped)) return undefined;
+  const left = transactionReceiverName(unwrapped.whenTrue);
+  const right = transactionReceiverName(unwrapped.whenFalse);
+  return left && left === right ? left : undefined;
+}
+
+export function findConnectInExpression(expr: ts.Expression): Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined {
+  const direct = unwrapCall(expr);
+  if (direct) {
+    const fact = connectFactFromCall(direct);
+    if (fact) return fact;
+  }
+  let found: Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined;
+  function visit(node: ts.Node): void {
+    if (found) return;
+    if (ts.isCallExpression(node)) found = connectFactFromCall(node);
+    if (!found) ts.forEachChild(node, visit);
+  }
+  visit(expr);
+  return found;
+}
+
+export async function readSource(abs: string): Promise<ts.SourceFile | undefined> {
+  try {
+    const text = await fs.readFile(abs, 'utf8');
+    return ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveImport(repoPath: string, fromFile: string, spec: string): Promise<string | undefined> {
+  if (!spec.startsWith('.')) return undefined;
+  const rawBase = path.resolve(repoPath, path.dirname(fromFile), spec);
+  const parsed = path.parse(rawBase);
+  const base = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].includes(parsed.ext) ? path.join(parsed.dir, parsed.name) : rawBase;
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path.join(base, 'index.ts'), path.join(base, 'index.js')]) {
+    const stat = await fs.stat(candidate).catch(() => undefined);
+    if (stat?.isFile()) return normalizePath(path.relative(repoPath, candidate));
+  }
+  return undefined;
+}
+
+export async function importsFor(repoPath: string, filePath: string, sf: ts.SourceFile): Promise<ImportBinding[]> {
+  const imports: ImportBinding[] = [];
+  for (const stmt of sf.statements) {
+    if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteralLike(stmt.moduleSpecifier)) continue;
+    const sourceFile = await resolveImport(repoPath, filePath, stmt.moduleSpecifier.text);
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name) imports.push({ localName: clause.name.text, exportedName: 'default', sourceFile });
+    const bindings = clause.namedBindings;
+    if (bindings && ts.isNamedImports(bindings))
+      for (const el of bindings.elements) imports.push({ localName: el.name.text, exportedName: el.propertyName?.text ?? el.name.text, sourceFile });
+  }
+  return imports;
+}