@saptools/service-flow 0.1.48 → 0.1.49

package/dist/{chunk-EGY2A4AT.js → chunk-XOROZHW4.js}

@@ -1276,7 +1276,7 @@ function collectClassHelpers(sf) {
 // src/parsers/outbound-call-parser.ts
 import fs7 from "fs/promises";
 import path10 from "path";
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // src/linker/external-http-target.ts
 import { createHash } from "crypto";
@@ -1552,7 +1552,242 @@ function topLevelQueryIndex(text) {
 
 // src/parsers/imported-wrapper-parser.ts
 import path9 from "path";
+import ts7 from "typescript";
+
+// src/parsers/operation-path-analysis.ts
 import ts6 from "typescript";
+var maxAliasDepth = 6;
+function analyzeOperationPath(expression, use, method = "POST") {
+  if (!expression) return emptyAnalysis();
+  const state = collectExpressionState(expression, use, 0, /* @__PURE__ */ new Set());
+  const paths = unique(state.paths.map(normalizeRawPath));
+  const normalized = unique(paths.flatMap((value) => normalizedCandidate(value, method)));
+  const status = pathStatus(paths, state.placeholders, state.dynamic);
+  const runtimeIdentifier = state.dynamic.at(-1)?.expression;
+  return {
+    status,
+    rawExpression: expression.getText(expression.getSourceFile()),
+    normalizedOperationPath: status === "static" && normalized.length === 1 ? normalized[0] : void 0,
+    candidateRawPaths: paths,
+    candidateNormalizedOperationPaths: normalized,
+    placeholderKeys: unique([...state.placeholders, ...runtimeIdentifier ? [runtimeIdentifier] : []]),
+    sourceKind: unique(state.sourceKinds).join("+") || "unknown",
+    candidateIdentifier: ts6.isIdentifier(expression) ? expression.text : void 0,
+    runtimeIdentifier,
+    dynamicReassignments: state.dynamic,
+    lexicalScope: lexicalEvidence(expression, use)
+  };
+}
+function operationPathExpression(analysis) {
+  if (analysis.status === "ambiguous" || analysis.status === "unknown") return void 0;
+  if (analysis.sourceKind.includes("parameter_binding")) return void 0;
+  if (analysis.candidateRawPaths.length === 1 && analysis.dynamicReassignments.length === 0)
+    return analysis.candidateRawPaths[0];
+  if (!analysis.runtimeIdentifier || analysis.sourceKind.includes("binding_not_found"))
+    return void 0;
+  return isRuntimeIdentifier(analysis.runtimeIdentifier) ? `\${${analysis.runtimeIdentifier}}` : void 0;
+}
+function pathUnresolvedReason(analysis) {
+  if (analysis.status === "ambiguous") return "ambiguous_operation_path_candidates";
+  if (analysis.status === "dynamic" && !operationPathExpression(analysis))
+    return "dynamic_operation_path_identifier";
+  if (analysis.dynamicReassignments.length > 0) return "dynamic_operation_path_identifier";
+  return void 0;
+}
+function collectExpressionState(expression, use, depth, seen) {
+  const unwrapped = unwrap(expression);
+  if (ts6.isStringLiteral(unwrapped)) return staticState(unwrapped.text, "string_literal");
+  if (ts6.isNoSubstitutionTemplateLiteral(unwrapped))
+    return staticState(unwrapped.text, "no_substitution_template");
+  if (ts6.isTemplateExpression(unwrapped)) return templateState(unwrapped);
+  if (ts6.isConditionalExpression(unwrapped))
+    return mergeStates([
+      collectExpressionState(unwrapped.whenTrue, use, depth + 1, seen),
+      collectExpressionState(unwrapped.whenFalse, use, depth + 1, seen)
+    ], "conditional_candidates");
+  if (ts6.isIdentifier(unwrapped))
+    return collectIdentifierState(unwrapped, use, depth, seen);
+  return dynamicState(unwrapped);
+}
+function collectIdentifierState(identifier, use, depth, seen) {
+  if (depth >= maxAliasDepth)
+    return dynamicState(identifier, "alias_depth_exceeded");
+  const binding = resolveBinding(identifier, use);
+  if (!binding || seen.has(binding.declaration))
+    return dynamicState(identifier, binding ? "alias_cycle" : "binding_not_found");
+  seen.add(binding.declaration);
+  if (ts6.isParameter(binding.declaration))
+    return dynamicState(identifier, "parameter_binding");
+  const expressions = reachingExpressions(binding.declaration, use);
+  if (expressions.length === 0) return dynamicState(identifier, "initializer_missing");
+  const states = expressions.map((item) => collectExpressionState(item.expression, item.node, depth + 1, seen));
+  const merged = mergeStates(states, binding.immutable ? "const_alias" : "mutable_alias");
+  if (merged.dynamic.length === 0) return merged;
+  return {
+    ...merged,
+    dynamic: merged.dynamic.map((item) => item.expression === identifier.text ? item : item)
+  };
+}
+function reachingExpressions(declaration, use) {
+  const rows2 = [];
+  if (declaration.initializer) rows2.push({ expression: declaration.initializer, node: declaration });
+  if ((declaration.parent.flags & ts6.NodeFlags.Const) !== 0) return rows2;
+  const source = use.getSourceFile();
+  const visit = (node) => {
+    if (node.getStart(source) >= use.getStart(source)) return;
+    if (node !== source && ts6.isFunctionLike(node) && !contains(node, use)) return;
+    if (isAssignmentTo(node, declaration, use))
+      rows2.push({ expression: node.right, node });
+    ts6.forEachChild(node, visit);
+  };
+  visit(source);
+  return rows2.sort((left, right) => left.node.getStart(source) - right.node.getStart(source));
+}
+function isAssignmentTo(node, declaration, use) {
+  if (!ts6.isBinaryExpression(node) || node.operatorToken.kind !== ts6.SyntaxKind.EqualsToken)
+    return false;
+  if (!ts6.isIdentifier(node.left) || !ts6.isIdentifier(declaration.name)) return false;
+  return resolveBinding(node.left, node)?.declaration === declaration && contains(declarationScope(declaration), use);
+}
+function resolveBinding(identifier, use) {
+  const source = use.getSourceFile();
+  const matches2 = [];
+  const visit = (node) => {
+    if (isNamedDeclaration(node, identifier.text) && isAccessible(node, use))
+      matches2.push(node);
+    ts6.forEachChild(node, visit);
+  };
+  visit(source);
+  const declaration = matches2.sort((left, right) => right.getStart(source) - left.getStart(source))[0];
+  if (!declaration) return void 0;
+  const immutable = ts6.isVariableDeclaration(declaration) && (declaration.parent.flags & ts6.NodeFlags.Const) !== 0;
+  return { declaration, immutable };
+}
+function isNamedDeclaration(node, name) {
+  return (ts6.isVariableDeclaration(node) || ts6.isParameter(node)) && ts6.isIdentifier(node.name) && node.name.text === name;
+}
+function isAccessible(declaration, use) {
+  const source = use.getSourceFile();
+  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
+  const scope = declarationScope(declaration);
+  return ts6.isSourceFile(scope) || contains(scope, use);
+}
+function declarationScope(declaration) {
+  if (ts6.isParameter(declaration)) return declaration.parent;
+  if (ts6.isCatchClause(declaration.parent)) return declaration.parent.block;
+  const list = declaration.parent;
+  if (isLoopInitializer(list.parent)) return list.parent.statement;
+  const blockScoped = (list.flags & (ts6.NodeFlags.Const | ts6.NodeFlags.Let)) !== 0;
+  let current = list.parent;
+  if (!blockScoped) {
+    while (current.parent && !ts6.isFunctionLike(current) && !ts6.isSourceFile(current))
+      current = current.parent;
+    return current;
+  }
+  while (current.parent && !isLexicalScope(current)) current = current.parent;
+  return current;
+}
+function isLoopInitializer(node) {
+  return ts6.isForStatement(node) || ts6.isForInStatement(node) || ts6.isForOfStatement(node);
+}
+function isLexicalScope(node) {
+  return ts6.isBlock(node) || ts6.isSourceFile(node) || ts6.isModuleBlock(node) || ts6.isCaseBlock(node) || ts6.isFunctionLike(node);
+}
+function templateState(expression) {
+  const value = expression.getText(expression.getSourceFile()).slice(1, -1);
+  return {
+    paths: [value],
+    placeholders: expression.templateSpans.map((span) => span.expression.getText(expression.getSourceFile())),
+    dynamic: [],
+    sourceKinds: ["template_with_placeholders"]
+  };
+}
+function staticState(path11, sourceKind) {
+  return { paths: [path11], placeholders: [], dynamic: [], sourceKinds: [sourceKind] };
+}
+function dynamicState(expression, sourceKind = "dynamic_expression") {
+  return {
+    paths: [],
+    placeholders: [],
+    dynamic: [{
+      expression: expression.getText(expression.getSourceFile()),
+      sourceLine: sourceLine(expression)
+    }],
+    sourceKinds: [sourceKind]
+  };
+}
+function mergeStates(states, sourceKind) {
+  return {
+    paths: states.flatMap((state) => state.paths),
+    placeholders: states.flatMap((state) => state.placeholders),
+    dynamic: states.flatMap((state) => state.dynamic),
+    sourceKinds: [sourceKind, ...states.flatMap((state) => state.sourceKinds)]
+  };
+}
+function pathStatus(paths, placeholders3, dynamic) {
+  if (dynamic.length > 0) return "dynamic";
+  if (paths.length > 1) return "ambiguous";
+  if (placeholders3.length > 0) return "dynamic";
+  if (paths.length === 1) return "static";
+  return "unknown";
+}
+function normalizedCandidate(value, method) {
+  const invocation = normalizeODataOperationInvocationPath(value);
+  if (invocation?.wasInvocation) return [invocation.normalizedOperationPath];
+  const intent = classifyODataPathIntent(value, method);
+  if (intent.kind.startsWith("entity_")) return [];
+  if (!value.startsWith("/") || value.slice(1).includes("/") || value.includes("?")) return [];
+  return [value];
+}
+function lexicalEvidence(expression, use) {
+  if (!ts6.isIdentifier(expression))
+    return { assignmentLines: [], sourceOrderSafe: expression.getStart() < use.getStart() };
+  const binding = resolveBinding(expression, use);
+  if (!binding) return { assignmentLines: [], sourceOrderSafe: false };
+  const assignmentLines = ts6.isVariableDeclaration(binding.declaration) ? reachingExpressions(binding.declaration, use).slice(binding.declaration.initializer ? 1 : 0).map((item) => sourceLine(item.node)) : [];
+  return {
+    declarationLine: sourceLine(binding.declaration),
+    assignmentLines,
+    sourceOrderSafe: true
+  };
+}
+function unwrap(expression) {
+  if (ts6.isAwaitExpression(expression) || ts6.isParenthesizedExpression(expression))
+    return unwrap(expression.expression);
+  if (ts6.isAsExpression(expression) || ts6.isSatisfiesExpression(expression) || ts6.isTypeAssertionExpression(expression))
+    return unwrap(expression.expression);
+  return expression;
+}
+function normalizeRawPath(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function isRuntimeIdentifier(value) {
+  return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(value);
+}
+function contains(parent, child) {
+  const source = child.getSourceFile();
+  return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
+}
+function sourceLine(node) {
+  const source = node.getSourceFile();
+  return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+}
+function unique(values) {
+  return [...new Set(values)].sort();
+}
+function emptyAnalysis() {
+  return {
+    status: "unknown",
+    candidateRawPaths: [],
+    candidateNormalizedOperationPaths: [],
+    placeholderKeys: [],
+    sourceKind: "missing",
+    dynamicReassignments: [],
+    lexicalScope: { assignmentLines: [], sourceOrderSafe: false }
+  };
+}
+
+// src/parsers/imported-wrapper-parser.ts
 async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBindings) {
   const imports = await importsFor(repoPath, filePath, source);
   const importedByLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
@@ -1560,7 +1795,7 @@ async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBind
   const out = [];
   const cache = /* @__PURE__ */ new Map();
   for (const call of calls) {
-    if (!ts6.isIdentifier(call.expression)) continue;
+    if (!ts7.isIdentifier(call.expression)) continue;
     const imported = importedByLocal.get(call.expression.text);
     if (!imported?.sourceFile) continue;
     const spec = await loadWrapperSpec(repoPath, imported, cache, 0);
@@ -1572,8 +1807,8 @@ async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBind
 function collectImportedCalls(source, imports) {
   const calls = [];
   const visit = (node) => {
-    if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && imports.has(node.expression.text)) calls.push(node);
-    ts6.forEachChild(node, visit);
+    if (ts7.isCallExpression(node) && ts7.isIdentifier(node.expression) && imports.has(node.expression.text)) calls.push(node);
+    ts7.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -1600,20 +1835,20 @@ function directSendSpec(source, sourceFile, name, fn) {
   const params = parameterNames(fn);
   const sends = [];
   visitFunctionBody(fn, (node) => {
-    if (ts6.isCallExpression(node) && ts6.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send") sends.push(node);
+    if (ts7.isCallExpression(node) && ts7.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send") sends.push(node);
   });
   if (sends.length !== 1) return void 0;
   const send = sends[0];
-  const receiver = send && ts6.isPropertyAccessExpression(send.expression) && ts6.isIdentifier(send.expression.expression) ? send.expression.expression.text : void 0;
+  const receiver = send && ts7.isPropertyAccessExpression(send.expression) && ts7.isIdentifier(send.expression.expression) ? send.expression.expression.text : void 0;
   const object = send?.arguments[0];
-  if (!receiver || !object || !ts6.isObjectLiteralExpression(object)) return void 0;
+  if (!receiver || !object || !ts7.isObjectLiteralExpression(object)) return void 0;
   const pathExpr = propertyExpression(object, "path");
   const methodExpr = propertyExpression(object, "method");
-  const pathName = pathExpr && ts6.isIdentifier(pathExpr) ? pathExpr.text : void 0;
+  const pathName = pathExpr && ts7.isIdentifier(pathExpr) ? pathExpr.text : void 0;
   const clientIndex = params.indexOf(receiver);
   const pathIndex = pathName ? params.indexOf(pathName) : -1;
   if (clientIndex < 0 || pathIndex < 0) return void 0;
-  const methodName = methodExpr && ts6.isIdentifier(methodExpr) ? methodExpr.text : void 0;
+  const methodName = methodExpr && ts7.isIdentifier(methodExpr) ? methodExpr.text : void 0;
   const methodIndex = methodName ? params.indexOf(methodName) : -1;
   return { clientIndex, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : void 0, methodLiteral: literal(methodExpr), sourceFile, sourceLine: lineOf3(source, fn), chain: [name] };
 }
@@ -1622,11 +1857,11 @@ async function nestedSendSpec(repoPath, sourceFile, source, name, fn, cache, dep
   const byLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
   const calls = [];
   visitFunctionBody(fn, (node) => {
-    if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && byLocal.has(node.expression.text)) calls.push(node);
+    if (ts7.isCallExpression(node) && ts7.isIdentifier(node.expression) && byLocal.has(node.expression.text)) calls.push(node);
   });
   if (calls.length !== 1) return void 0;
   const call = calls[0];
-  const imported = call && ts6.isIdentifier(call.expression) ? byLocal.get(call.expression.text) : void 0;
+  const imported = call && ts7.isIdentifier(call.expression) ? byLocal.get(call.expression.text) : void 0;
   const nested = imported ? await loadWrapperSpec(repoPath, imported, cache, depth + 1) : void 0;
   if (!call || !nested) return void 0;
   const params = parameterNames(fn);
@@ -1638,12 +1873,12 @@ async function nestedSendSpec(repoPath, sourceFile, source, name, fn, cache, dep
 }
 function wrapperCallFact(source, filePath, call, spec, serviceBindings) {
   const client = call.arguments[spec.clientIndex];
-  if (!client || !ts6.isIdentifier(client) || !serviceBindings.has(client.text)) return void 0;
-  const pathValue = resolveCallerPath(call.arguments[spec.pathIndex], call);
+  if (!client || !ts7.isIdentifier(client) || !serviceBindings.has(client.text)) return void 0;
   const methodValue = spec.methodIndex === void 0 ? spec.methodLiteral : literal(call.arguments[spec.methodIndex]);
   const method = (methodValue ?? "POST").toUpperCase();
-  const rawPath = pathValue.rawExpression;
-  const operationPathExpr = pathValue.value ? normalizeOperationPath(pathValue.value) : runtimePathExpression(rawPath);
+  const pathAnalysis = analyzeOperationPath(call.arguments[spec.pathIndex], call, method);
+  const operationPathExpr = operationPathExpression(pathAnalysis);
+  const unresolvedReason = pathUnresolvedReason(pathAnalysis);
   return {
     callType: "remote_action",
     serviceVariableName: client.text,
@@ -1653,59 +1888,41 @@ function wrapperCallFact(source, filePath, call, spec, serviceBindings) {
     sourceFile: normalizePath(filePath),
     sourceLine: lineOf3(source, call),
     confidence: operationPathExpr ? 0.85 : 0.5,
-    unresolvedReason: pathValue.value ? void 0 : "dynamic_operation_path_identifier",
+    unresolvedReason,
     evidence: {
       parser: "typescript_ast",
-      classifier: pathValue.value ? "imported_wrapper_literal_path" : "imported_wrapper_dynamic_path",
+      classifier: importedWrapperClassifier(pathAnalysis.status),
       receiver: client.text,
       wrapperFunction: spec.chain[0],
       wrapperChain: spec.chain,
       callerSite: { sourceFile: normalizePath(filePath), sourceLine: lineOf3(source, call) },
       calleeSite: { sourceFile: spec.sourceFile, sourceLine: spec.sourceLine },
-      rawPathExpression: rawPath,
-      missingPathIdentifier: pathValue.value ? void 0 : rawPath,
-      odataPathIntent: pathValue.value ? classifyODataPathIntent(operationPathExpr, method) : void 0
+      rawPathExpression: pathAnalysis.rawExpression,
+      missingPathIdentifier: pathAnalysis.runtimeIdentifier,
+      pathAnalysis,
+      odataPathIntent: operationPathExpr ? classifyODataPathIntent(operationPathExpr, method) : void 0
     }
   };
 }
-function resolveCallerPath(expr, use) {
-  if (!expr) return { sourceKind: "missing", rawExpression: "" };
-  if (ts6.isStringLiteralLike(expr) || ts6.isNoSubstitutionTemplateLiteral(expr)) return { value: expr.text, sourceKind: "literal", rawExpression: expr.getText() };
-  if (ts6.isTemplateExpression(expr)) return { value: expr.getText().slice(1, -1), sourceKind: "template", rawExpression: expr.getText() };
-  if (ts6.isIdentifier(expr)) {
-    const initializer = constInitializer(expr.text, use);
-    if (initializer) {
-      const resolved2 = resolveCallerPath(initializer, initializer);
-      return { ...resolved2, sourceKind: "const", rawExpression: expr.text };
-    }
-  }
-  return { sourceKind: "dynamic", rawExpression: expr.getText() };
-}
-function constInitializer(name, use) {
-  let found;
-  const source = use.getSourceFile();
-  const visit = (node) => {
-    if (node.getStart(source) >= use.getStart(source)) return;
-    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name) && node.name.text === name && node.initializer && (node.parent.flags & ts6.NodeFlags.Const) !== 0) found = node.initializer;
-    ts6.forEachChild(node, visit);
-  };
-  visit(source);
-  return found;
+function importedWrapperClassifier(status) {
+  if (status === "static") return "imported_wrapper_literal_path";
+  if (status === "ambiguous") return "imported_wrapper_ambiguous_path";
+  return "imported_wrapper_dynamic_path";
 }
 function findFunction(source, exportedName) {
   const localName = exportedLocalName(source, exportedName);
   for (const statement of source.statements) {
-    if (ts6.isFunctionDeclaration(statement) && statement.name?.text === localName) return { name: exportedName, fn: statement };
-    if (!ts6.isVariableStatement(statement)) continue;
+    if (ts7.isFunctionDeclaration(statement) && statement.name?.text === localName) return { name: exportedName, fn: statement };
+    if (!ts7.isVariableStatement(statement)) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (ts6.isIdentifier(declaration.name) && declaration.name.text === localName && declaration.initializer && (ts6.isArrowFunction(declaration.initializer) || ts6.isFunctionExpression(declaration.initializer))) return { name: exportedName, fn: declaration.initializer };
+      if (ts7.isIdentifier(declaration.name) && declaration.name.text === localName && declaration.initializer && (ts7.isArrowFunction(declaration.initializer) || ts7.isFunctionExpression(declaration.initializer))) return { name: exportedName, fn: declaration.initializer };
     }
   }
   return void 0;
 }
 function exportedLocalName(source, exportedName) {
   for (const statement of source.statements) {
-    if (!ts6.isExportDeclaration(statement) || !statement.exportClause || !ts6.isNamedExports(statement.exportClause)) continue;
+    if (!ts7.isExportDeclaration(statement) || !statement.exportClause || !ts7.isNamedExports(statement.exportClause)) continue;
     const match = statement.exportClause.elements.find((item) => item.name.text === exportedName);
     if (match) return match.propertyName?.text ?? match.name.text;
   }
@@ -1713,36 +1930,30 @@ function exportedLocalName(source, exportedName) {
 }
 function visitFunctionBody(fn, visitor) {
   const visit = (node) => {
-    if (node !== fn && ts6.isFunctionLike(node)) return;
+    if (node !== fn && ts7.isFunctionLike(node)) return;
     visitor(node);
-    ts6.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   };
   if (fn.body) visit(fn.body);
 }
 function parameterNames(fn) {
-  return fn.parameters.map((parameter) => ts6.isIdentifier(parameter.name) ? parameter.name.text : "");
+  return fn.parameters.map((parameter) => ts7.isIdentifier(parameter.name) ? parameter.name.text : "");
 }
 function mappedParameterIndex(expr, parameters) {
-  return expr && ts6.isIdentifier(expr) ? parameters.indexOf(expr.text) : -1;
+  return expr && ts7.isIdentifier(expr) ? parameters.indexOf(expr.text) : -1;
 }
 function propertyExpression(object, key) {
   for (const property of object.properties) {
-    if (ts6.isPropertyAssignment(property) && propertyName(property.name) === key) return property.initializer;
-    if (ts6.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
+    if (ts7.isPropertyAssignment(property) && propertyName(property.name) === key) return property.initializer;
+    if (ts7.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
   }
   return void 0;
 }
 function propertyName(name) {
-  return ts6.isIdentifier(name) || ts6.isStringLiteralLike(name) ? name.text : void 0;
+  return ts7.isIdentifier(name) || ts7.isStringLiteralLike(name) ? name.text : void 0;
 }
 function literal(expr) {
-  return expr && (ts6.isStringLiteralLike(expr) || ts6.isNoSubstitutionTemplateLiteral(expr)) ? expr.text : void 0;
-}
-function normalizeOperationPath(value) {
-  return value.startsWith("/") ? value : `/${value}`;
-}
-function runtimePathExpression(value) {
-  return value ? `\${${value}}` : void 0;
+  return expr && (ts7.isStringLiteralLike(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) ? expr.text : void 0;
 }
 
 // src/parsers/outbound-call-parser.ts
@@ -1751,47 +1962,47 @@ function lineOf4(text, idx) {
 }
 function entityFromExpression(expr) {
   if (!expr) return void 0;
-  if (ts7.isIdentifier(expr) || ts7.isStringLiteral(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
-  if (ts7.isPropertyAccessExpression(expr) && expr.expression.kind === ts7.SyntaxKind.ThisKeyword) return expr.name.text;
-  if (ts7.isElementAccessExpression(expr) && expr.argumentExpression && (ts7.isStringLiteral(expr.argumentExpression) || ts7.isNoSubstitutionTemplateLiteral(expr.argumentExpression))) return expr.argumentExpression.text;
+  if (ts8.isIdentifier(expr) || ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
+  if (ts8.isPropertyAccessExpression(expr) && expr.expression.kind === ts8.SyntaxKind.ThisKeyword) return expr.name.text;
+  if (ts8.isElementAccessExpression(expr) && expr.argumentExpression && (ts8.isStringLiteral(expr.argumentExpression) || ts8.isNoSubstitutionTemplateLiteral(expr.argumentExpression))) return expr.argumentExpression.text;
   return void 0;
 }
 function expressionName(expr) {
-  if (ts7.isIdentifier(expr)) return expr.text;
-  if (ts7.isPropertyAccessExpression(expr)) return `${expressionName(expr.expression)}.${expr.name.text}`;
+  if (ts8.isIdentifier(expr)) return expr.text;
+  if (ts8.isPropertyAccessExpression(expr)) return `${expressionName(expr.expression)}.${expr.name.text}`;
   return expr.getText();
 }
 function variableInitializers(source) {
   const initializers = /* @__PURE__ */ new Map();
   for (const statement of source.statements) {
-    if (!ts7.isVariableStatement(statement) || (statement.declarationList.flags & ts7.NodeFlags.Const) === 0) continue;
+    if (!ts8.isVariableStatement(statement) || (statement.declarationList.flags & ts8.NodeFlags.Const) === 0) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (ts7.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
+      if (ts8.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
     }
   }
   return initializers;
 }
 function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map()) {
-  if (ts7.isParenthesizedExpression(expr) || ts7.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts7.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text), initializers);
-  if (ts7.isCallExpression(expr)) {
+  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
+  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text), initializers);
+  if (ts8.isCallExpression(expr)) {
     const name = expressionName(expr.expression);
     if (name === "cds.run") return queryEntityFromAst(expr.arguments[0], initializers);
     if (["SELECT.one.from", "SELECT.from", "SELECT.one", "INSERT.into", "UPSERT.into", "DELETE.from", "UPDATE.entity"].includes(name)) return entityFromExpression(expr.arguments[0]);
     if (name === "UPDATE") return entityFromExpression(expr.arguments[0]);
-    const receiver = ts7.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : void 0;
+    const receiver = ts8.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : void 0;
     if (receiver) return queryEntityFromAst(receiver, initializers);
   }
   return void 0;
 }
 function extractQueryEntity(expr) {
-  const source = ts7.createSourceFile("query.ts", `const __query = (${expr});`, ts7.ScriptTarget.Latest, true, ts7.ScriptKind.TS);
+  const source = ts8.createSourceFile("query.ts", `const __query = (${expr});`, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
   const initializers = variableInitializers(source);
   let found;
   const visit = (node) => {
     if (found) return;
-    if (ts7.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
-    ts7.forEachChild(node, visit);
+    if (ts8.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   return found;
@@ -1805,7 +2016,7 @@ function parserEvidence(source, node, extra) {
   return { parser: "typescript_ast", startOffset: node.getStart(source), endOffset: node.getEnd(), ...extra };
 }
 function isStringLike(expr) {
-  return Boolean(expr && (ts7.isStringLiteral(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)));
+  return Boolean(expr && (ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr)));
 }
 function literalText(expr) {
   if (isStringLike(expr)) return expr.text;
@@ -1813,151 +2024,118 @@ function literalText(expr) {
 }
 function objectPropertyText(object, key) {
   const prop = object.properties.find(
-    (property) => ts7.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts7.isShorthandPropertyAssignment(property) && property.name.text === key
+    (property) => ts8.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts8.isShorthandPropertyAssignment(property) && property.name.text === key
   );
   if (!prop) return void 0;
-  return ts7.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
+  return ts8.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
 }
 function objectPropertyIsShorthand(object, key) {
-  return object.properties.some((property) => ts7.isShorthandPropertyAssignment(property) && property.name.text === key);
+  return object.properties.some((property) => ts8.isShorthandPropertyAssignment(property) && property.name.text === key);
 }
 function nameOfProperty(name) {
-  if (ts7.isIdentifier(name) || ts7.isStringLiteral(name) || ts7.isNumericLiteral(name)) return name.text;
+  if (ts8.isIdentifier(name) || ts8.isStringLiteral(name) || ts8.isNumericLiteral(name)) return name.text;
   return void 0;
 }
-var maxAliasDepth = 5;
+var maxAliasDepth2 = 5;
 function safeRaw(expr) {
-  if (ts7.isStringLiteral(expr) || ts7.isNoSubstitutionTemplateLiteral(expr) || ts7.isIdentifier(expr) || ts7.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
+  if (ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr) || ts8.isIdentifier(expr) || ts8.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
   return void 0;
 }
 function placeholders2(expr) {
   return expr.templateSpans.map((span) => span.expression.getText(expr.getSourceFile()));
 }
 function isFunctionLikeScope(node) {
-  return ts7.isFunctionLike(node) || ts7.isSourceFile(node);
+  return ts8.isFunctionLike(node) || ts8.isSourceFile(node);
 }
 function nodeContains(parent, child) {
   const source = child.getSourceFile();
   return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
 }
-function declarationScope(node) {
-  if (ts7.isParameter(node)) return node.parent;
-  if (ts7.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
+function declarationScope2(node) {
+  if (ts8.isParameter(node)) return node.parent;
+  if (ts8.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
   const list = node.parent;
-  const blockScoped = (list.flags & (ts7.NodeFlags.Const | ts7.NodeFlags.Let)) !== 0;
+  const blockScoped = (list.flags & (ts8.NodeFlags.Const | ts8.NodeFlags.Let)) !== 0;
   let current = list.parent;
   if (!blockScoped) {
     while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
     return current;
   }
-  while (current.parent && !ts7.isBlock(current) && !ts7.isSourceFile(current) && !ts7.isModuleBlock(current) && !ts7.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
+  while (current.parent && !ts8.isBlock(current) && !ts8.isSourceFile(current) && !ts8.isModuleBlock(current) && !ts8.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
   return current;
 }
 function isLoopInitializerScope(declaration, scope) {
   const list = declaration.parent;
-  return ts7.isForStatement(scope) && scope.initializer === list || (ts7.isForInStatement(scope) || ts7.isForOfStatement(scope)) && scope.initializer === list;
+  return ts8.isForStatement(scope) && scope.initializer === list || (ts8.isForInStatement(scope) || ts8.isForOfStatement(scope)) && scope.initializer === list;
 }
 function catchBindingScope(declaration) {
-  if (ts7.isParameter(declaration)) return void 0;
-  return ts7.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
+  if (ts8.isParameter(declaration)) return void 0;
+  return ts8.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
 }
 function isAccessibleDeclaration(declaration, use) {
   const source = use.getSourceFile();
   if (declaration.name.getStart(source) >= use.getStart(source)) return false;
   const catchScope = catchBindingScope(declaration);
   if (catchScope) return nodeContains(catchScope.block, use);
-  const scope = declarationScope(declaration);
-  if (ts7.isForStatement(scope) || ts7.isForInStatement(scope) || ts7.isForOfStatement(scope)) return nodeContains(scope.statement, use);
-  return ts7.isSourceFile(scope) || nodeContains(scope, use);
+  const scope = declarationScope2(declaration);
+  if (ts8.isForStatement(scope) || ts8.isForInStatement(scope) || ts8.isForOfStatement(scope)) return nodeContains(scope.statement, use);
+  return ts8.isSourceFile(scope) || nodeContains(scope, use);
 }
-function resolveBinding(identifier, use) {
+function resolveBinding2(identifier, use) {
   const source = use.getSourceFile();
   let best;
   const visit = (node) => {
-    if (ts7.isVariableDeclaration(node) && ts7.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
-    if (ts7.isParameter(node) && ts7.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
-    ts7.forEachChild(node, visit);
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    if (ts8.isParameter(node) && ts8.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   if (!best) return { immutable: false, evidence: ["binding_not_found"] };
-  const immutable = ts7.isVariableDeclaration(best) && (best.parent.flags & ts7.NodeFlags.Const) !== 0;
-  return { declaration: best, initializer: ts7.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "lexical_const_binding_before_use" : "lexical_mutable_or_parameter_binding"] };
+  const immutable = ts8.isVariableDeclaration(best) && (best.parent.flags & ts8.NodeFlags.Const) !== 0;
+  return { declaration: best, initializer: ts8.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "lexical_const_binding_before_use" : "lexical_mutable_or_parameter_binding"] };
 }
 function resolveExpression(expr, use, policy, depth = 0, seen = /* @__PURE__ */ new Set()) {
   if (!expr) return { status: "unknown", sourceKind: "dynamic_expression", placeholderKeys: [], evidence: ["expression_missing"] };
-  if (ts7.isStringLiteral(expr)) return { status: "static", sourceKind: "string_literal", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["string_literal"] };
-  if (ts7.isNoSubstitutionTemplateLiteral(expr)) return { status: "static", sourceKind: "no_substitution_template", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["no_substitution_template"] };
-  if (ts7.isTemplateExpression(expr)) {
+  if (ts8.isStringLiteral(expr)) return { status: "static", sourceKind: "string_literal", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["string_literal"] };
+  if (ts8.isNoSubstitutionTemplateLiteral(expr)) return { status: "static", sourceKind: "no_substitution_template", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["no_substitution_template"] };
+  if (ts8.isTemplateExpression(expr)) {
     const keys = placeholders2(expr);
     if (policy === "operation_path") return { status: "dynamic", sourceKind: "template_with_substitutions", value: stripQuotes(expr.getText(expr.getSourceFile())), rawExpression: safeRaw(expr), placeholderKeys: keys, evidence: ["operation_path_template_placeholders_retained"] };
     return { status: "dynamic", sourceKind: "template_with_substitutions", placeholderKeys: keys, evidence: ["template_substitutions_not_static_external_target"] };
   }
-  if (ts7.isIdentifier(expr)) {
-    if (depth >= maxAliasDepth) return { status: "unknown", sourceKind: "const_alias", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["alias_depth_exceeded"], constName: expr.text };
-    const binding = resolveBinding(expr, use);
+  if (ts8.isIdentifier(expr)) {
+    if (depth >= maxAliasDepth2) return { status: "unknown", sourceKind: "const_alias", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["alias_depth_exceeded"], constName: expr.text };
+    const binding = resolveBinding2(expr, use);
     if (!binding.declaration || !binding.initializer || !binding.immutable) return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: binding.evidence, constName: expr.text };
     if (seen.has(binding.declaration)) return { status: "unknown", sourceKind: "const_alias", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["alias_cycle_detected"], constName: expr.text };
     seen.add(binding.declaration);
     const resolved2 = resolveExpression(binding.initializer, binding.declaration, policy, depth + 1, seen);
     return { ...resolved2, sourceKind: "const_alias", rawExpression: safeRaw(expr), constName: expr.text, evidence: [...binding.evidence, ...resolved2.evidence] };
   }
-  return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts7.SyntaxKind[expr.kind] ?? "expression"}`] };
+  return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts8.SyntaxKind[expr.kind] ?? "expression"}`] };
 }
 function staticExpressionText(expr, initializers) {
   if (!expr) return void 0;
   if (isStringLike(expr)) return expr.text;
-  if (ts7.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
+  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
   return void 0;
 }
-function staticPathExpression(expr, use) {
-  const resolution = resolveExpression(expr, use, "operation_path");
-  const sourceKind = resolution.sourceKind === "const_alias" ? "const" : resolution.sourceKind === "template_with_substitutions" || resolution.sourceKind === "no_substitution_template" ? "template" : resolution.status === "static" ? "literal" : "dynamic";
-  return { text: resolution.value, sourceKind, rawExpression: resolution.rawExpression, constName: resolution.constName, resolution };
-}
 function operationPathFromStatic(text) {
   return text ? `/${stripQuotes(text).replace(/^\//, "")}` : void 0;
 }
-function staticPathCandidates(identifier, call, method) {
-  const binding = resolveBinding(identifier, call);
-  const declaration = binding.declaration;
-  if (!declaration) return void 0;
-  const source = call.getSourceFile();
-  const paths = [];
-  let hasDynamicAssignments = false;
-  const addExpr = (expr, origin) => {
-    const resolved2 = staticPathExpression(expr, origin);
-    if (resolved2.text) paths.push(operationPathFromStatic(resolved2.text) ?? resolved2.text);
-    else hasDynamicAssignments = true;
-  };
-  if (ts7.isVariableDeclaration(declaration)) addExpr(declaration.initializer, declaration);
-  const visit = (node) => {
-    if (node !== source && isFunctionLikeScope(node) && !nodeContains(node, call)) return;
-    if (node.getStart(source) >= call.getStart(source)) return;
-    if (ts7.isBinaryExpression(node) && node.operatorToken.kind === ts7.SyntaxKind.EqualsToken && ts7.isIdentifier(node.left)) {
-      const target = resolveBinding(node.left, node);
-      if (target.declaration === declaration) addExpr(node.right, node);
-    }
-    ts7.forEachChild(node, visit);
-  };
-  visit(source);
-  const candidatePaths = [...new Set(paths)];
-  if (candidatePaths.length === 0) return void 0;
-  const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, method).topLevelOperationName).filter((value) => Boolean(value)))];
-  return { candidatePaths, normalizedCandidateOperations, candidateSourceKind: "static candidates observed before call in lexical scope", candidateIdentifier: identifier.text, hasDynamicAssignments, conservativeReason: hasDynamicAssignments ? "dynamic_assignment_observed" : normalizedCandidateOperations.length > 1 ? "candidate_tie" : void 0 };
-}
 function destinationExpressionShape(expr) {
   if (!expr) return void 0;
-  if (ts7.isIdentifier(expr)) return "identifier";
-  if (ts7.isPropertyAccessExpression(expr) || ts7.isElementAccessExpression(expr)) return "property_read";
-  if (ts7.isCallExpression(expr)) return "function_call";
-  if (ts7.isConditionalExpression(expr)) return "conditional";
-  if (ts7.isBinaryExpression(expr)) return "binary_expression";
-  if (ts7.isTemplateExpression(expr)) return "template_expression";
-  return ts7.SyntaxKind[expr.kind] ?? "expression";
+  if (ts8.isIdentifier(expr)) return "identifier";
+  if (ts8.isPropertyAccessExpression(expr) || ts8.isElementAccessExpression(expr)) return "property_read";
+  if (ts8.isCallExpression(expr)) return "function_call";
+  if (ts8.isConditionalExpression(expr)) return "conditional";
+  if (ts8.isBinaryExpression(expr)) return "binary_expression";
+  if (ts8.isTemplateExpression(expr)) return "template_expression";
+  return ts8.SyntaxKind[expr.kind] ?? "expression";
 }
 function staticConditionalCandidates(expr, initializers) {
-  const resolved2 = expr && ts7.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
-  if (!resolved2 || !ts7.isConditionalExpression(resolved2)) return void 0;
+  const resolved2 = expr && ts8.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
+  if (!resolved2 || !ts8.isConditionalExpression(resolved2)) return void 0;
   const left = staticExpressionText(resolved2.whenTrue, initializers);
   const right = staticExpressionText(resolved2.whenFalse, initializers);
   if (!left || !right) return void 0;
@@ -1965,8 +2143,8 @@ function staticConditionalCandidates(expr, initializers) {
 }
 function propertyInitializer(object, key) {
   for (const property of object.properties) {
-    if (ts7.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
-    if (ts7.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
+    if (ts8.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
+    if (ts8.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
   }
   return void 0;
 }
@@ -1979,6 +2157,30 @@ function safeOperationName(value) {
   if (!value || !/^[A-Za-z_$][\w$]*(?:[./][A-Za-z_$][\w$]*)*$/.test(value)) return void 0;
   return operationPathFromStatic(value);
 }
+function wrapperSourceKind(sourceKind) {
+  if (sourceKind.includes("const_alias")) return "const";
+  if (sourceKind.includes("template")) return "template";
+  if (sourceKind.includes("string_literal")) return "literal";
+  return sourceKind.includes("conditional") ? "ambiguous" : "dynamic";
+}
+function literalPathSource(analysis) {
+  if (analysis.status !== "static") return void 0;
+  if (analysis.sourceKind.includes("const_alias")) return "same_scope_const_initializer";
+  if (analysis.sourceKind.includes("no_substitution_template")) return "template";
+  return analysis.sourceKind.includes("string_literal") ? "literal" : analysis.sourceKind;
+}
+function legacyPathCandidates(analysis) {
+  if (analysis.candidateRawPaths.length < 2 && analysis.dynamicReassignments.length === 0)
+    return void 0;
+  return {
+    candidatePaths: analysis.candidateRawPaths,
+    normalizedCandidateOperations: analysis.candidateNormalizedOperationPaths.map((value) => value.replace(/^\//, "")),
+    candidateSourceKind: analysis.sourceKind,
+    candidateIdentifier: analysis.candidateIdentifier,
+    hasDynamicAssignments: analysis.dynamicReassignments.length > 0,
+    conservativeReason: analysis.dynamicReassignments.length > 0 ? "dynamic_assignment_observed" : "candidate_tie"
+  };
+}
 function hasTemplatePlaceholder(value) {
   return /\$\{|%7B|%7D/i.test(value);
 }
@@ -2003,7 +2205,7 @@ function externalHttpEvidence(node, source) {
   const exprText = expr.getText(source);
   if (exprText === "useOrFetchDestination") {
     const objectArg = node.arguments[0];
-    if (objectArg && ts7.isObjectLiteralExpression(objectArg)) {
+    if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
       const destination = destinationTargetFromExpression(propertyInitializer(objectArg, "destinationName"), node);
       return { externalTarget: destination ?? { kind: "unknown", dynamic: false }, classifier: "sap_destination_lookup", sourceCallShape: "useOrFetchDestination" };
     }
@@ -2011,13 +2213,13 @@ function externalHttpEvidence(node, source) {
   if (exprText === "executeHttpRequest") {
     const destination = destinationTargetFromExpression(node.arguments[0], node);
     const config = node.arguments[1];
-    const method = config && ts7.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : void 0;
-    const url = config && ts7.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, "url"), node) : { kind: "unknown", dynamic: false };
+    const method = config && ts8.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : void 0;
+    const url = config && ts8.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, "url"), node) : { kind: "unknown", dynamic: false };
     return { method, externalTarget: destination ? { ...url, destination } : url, classifier: "sap_execute_http_request", sourceCallShape: "executeHttpRequest" };
   }
   if (exprText === "axios") {
     const config = node.arguments[0];
-    if (config && ts7.isObjectLiteralExpression(config)) {
+    if (config && ts8.isObjectLiteralExpression(config)) {
       const method = httpMethodFromObject(config, node);
       return { method, externalTarget: urlTargetFromExpression(propertyInitializer(config, "url"), node), classifier: "axios_config_call", sourceCallShape: "axios(config)" };
     }
@@ -2025,10 +2227,10 @@ function externalHttpEvidence(node, source) {
   }
   if (exprText === "fetch") {
     const init = node.arguments[1];
-    const method = init && ts7.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
+    const method = init && ts8.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
     return { method, externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: "fetch_call", sourceCallShape: "fetch" };
   }
-  if (ts7.isPropertyAccessExpression(expr) && ["get", "post", "put", "patch", "delete", "head"].includes(expr.name.text) && expr.expression.getText(source) === "axios") {
+  if (ts8.isPropertyAccessExpression(expr) && ["get", "post", "put", "patch", "delete", "head"].includes(expr.name.text) && expr.expression.getText(source) === "axios") {
     return { method: expr.name.text.toUpperCase(), externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: "axios_member_call", sourceCallShape: `axios.${expr.name.text}` };
   }
   return void 0;
@@ -2036,27 +2238,27 @@ function externalHttpEvidence(node, source) {
 function collectServiceVariables(source) {
   const vars = /* @__PURE__ */ new Set(["cds", "messaging", "messageClient", "eventClient"]);
   const visit = (node) => {
-    if (ts7.isVariableDeclaration(node) && ts7.isIdentifier(node.name) && node.initializer) {
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer) {
       const text = node.initializer.getText(source);
       if (/cds\.connect\.(to|messaging)\s*\(/.test(text)) vars.add(node.name.text);
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   return vars;
 }
 function receiverName(expr) {
-  if (ts7.isIdentifier(expr)) return expr.text;
-  if (ts7.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
+  if (ts8.isIdentifier(expr)) return expr.text;
+  if (ts8.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
   return void 0;
 }
 function sourceOf(node) {
   return node.getSourceFile();
 }
 function rootReceiverName(expr) {
-  if (ts7.isIdentifier(expr)) return expr.text;
-  if (ts7.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
-  if (ts7.isCallExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts8.isIdentifier(expr)) return expr.text;
+  if (ts8.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts8.isCallExpression(expr)) return rootReceiverName(expr.expression);
   return void 0;
 }
 function isSupportedEventReceiver(receiver, rootReceiver, serviceVariables) {
@@ -2073,38 +2275,38 @@ function collectWrapperSpecs(source) {
   const serviceVariables = collectServiceVariables(source);
   const calledNames = /* @__PURE__ */ new Set();
   const collectCalls = (node) => {
-    if (ts7.isCallExpression(node)) {
-      if (ts7.isIdentifier(node.expression)) calledNames.add(node.expression.text);
-      if (ts7.isCallExpression(node.expression) && ts7.isIdentifier(node.expression.expression)) calledNames.add(node.expression.expression.text);
-    }
-    ts7.forEachChild(node, collectCalls);
+    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression))
+      calledNames.add(node.expression.text);
+    if (ts8.isCallExpression(node) && ts8.isCallExpression(node.expression) && ts8.isIdentifier(node.expression.expression))
+      calledNames.add(node.expression.expression.text);
+    ts8.forEachChild(node, collectCalls);
   };
   collectCalls(source);
   const scanFunction = (name, fn) => {
-    if (!calledNames.has(name)) return;
-    const params = fn.parameters.map((param) => ts7.isIdentifier(param.name) ? param.name.text : void 0);
+    if (!calledNames.has(name) && !isExportedWrapper(fn)) return;
+    const params = fn.parameters.map((param) => ts8.isIdentifier(param.name) ? param.name.text : void 0);
     const sends = [];
     const visit = (node) => {
-      if (ts7.isCallExpression(node) && ts7.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts7.isIdentifier(node.expression.expression)) {
+      if (ts8.isCallExpression(node) && ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts8.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts7.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
           const pathProp = propertyInitializer(objectArg, "path");
           const methodProp = propertyInitializer(objectArg, "method");
-          const pathName = pathProp && ts7.isIdentifier(pathProp) ? pathProp.text : void 0;
-          const methodName = methodProp && ts7.isIdentifier(methodProp) ? methodProp.text : void 0;
+          const pathName = pathProp && ts8.isIdentifier(pathProp) ? pathProp.text : void 0;
+          const methodName = methodProp && ts8.isIdentifier(methodProp) ? methodProp.text : void 0;
           const methodLiteral = resolveExpression(methodProp, node, "literal").value;
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
-      if (ts7.isCallExpression(node) && ts7.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+      if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && specs.has(node.expression.text)) {
         const nested = specs.get(node.expression.text);
         const pathArg = nested ? node.arguments[nested.pathIndex] : void 0;
         const clientArg = nested?.clientIndex === void 0 ? void 0 : node.arguments[nested.clientIndex];
-        const pathName = pathArg && ts7.isIdentifier(pathArg) ? pathArg.text : void 0;
-        const clientName = clientArg && ts7.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        const pathName = pathArg && ts8.isIdentifier(pathArg) ? pathArg.text : void 0;
+        const clientName = clientArg && ts8.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() });
       }
-      ts7.forEachChild(node, visit);
+      ts8.forEachChild(node, visit);
     };
     visit(fn);
     if (sends.length !== 1) return;
@@ -2116,13 +2318,18 @@ function collectWrapperSpecs(source) {
     if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : void 0, clientName: clientIndex >= 0 ? void 0 : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : void 0, methodName: found.method, methodLiteral: found.methodLiteral, nestedWrapperFunction: found.nestedWrapperFunction, definitionLine: lineOf4(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node) => {
-    if (ts7.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
-    if (ts7.isVariableDeclaration(node) && ts7.isIdentifier(node.name) && node.initializer && (ts7.isArrowFunction(node.initializer) || ts7.isFunctionExpression(node.initializer))) scanFunction(node.name.text, node.initializer);
-    ts7.forEachChild(node, visitTop);
+    if (ts8.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer && (ts8.isArrowFunction(node.initializer) || ts8.isFunctionExpression(node.initializer))) scanFunction(node.name.text, node.initializer);
+    ts8.forEachChild(node, visitTop);
   };
   visitTop(source);
   return specs;
 }
+function isExportedWrapper(fn) {
+  const declaration = ts8.isFunctionDeclaration(fn) ? fn : ts8.isVariableDeclaration(fn.parent) ? fn.parent.parent.parent : void 0;
+  if (!declaration || !ts8.canHaveModifiers(declaration)) return false;
+  return ts8.getModifiers(declaration)?.some((modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword) ?? false;
+}
 function classifyOutboundCallsInSource(source, filePath) {
   const calls = [];
   const sourceFile = normalizePath(filePath);
@@ -2134,7 +2341,7 @@ function classifyOutboundCallsInSource(source, filePath) {
     calls.push({ node, fact: { ...fact, sourceFile, sourceLine: lineOf4(source.text, node.getStart(source)), confidence: fact.confidence ?? 0.8, evidence: parserEvidence(source, node, extra) } });
   };
   const visit = (node) => {
-    if (ts7.isCallExpression(node)) {
+    if (ts8.isCallExpression(node)) {
       if (wrapperInternalRanges.some((range) => node.getStart(source) >= range.start && node.getEnd() <= range.end)) {
         return;
       }
@@ -2145,24 +2352,23 @@ function classifyOutboundCallsInSource(source, filePath) {
         const entity = arg ? queryEntityFromAst(arg, initializers) : void 0;
         const payload = arg?.getText(source) ?? "";
         add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) });
-      } else if (ts7.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts7.isIdentifier(expr.expression) || ts7.isPropertyAccessExpression(expr.expression))) {
+      } else if (ts8.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts8.isIdentifier(expr.expression) || ts8.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts7.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
           const receiver = receiverName(expr.expression);
           const query = objectPropertyText(objectArg, "query");
           const method = stripQuotes(resolveExpression(propertyInitializer(objectArg, "method"), node, "literal").value ?? objectPropertyText(objectArg, "method") ?? "POST");
           const pathExpr = propertyInitializer(objectArg, "path") ?? propertyInitializer(objectArg, "event");
-          const resolvedPath = staticPathExpression(pathExpr, node);
-          const op = pathExpr ? resolvedPath.text ?? pathExpr.getText(source) : void 0;
+          const pathAnalysis = analyzeOperationPath(pathExpr, node, method);
+          const op = pathExpr ? operationPathExpression(pathAnalysis) ?? pathExpr.getText(source) : void 0;
           const shorthandPath = objectPropertyIsShorthand(objectArg, "path");
-          const candidateEvidence2 = pathExpr && ts7.isIdentifier(pathExpr) && !resolvedPath.text ? staticPathCandidates(pathExpr, node, method) : void 0;
-          const candidateOperationPath = candidateEvidence2 && !candidateEvidence2.hasDynamicAssignments && candidateEvidence2.normalizedCandidateOperations.length === 1 && candidateEvidence2.candidatePaths.length > 0 ? candidateEvidence2.candidatePaths[0] : void 0;
-          const operationPathExpr = operationPathFromStatic(resolvedPath.text) ?? candidateOperationPath;
+          const operationPathExpr = operationPathExpression(pathAnalysis);
           const intent = classifyODataPathIntent(operationPathExpr, method);
           const entityCallTypes = { entity_mutation: "remote_entity_mutation", entity_delete: "remote_entity_delete", entity_media: "remote_entity_media", entity_candidate: "remote_entity_candidate" };
           const entityCallType = entityCallTypes[intent.kind];
           const isODataQueryRead = method.toUpperCase() === "GET" && ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
-          add(node, { callType: query ? "remote_query" : entityCallType ?? (isODataQueryRead ? "remote_query" : "remote_action"), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : void 0, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason: !query && pathExpr && !operationPathExpr ? "dynamic_operation_path_identifier" : void 0 }, { receiver, classifier: "service_client_send_object", operationPathExpression: shorthandPath ? op : void 0, rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : resolvedPath.sourceKind : void 0, odataPathIntent: operationPathExpr ? intent : void 0, staticPathCandidates: candidateEvidence2, parserWarning: !query && pathExpr && !operationPathExpr ? "dynamic_operation_path_identifier" : void 0 });
+          const unresolvedReason = !query && pathExpr ? pathUnresolvedReason(pathAnalysis) : void 0;
+          add(node, { callType: query ? "remote_query" : entityCallType ?? (isODataQueryRead ? "remote_query" : "remote_action"), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : void 0, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason }, { receiver, classifier: "service_client_send_object", operationPathExpression: shorthandPath ? op : void 0, rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : void 0, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
         } else {
           const receiver = receiverName(expr.expression);
           const rootReceiver = rootReceiverName(expr.expression);
@@ -2171,33 +2377,35 @@ function classifyOutboundCallsInSource(source, filePath) {
           const pathArg = node.arguments[1];
           const supported = method && supportedHttpMethods.has(method);
           if (receiver && supported && serviceVariables.has(rootReceiver ?? receiver)) {
-            const resolvedPath = staticPathExpression(pathArg, node);
-            const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+            const pathAnalysis = analyzeOperationPath(pathArg, node, method);
+            const operationPathExpr = operationPathExpression(pathAnalysis);
             const intent = classifyODataPathIntent(operationPathExpr, method);
-            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" }, { receiver, rootReceiver, classifier: "service_client_send_method_path", rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : resolvedPath.sourceKind : void 0, odataPathIntent: operationPathExpr ? intent : void 0, parserWarning: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" });
+            const unresolvedReason = pathUnresolvedReason(pathAnalysis);
+            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason }, { receiver, rootReceiver, classifier: "service_client_send_method_path", rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : void 0, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
           } else if (receiver && serviceVariables.has(rootReceiver ?? receiver)) {
             const operationPathExpr = safeOperationName(firstArg2.value);
             add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.75 : 0.35, unresolvedReason: operationPathExpr ? void 0 : "unsupported_cap_send_signature" }, { receiver, rootReceiver, classifier: operationPathExpr ? "service_client_send_operation_event" : "service_client_send_unsupported_signature", rawOperationExpression: firstArg2.rawExpression, literalOperationSource: firstArg2.value ? firstArg2.sourceKind : void 0, parserWarning: operationPathExpr ? void 0 : "unsupported_cap_send_signature" });
           }
         }
-      } else if (ts7.isCallExpression(expr) && ts7.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts7.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
-        const wrapperName = ts7.isIdentifier(expr) ? expr.text : ts7.isCallExpression(expr) && ts7.isIdentifier(expr.expression) ? expr.expression.text : "";
-        const wrapperArgs = ts7.isIdentifier(expr) ? node.arguments : ts7.isCallExpression(expr) ? expr.arguments : node.arguments;
+      } else if (ts8.isCallExpression(expr) && ts8.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts8.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
+        const wrapperName = ts8.isIdentifier(expr) ? expr.text : ts8.isCallExpression(expr) && ts8.isIdentifier(expr.expression) ? expr.expression.text : "";
+        const wrapperArgs = ts8.isIdentifier(expr) ? node.arguments : ts8.isCallExpression(expr) ? expr.arguments : node.arguments;
         const spec = wrapperSpecs.get(wrapperName);
         const clientArg = spec?.clientIndex === void 0 ? void 0 : wrapperArgs[spec.clientIndex];
         const pathArg = spec ? wrapperArgs[spec.pathIndex] : void 0;
         const methodArg = spec?.methodIndex === void 0 ? void 0 : wrapperArgs[spec.methodIndex];
-        const receiver = clientArg && ts7.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
+        const receiver = clientArg && ts8.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
         const method = stripQuotes(resolveExpression(methodArg, node, "literal").value ?? spec?.methodLiteral ?? "POST");
-        const resolvedPath = staticPathExpression(pathArg, node);
-        const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+        const pathAnalysis = analyzeOperationPath(pathArg, node, method);
+        const operationPathExpr = operationPathExpression(pathAnalysis);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : void 0;
+        const unresolvedReason = pathUnresolvedReason(pathAnalysis);
         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, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf4(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, unresolvedReason }, { receiver, classifier: pathAnalysis.sourceKind.includes("string_literal") ? "higher_order_wrapper_literal_path" : "higher_order_wrapper_static_path", wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf4(source.text, node.getStart(source)), wrapperPathSourceKind: wrapperSourceKind(pathAnalysis.sourceKind), rawPathExpression: pathAnalysis.rawExpression, normalizedOperationPath, literalPathSource: pathAnalysis.sourceKind.includes("const_alias") ? "same_scope_const_initializer" : `wrapper_call_${wrapperSourceKind(pathAnalysis.sourceKind)}`, literalCallerArgumentDetected: true, pathAnalysis });
         } 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: lineOf4(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: "dynamic_operation_path_identifier" });
+          add(node, { callType: "remote_action", serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason }, { receiver, classifier: pathAnalysis.status === "ambiguous" ? "higher_order_wrapper_ambiguous_path" : "higher_order_wrapper_dynamic_path", wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf4(source.text, node.getStart(source)), wrapperPathSourceKind: wrapperSourceKind(pathAnalysis.sourceKind), rawPathExpression: pathAnalysis.rawExpression, pathAnalysis, parserWarning: unresolvedReason });
         }
-      } else if (ts7.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
+      } else if (ts8.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
         const receiver = receiverName(expr.expression);
         const rootReceiver = rootReceiverName(expr.expression);
         if (isSupportedEventReceiver(receiver, rootReceiver, serviceVariables)) {
@@ -2213,7 +2421,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         }
       }
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -2226,21 +2434,21 @@ function containsSupportedOutboundCall(node) {
 }
 async function parseOutboundCalls(repoPath, filePath) {
   const text = await fs7.readFile(path10.join(repoPath, filePath), "utf8");
-  const source = ts7.createSourceFile(filePath, text, ts7.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts7.ScriptKind.TS : ts7.ScriptKind.JS);
+  const source = ts8.createSourceFile(filePath, text, ts8.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS);
   const bindingNames = new Set((await parseServiceBindings(repoPath, filePath)).map((binding) => binding.variableName));
   const importedWrappers = await parseImportedWrapperCalls(repoPath, filePath, source, bindingNames);
   return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath)];
 }
 function parseLocalServiceCalls(text, filePath) {
-  const source = ts7.createSourceFile(filePath, text, ts7.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts7.ScriptKind.TS : ts7.ScriptKind.JS);
+  const source = ts8.createSourceFile(filePath, text, ts8.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS);
   const aliases = /* @__PURE__ */ new Map();
   const calls = [];
   const visit = (node) => {
-    if (ts7.isVariableDeclaration(node) && ts7.isIdentifier(node.name) && node.initializer) {
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer) {
       const origin = serviceLookup(node.initializer, aliases);
       if (origin) aliases.set(node.name.text, { ...origin, chain: [...origin.chain, node.name.text] });
     }
-    if (ts7.isCallExpression(node)) {
+    if (ts8.isCallExpression(node)) {
       const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== "entities") calls.push({
         callType: "local_service_call",
@@ -2263,20 +2471,20 @@ function parseLocalServiceCalls(text, filePath) {
         })
       });
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   return calls;
 }
 function serviceLookup(expr, aliases) {
-  if (ts7.isIdentifier(expr)) return aliases.get(expr.text);
-  if (ts7.isPropertyAccessExpression(expr) && expr.expression.getText() === "cds.services") return { service: expr.name.text, lookup: expr.getText(), chain: [expr.getText()] };
-  if (ts7.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts7.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
+  if (ts8.isIdentifier(expr)) return aliases.get(expr.text);
+  if (ts8.isPropertyAccessExpression(expr) && expr.expression.getText() === "cds.services") return { service: expr.name.text, lookup: expr.getText(), chain: [expr.getText()] };
+  if (ts8.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts8.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
   return void 0;
 }
 function serviceOperationCall(node, aliases) {
   const expr = node.expression;
-  if (!ts7.isPropertyAccessExpression(expr)) return void 0;
+  if (!ts8.isPropertyAccessExpression(expr)) return void 0;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return void 0;
   if (expr.name.text === "send") {
@@ -2741,9 +2949,9 @@ function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
   if (stringMatch?.[1]) {
     const identifier = stringMatch[1];
     const generated = generatedFromConstantName(identifier);
-    const normalizedCandidate = candidateOperation ? normalizedOperationName(candidateOperation) : void 0;
+    const normalizedCandidate2 = candidateOperation ? normalizedOperationName(candidateOperation) : void 0;
     if (generated) return { status: "resolved", operationName: generated, raw: expression };
-    if (normalizedCandidate && identifier === normalizedCandidate) return { status: "resolved", operationName: identifier, raw: expression };
+    if (normalizedCandidate2 && identifier === normalizedCandidate2) return { status: "resolved", operationName: identifier, raw: expression };
     return { status: "unsupported", raw: expression, reason: "string_wrapper_identifier_not_resolved" };
   }
   if (/^[`'"]/.test(expression) && !/[`'"]$/.test(expression)) return { status: "malformed", raw: expression, reason: "unterminated_literal" };
@@ -2807,7 +3015,36 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
   const operationLikeRemoteEntity = isRemoteEntityCall && Boolean(op) && credibleOperationSignal && (!strongEntitySignal || indexedOperationCandidateCount > 0);
   const isOperationCall = operationLikeRemoteEntity || (callType === "remote_action" || callType === "local_service_call" || callType === "remote_query" && Boolean(op));
   const resolution = isOperationCall ? resolveOperation(db, { servicePath, operationPath: op, serviceName: call.local_service_name, repoId: callType === "local_service_call" ? Number(call.repo_id) : void 0, alias: applyVariables(call.aliasExpr ?? call.alias, vars), destination: destination ? applyVariables(destination, vars) : void 0, isDynamic, hasExplicitOverride: Object.keys(vars).length > 0 || callType === "local_service_call" }, workspaceId) : { status: "unresolved", candidates: [], reasons: [] };
-  const evidence = { ...callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0, normalized, intent), indexedOperationCandidateCount, parserCallType: callType };
+  const evidence = {
+    ...callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0, normalized, intent),
+    indexedOperationCandidateCount,
+    parserCallType: callType,
+    entityOperationPrecedence: operationPrecedence(
+      callType,
+      intent,
+      indexedOperationCandidateCount,
+      Boolean(resolution.target)
+    )
+  };
+  const pathAnalysis = objectValue(objectJson(call.evidence_json)?.pathAnalysis);
+  if (callType === "remote_action" && pathAnalysis?.status === "ambiguous") {
+    const candidatePaths = Array.isArray(pathAnalysis.candidateRawPaths) ? pathAnalysis.candidateRawPaths : [];
+    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,
+      "UNRESOLVED_EDGE",
+      "ambiguous",
+      "call",
+      String(call.id),
+      "operation_candidates",
+      candidatePaths.join(","),
+      Number(call.confidence ?? 0.5),
+      JSON.stringify(evidence),
+      0,
+      "Ambiguous operation path candidates require explicit disambiguation",
+      generation
+    );
+    return { status: "ambiguous", callType };
+  }
   if (isRemoteEntityCall && (resolution.target || resolution.candidates.length > 0 || resolution.status === "dynamic")) {
     if (resolution.target) {
       db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "REMOTE_CALL_RESOLVES_TO_OPERATION", "resolved", "call", String(call.id), "operation", String(resolution.target.operationId), resolution.target.score, JSON.stringify({ ...evidence, operationEntityPrecedence: "indexed_operation_over_parser_entity" }), 0, generation);
@@ -2853,6 +3090,34 @@ function operationCandidateCount(db, workspaceId, operationPath, operationName)
   const row = db.prepare(`SELECT COUNT(*) count 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=? AND (o.operation_path=? OR o.operation_path=? OR o.operation_name=?)`).get(workspaceId, operationPath, normalizedName ? `/${normalizedName}` : operationPath, normalizedName);
   return Number(row?.count ?? 0);
 }
+function operationPrecedence(callType, intent, indexedOperationCandidateCount, resolvedOperation) {
+  if (resolvedOperation) {
+    return {
+      decision: "operation",
+      reason: "indexed_operation_with_strong_service_context",
+      indexedOperationCandidateCount
+    };
+  }
+  if (callType === "remote_action" && intent.kind === "operation_invocation") {
+    return {
+      decision: "operation_candidate",
+      rejectionReason: indexedOperationCandidateCount > 0 ? "indexed_candidates_lack_unique_strong_service_context" : "no_indexed_operation_candidate",
+      indexedOperationCandidateCount
+    };
+  }
+  if (intent.kind.startsWith("entity_")) {
+    return {
+      decision: "entity",
+      rejectionReason: indexedOperationCandidateCount > 0 ? "entity_shape_has_precedence_without_resolved_operation_context" : "entity_shape_has_no_indexed_operation_evidence",
+      indexedOperationCandidateCount
+    };
+  }
+  return {
+    decision: "unresolved",
+    rejectionReason: "path_has_no_safe_entity_or_operation_precedence",
+    indexedOperationCandidateCount
+  };
+}
 function unresolvedOperationReason(resolution) {
   if (resolution.status === "dynamic") return `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}`;
   if (resolution.candidates.length === 0) return "No indexed target operation matched";
@@ -2911,7 +3176,7 @@ function linkImplementations(db, workspaceId, generation) {
     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] : void 0;
+    const unique2 = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
     const ambiguityReasons = duplicatePackageAmbiguous ? ["duplicate_package_name_candidates"] : winners.length > 1 ? ["multiple_equal_score_implementation_candidates"] : [];
     const evidence = {
       servicePath: operation.servicePath,
@@ -2925,16 +3190,16 @@ function linkImplementations(db, workspaceId, generation) {
       candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
     };
-    const evidenceWithHints = unique ? evidence : { ...evidence, implementationHintSuggestions: implementationHintSuggestions(evidence) };
+    const evidenceWithHints = unique2 ? evidence : { ...evidence, implementationHintSuggestions: implementationHintSuggestions(evidence) };
     if (accepted.length === 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", "unresolved", "operation", graphId(operation.operationId), "handler_method_candidates", candidates.map((row) => graphId(row.methodId)).join(","), 0, JSON.stringify(evidenceWithHints), 0, "No implementation candidate passed policy", generation);
       edgeCount += 1;
       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) : selected.map((row) => graphId(row.methodId)).join(","), unique ? 0.95 : 0.5, JSON.stringify(evidenceWithHints), 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", unique2 ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique2 ? "handler_method" : "handler_method_candidates", unique2 ? graphId(unique2.methodId) : selected.map((row) => graphId(row.methodId)).join(","), unique2 ? 0.95 : 0.5, JSON.stringify(evidenceWithHints), 0, unique2 ? null : "Ambiguous registered handler implementation candidates", generation);
     edgeCount += 1;
-    if (unique) resolvedCount += 1;
+    if (unique2) resolvedCount += 1;
     else ambiguousCount += 1;
   }
   return { edgeCount, resolvedCount, ambiguousCount, unresolvedCount };
@@ -3189,11 +3454,12 @@ function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
     persistedResolution: persistedResolution(row)
   };
 }
-function runtimeResolution(db, row, evidence, vars, workspaceId) {
+function runtimeResolution(db, row, evidence, vars, workspaceId, contextualUnresolvedReason) {
   const substituted = evidenceWithRuntimeVariables(evidence, vars);
   if (!isRemoteRuntimeCandidate(row, evidence, vars)) {
-    const withSections = withEffectiveResolution(substituted, row, row.unresolved_reason);
-    return { row, evidence: withSections, unresolvedReason: row.unresolved_reason };
+    const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason;
+    const withSections = withEffectiveResolution(substituted, row, unresolvedReason2);
+    return { row, evidence: withSections, unresolvedReason: unresolvedReason2 };
   }
   const resolution = resolveRuntimeOperation(db, substituted, workspaceId);
   if (resolution.target) {
@@ -3206,6 +3472,9 @@ function runtimeResolution(db, row, evidence, vars, workspaceId) {
 function runtimeVariableDiagnostic(edges) {
   const missing = /* @__PURE__ */ new Set();
   for (const edge of edges) {
+    const effective = parseObject(edge.evidence.effectiveResolution);
+    if (!["dynamic", "unresolved", "ambiguous"].includes(String(effective.status ?? "")))
+      continue;
     const substitutions = edge.evidence.runtimeSubstitutions;
     if (!substitutions || typeof substitutions !== "object" || Array.isArray(substitutions)) continue;
     for (const value of Object.values(substitutions))
@@ -3295,11 +3564,17 @@ function evidenceWithRuntimeVariables(evidence, vars) {
 function runtimeSubstitutions(evidence, vars) {
   const substitutions = {};
   for (const key of ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"]) {
-    const substitution = substituteVariables(stringValue3(evidence[key]), vars);
+    const substitution = substituteVariables(substitutionValue(evidence, key), vars);
     if (substitution.placeholders.length > 0) substitutions[key] = substitution;
   }
   return substitutions;
 }
+function substitutionValue(evidence, key) {
+  const value = stringValue3(evidence[key]);
+  if (key !== "operationPath") return value;
+  const normalized = normalizeODataOperationInvocationPath(value);
+  return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
+}
 function isRemoteRuntimeCandidate(row, evidence, vars) {
   if (!vars || Object.keys(vars).length === 0) return false;
   if (!["dynamic", "ambiguous", "unresolved"].includes(String(row.status ?? ""))) return false;
@@ -3332,32 +3607,53 @@ function positiveDepth(value) {
 function operationStartScope(db, repoId, start, hintOptions) {
   const requested = normalizeOperation(start.operationPath ?? start.operation);
   if (!requested) return void 0;
-  const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,s.service_path servicePath,r.id repoId,r.name repoName
+  const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.service_path servicePath,r.id repoId,r.name repoName
     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
     WHERE (? IS NULL OR r.id=?) AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
     ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith("/") ? requested : `/${requested}`);
   if (rows2.length === 0) return void 0;
   const repoCount = new Set(rows2.map((row) => String(row.repoName))).size;
   const serviceCount = new Set(rows2.map((row) => `${String(row.repoName)}:${String(row.servicePath)}`)).size;
-  if (!repoId && repoCount > 1) return { diagnostics: [{ severity: "warning", code: "trace_start_ambiguous", message: "Operation trace start matched multiple repositories; add --repo to disambiguate", normalizedSelectorValue: requested, resolutionStage: "operation", resolutionStatus: "ambiguous_operation", candidates: rows2 }] };
-  if (!start.servicePath && serviceCount > 1) return { diagnostics: [{ severity: "warning", code: "trace_start_ambiguous", message: "Operation trace start matched multiple services; add --service to disambiguate", normalizedSelectorValue: requested, resolutionStage: "operation", resolutionStatus: "ambiguous_operation", candidates: rows2 }] };
-  if (rows2.length !== 1) return { diagnostics: [{ severity: "warning", code: "trace_start_ambiguous", message: "Operation trace start matched multiple indexed operations", normalizedSelectorValue: requested, resolutionStage: "operation", resolutionStatus: "ambiguous_operation", candidates: rows2 }] };
+  if (!repoId && repoCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple repositories; add --repo to disambiguate")] };
+  if (!start.servicePath && serviceCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple services; add --service to disambiguate")] };
+  if (rows2.length !== 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple indexed operations")] };
   const operationId = String(rows2[0]?.operationId);
   const impl = implementationScope(db, operationId);
-  if (impl.edge?.status === "resolved" && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? /* @__PURE__ */ new Set([impl.symbolId]) : void 0, operationId, diagnostics: [] };
+  if (impl.edge?.status === "resolved" && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? /* @__PURE__ */ new Set([impl.symbolId]) : void 0, repoId: impl.repoId, operationId, diagnostics: [] };
   const hinted = implementationMethodIdFromHint(impl.edge, hintOptions);
   if (hinted.methodId) {
     const hintedScope = handlerScope(db, hinted.methodId);
-    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? /* @__PURE__ */ new Set([hintedScope.symbolId]) : void 0, operationId, diagnostics: [] };
+    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? /* @__PURE__ */ new Set([hintedScope.symbolId]) : void 0, repoId: hintedScope.repoId, operationId, diagnostics: [] };
   }
   if (impl.edge) {
     const evidence = parseEvidence(impl.edge.evidence_json);
     const hintDiagnostic = implementationHintDiagnostic(hinted, evidence.implementationHintSuggestions);
-    const diagnostics = [{ severity: "warning", code: impl.edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved", message: `Indexed operation matched but implementation edge is ${String(impl.edge.status ?? "unresolved")}`, resolutionStage: "implementation", resolutionStatus: impl.edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation", implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, implementationAmbiguityReasons: evidence.ambiguityReasons, implementationHintSuggestions: evidence.implementationHintSuggestions, candidates: evidence.candidates }];
+    const diagnostics = [{ severity: "warning", code: impl.edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved", message: `Indexed operation matched but implementation edge is ${String(impl.edge.status ?? "unresolved")}`, resolutionStage: "implementation", resolutionStatus: impl.edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation", implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, implementationAmbiguityReasons: evidence.ambiguityReasons, implementationRejectionReasons: implementationRejectionReasons(evidence), implementationHintSuggestions: evidence.implementationHintSuggestions, candidates: evidence.candidates }];
     return { operationId, diagnostics: hintDiagnostic ? [hintDiagnostic, ...diagnostics] : diagnostics };
   }
   return { operationId, diagnostics: [{ severity: "warning", code: "trace_start_implementation_unresolved", message: "Indexed operation matched but no implementation candidate exists", resolutionStage: "implementation", resolutionStatus: "operation_without_implementation" }] };
 }
+function implementationRejectionReasons(evidence) {
+  const candidates = Array.isArray(evidence.candidates) ? evidence.candidates.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+  const reasons = candidates.flatMap((candidate) => Array.isArray(candidate.rejectedReasons) ? candidate.rejectedReasons.filter((reason) => typeof reason === "string") : []);
+  return [...new Set(reasons)].sort();
+}
+function ambiguousStartDiagnostic(requested, candidates, message) {
+  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+  return {
+    severity: "warning",
+    code: "trace_start_ambiguous",
+    message,
+    normalizedSelectorValue: requested,
+    resolutionStage: "operation",
+    resolutionStatus: "ambiguous_operation",
+    candidates,
+    serviceSuggestions
+  };
+}
 function sourceFilesForStart(db, repoId, start) {
   const handler = start.handler;
   const operation = normalizeOperation(start.operation ?? start.operationPath);
@@ -3385,7 +3681,7 @@ function sourceFilesForStart(db, repoId, start) {
     operation,
     operation
   );
-  if (rows2.length > 0) return { files: new Set(rows2.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(rows2.map((row) => Number(row.symbolId)).filter(Boolean)) };
+  if (rows2.length > 0) return { files: new Set(rows2.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(rows2.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
   if (start.servicePath && operation) {
     const implRows = db.prepare(`SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId
       FROM cds_services s JOIN cds_operations o ON o.service_id=s.id
@@ -3394,7 +3690,7 @@ function sourceFilesForStart(db, repoId, start) {
       JOIN handler_classes hc ON hc.id=hm.handler_class_id
       LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id AND sym.source_file=hc.source_file AND sym.name=hm.method_name
       WHERE (? IS NULL OR s.repo_id=?) AND s.service_path=? AND (o.operation_path=? OR o.operation_name=?)`).all(repoId, repoId, start.servicePath, operation, operation);
-    if (implRows.length > 0) return { files: new Set(implRows.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(implRows.map((row) => Number(row.symbolId)).filter(Boolean)) };
+    if (implRows.length > 0) return { files: new Set(implRows.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(implRows.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
   }
   return void 0;
 }
@@ -3414,6 +3710,7 @@ function startScope(db, start, hintOptions) {
     return { repo, selectorMatched: false };
   return {
     repo,
+    executionRepoId: sourceScope?.repoId ?? repo?.id,
     sourceFiles,
     symbolIds: sourceScope?.symbols,
     selectorMatched: !terminalOperationScope && (!hasSelector || sourceFiles !== void 0),
@@ -3560,20 +3857,59 @@ function knownBindingsForCalls(db, calls) {
 function knownBindingsForScope(db, repoId, symbolIds, files) {
   const map = /* @__PURE__ */ new Map();
   if (repoId === void 0) return map;
-  const rows2 = db.prepare(`SELECT b.id,b.variable_name variableName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
+  const rows2 = db.prepare(`SELECT b.id,b.symbol_id symbolId,b.variable_name variableName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
     FROM service_bindings b LEFT JOIN cds_requires req ON req.repo_id=b.repo_id AND req.alias=b.alias
     WHERE b.repo_id=?`).all(repoId);
   for (const row of rows2) {
     if (!row.variableName) continue;
     if (files && !files.has(String(row.sourceFile))) continue;
-    if (symbolIds && symbolIds.size > 0) {
-      const owner = db.prepare("SELECT id FROM symbols WHERE id IN (" + [...symbolIds].map(() => "?").join(",") + ") AND source_file=? AND start_line<=? AND end_line>=? LIMIT 1").get(...symbolIds, row.sourceFile, row.sourceLine, row.sourceLine);
-      if (!owner) continue;
+    if (symbolIds && symbolIds.size > 0 && row.symbolId != null && !symbolIds.has(Number(row.symbolId))) continue;
+    const candidate = enrichBinding({
+      ...row,
+      bindingId: Number(row.id),
+      source: "local_service_binding",
+      calleeReceiver: row.variableName,
+      resolutionStatus: "selected"
+    });
+    const existing = map.get(row.variableName);
+    if (!existing) {
+      map.set(row.variableName, candidate);
+      continue;
     }
-    map.set(row.variableName, enrichBinding({ ...row, bindingId: Number(row.id), source: "local_service_binding", calleeReceiver: row.variableName }));
+    const candidates = uniqueBindingCandidates([
+      ...existing.bindingCandidates ?? [bindingCandidateEvidence(existing)],
+      bindingCandidateEvidence(candidate)
+    ]);
+    map.set(row.variableName, {
+      ...candidate,
+      bindingId: void 0,
+      source: "ambiguous_local_service_bindings",
+      resolutionStatus: "ambiguous",
+      bindingCandidates: candidates
+    });
   }
   return map;
 }
+function bindingCandidateEvidence(binding) {
+  return {
+    bindingId: binding.bindingId,
+    sourceFile: binding.sourceFile,
+    sourceLine: binding.sourceLine,
+    alias: binding.alias,
+    aliasExpr: binding.aliasExpr,
+    destinationExpr: binding.destinationExpr,
+    servicePathExpr: binding.servicePathExpr
+  };
+}
+function uniqueBindingCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = JSON.stringify(candidate);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
 function contextForSymbolCall(db, symbolCall, callerBindings) {
   const next = /* @__PURE__ */ new Map();
   if (callerBindings.size === 0) return next;
@@ -3623,6 +3959,21 @@ function contextForSymbolCall(db, symbolCall, callerBindings) {
 }
 function contextualRuntimeResolution(db, call, binding, workspaceId, persistedRows = []) {
   if (!binding || String(call.call_type) !== "remote_action" || call.operation_path_expr === void 0 || call.operation_path_expr === null) return {};
+  if (binding.resolutionStatus === "ambiguous") {
+    return {
+      evidence: {
+        contextualServiceBindingAttempted: true,
+        contextualBinding: {
+          source: binding.source,
+          status: "tied",
+          candidates: binding.bindingCandidates
+        },
+        contextualResolutionStatus: "ambiguous",
+        contextualCandidateCount: binding.bindingCandidates?.length ?? 0
+      },
+      unresolvedReason: "Ambiguous contextual service binding candidates"
+    };
+  }
   const normalized = normalizeODataOperationInvocationPath(String(call.operation_path_expr));
   const op = normalized?.normalizedOperationPath ?? (String(call.operation_path_expr).startsWith("/") ? String(call.operation_path_expr) : `/${String(call.operation_path_expr)}`);
   const servicePath = binding.effectiveServicePath ?? binding.servicePathExpr ?? binding.requireServicePath;
@@ -3655,7 +4006,7 @@ function trace(db, start, options) {
   const edges = [];
   const nodes = /* @__PURE__ */ new Map();
   const seenEdges = /* @__PURE__ */ new Set();
-  const queue = scope.selectorMatched ? [{ repoId: scope.repo?.id, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: /* @__PURE__ */ new Map() }] : [];
+  const queue = scope.selectorMatched ? [{ repoId: scope.executionRepoId, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: /* @__PURE__ */ new Map() }] : [];
   if (scope.startOperationId && scope.selectorMatched) {
     const op = operationNode(db, scope.startOperationId);
     const impl = implementationScope(db, scope.startOperationId);
@@ -3725,7 +4076,7 @@ function trace(db, start, options) {
           String(row.evidence_json || "{}")
         );
         const rawEvidence = baseTraceEvidence(row, call, persistedEvidence, contextual.evidence);
-        const effective = runtimeResolution(db, row, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)));
+        const effective = runtimeResolution(db, row, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)), contextual.unresolvedReason);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
@@ -3826,4 +4177,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-EGY2A4AT.js.map
+//# sourceMappingURL=chunk-XOROZHW4.js.map