@saptools/service-flow 0.1.48 → 0.1.50

package/dist/{chunk-EGY2A4AT.js → chunk-52OUS3MO.js}

@@ -315,6 +315,46 @@ import fs4 from "fs/promises";
 import path5 from "path";
 import ts2 from "typescript";
 
+// src/linker/operation-decorator-normalizer.ts
+function lowerFirst(value) {
+  return value ? `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}` : value;
+}
+function normalizedOperationName(value) {
+  return value.replace(/^\//, "");
+}
+function clean(value) {
+  return value.replace(/^[`'"]|[`'"]$/g, "");
+}
+function generatedOperationNameFromConstant(value) {
+  for (const prefix of ["Action", "Func"]) {
+    if (value.startsWith(prefix) && value.length > prefix.length && /^[A-Z]/.test(value.slice(prefix.length))) return lowerFirst(value.slice(prefix.length));
+  }
+  return void 0;
+}
+function resolved(value, raw) {
+  const literal2 = clean(value);
+  const generated = generatedOperationNameFromConstant(literal2);
+  return { status: "resolved", operationName: generated ?? normalizedOperationName(literal2), raw };
+}
+function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
+  if (value) return resolved(value, raw);
+  if (!raw || raw.trim().length === 0) return { status: "none", raw };
+  const expression = raw.trim();
+  const nameMatch = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(expression);
+  if (nameMatch?.[1]) return resolved(nameMatch[1], expression);
+  const stringMatch = /^String\(([A-Za-z_$][\w$]*)\)$/.exec(expression);
+  if (stringMatch?.[1]) {
+    const identifier = stringMatch[1];
+    const generated = generatedOperationNameFromConstant(identifier);
+    const normalizedCandidate2 = candidateOperation ? normalizedOperationName(candidateOperation) : void 0;
+    if (generated) return { status: "resolved", operationName: generated, 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" };
+  return { status: "unsupported", raw: expression, reason: "unsupported_decorator_expression" };
+}
+
 // src/parsers/ts-project.ts
 import ts from "typescript";
 function createSourceFile(filePath, text) {
@@ -340,16 +380,102 @@ function callName(d) {
 }
 function firstArg(d) {
   const e = d.expression;
-  return ts2.isCallExpression(e) && e.arguments[0] ? e.arguments[0].getText() : "";
+  return ts2.isCallExpression(e) ? e.arguments[0] : void 0;
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (ts2.isParenthesizedExpression(current) || ts2.isAsExpression(current) || ts2.isTypeAssertionExpression(current) || ts2.isSatisfiesExpression(current)) current = current.expression;
+  return current;
+}
+function stringValue(expression) {
+  if (!expression) return void 0;
+  const unwrapped = unwrapExpression(expression);
+  return ts2.isStringLiteralLike(unwrapped) ? unwrapped.text : void 0;
+}
+function propertyName(node) {
+  if (ts2.isIdentifier(node) || ts2.isStringLiteralLike(node)) return node.text;
+  return void 0;
+}
+function collectEnumMembers(statement, lookups) {
+  for (const member of statement.members) {
+    const name = propertyName(member.name);
+    const value = stringValue(member.initializer);
+    if (name && value !== void 0)
+      lookups.enumMembers.set(`${statement.name.text}.${name}`, value);
+  }
+}
+function collectObjectProperties(name, initializer, lookups) {
+  const object = unwrapExpression(initializer);
+  if (!ts2.isObjectLiteralExpression(object)) return;
+  for (const property of object.properties) {
+    if (!ts2.isPropertyAssignment(property)) continue;
+    const key = propertyName(property.name);
+    const value = stringValue(property.initializer);
+    if (key && value !== void 0)
+      lookups.objectProperties.set(`${name}.${key}`, value);
+  }
+}
+function collectStringLookups(source) {
+  const lookups = {
+    identifiers: /* @__PURE__ */ new Map(),
+    enumMembers: /* @__PURE__ */ new Map(),
+    objectProperties: /* @__PURE__ */ new Map()
+  };
+  for (const statement of source.statements) {
+    if (ts2.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
+    if (!ts2.isVariableStatement(statement) || !(statement.declarationList.flags & ts2.NodeFlags.Const)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts2.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      const value = stringValue(declaration.initializer);
+      if (value !== void 0) lookups.identifiers.set(declaration.name.text, value);
+      collectObjectProperties(declaration.name.text, declaration.initializer, lookups);
+    }
+  }
+  return lookups;
+}
+function unresolved(rawExpression, reason) {
+  return { rawExpression, resolutionKind: "unresolved", unresolvedReason: reason };
+}
+function generatedConstant(rawExpression) {
+  const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(rawExpression.trim());
+  return match?.[1] ? generatedOperationNameFromConstant(match[1]) : void 0;
+}
+function resolveDecoratorArgument(argument, lookups) {
+  if (!argument) return unresolved("", "decorator_argument_missing");
+  const rawExpression = argument.getText();
+  const expression = unwrapExpression(argument);
+  if (ts2.isStringLiteralLike(expression))
+    return { rawExpression, resolvedValue: expression.text, resolutionKind: "literal" };
+  if (ts2.isIdentifier(expression)) {
+    const value = lookups.identifiers.get(expression.text);
+    return value === void 0 ? unresolved(rawExpression, "identifier_not_resolved_to_local_const_string") : { rawExpression, resolvedValue: value, resolutionKind: "const_identifier" };
+  }
+  if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression)) {
+    const key = `${expression.expression.text}.${expression.name.text}`;
+    const enumValue = lookups.enumMembers.get(key);
+    if (enumValue !== void 0)
+      return { rawExpression, resolvedValue: enumValue, resolutionKind: "enum_member" };
+    const objectValue2 = lookups.objectProperties.get(key);
+    if (objectValue2 !== void 0)
+      return { rawExpression, resolvedValue: objectValue2, resolutionKind: "const_object_property" };
+  }
+  const generatedValue = generatedConstant(rawExpression);
+  if (generatedValue !== void 0)
+    return {
+      rawExpression,
+      resolvedValue: generatedValue,
+      resolutionKind: "generated_constant_name"
+    };
+  if (ts2.isPropertyAccessExpression(expression))
+    return unresolved(rawExpression, "property_access_not_resolved_to_local_string");
+  return unresolved(rawExpression, "unsupported_decorator_expression");
 }
 async function parseDecorators(repoPath, filePath) {
   const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
   const sf = createSourceFile(filePath, text);
-  const constants = /* @__PURE__ */ new Map();
+  const lookups = collectStringLookups(sf);
   const handlers = [];
   function visit(node) {
-    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isStringLiteralLike(node.initializer))
-      constants.set(node.name.text, node.initializer.text);
     if (ts2.isClassDeclaration(node)) {
       const className = node.name?.text ?? "AnonymousHandler";
       const hasHandler = decs(node).some((d) => callName(d) === "Handler");
@@ -357,13 +483,13 @@ async function parseDecorators(repoPath, filePath) {
         (m) => decs(m).filter(
           (d) => ["Func", "Action", "On", "Event"].includes(callName(d))
         ).map((d) => {
-          const raw = firstArg(d);
-          const value = raw.startsWith('"') || raw.startsWith("'") || raw.startsWith("`") ? stripQuotes(raw) : constants.get(raw) ?? (raw.endsWith(".name") ? raw.split(".").at(-2) : void 0);
+          const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
           return {
             methodName: m.name.getText(),
             decoratorKind: callName(d),
-            decoratorValue: value,
-            decoratorRawExpression: raw,
+            decoratorValue: decoratorResolution.resolvedValue,
+            decoratorRawExpression: decoratorResolution.rawExpression,
+            decoratorResolution,
             sourceFile: normalizePath(filePath),
             sourceLine: line(sf, m.getStart())
           };
@@ -588,7 +714,7 @@ import ts4 from "typescript";
 function lineOf3(sf, node) {
   return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
 }
-function stringValue(node) {
+function stringValue2(node) {
   if (!node) return void 0;
   if (ts4.isStringLiteralLike(node) || ts4.isNoSubstitutionTemplateLiteral(node)) return node.text;
   if (ts4.isTemplateExpression(node)) return node.getText().replace(/^`|`$/g, "");
@@ -609,7 +735,7 @@ function connectFactFromCall(call) {
   let alias;
   let aliasExpr;
   if (ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first)) alias = first.text;
-  else if (!ts4.isObjectLiteralExpression(first)) aliasExpr = stringValue(first);
+  else if (!ts4.isObjectLiteralExpression(first)) aliasExpr = stringValue2(first);
   if ((ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first)) && !objectArg) return { alias: first.text, isDynamic: false, placeholders: [] };
   if (!objectArg && aliasExpr) return { aliasExpr, isDynamic: true, placeholders: placeholders(aliasExpr) };
   const expressions = objectArg ? objectExpressions(objectArg) : {};
@@ -622,8 +748,8 @@ function objectExpressions(objectArg) {
     for (const prop of obj.properties) {
       if (!ts4.isPropertyAssignment(prop)) continue;
       const name = ts4.isIdentifier(prop.name) || ts4.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-      if (name === "destination") out.destinationExpr = stringValue(prop.initializer);
-      if (name === "path" || name === "servicePath") out.servicePathExpr = stringValue(prop.initializer);
+      if (name === "destination") out.destinationExpr = stringValue2(prop.initializer);
+      if (name === "path" || name === "servicePath") out.servicePathExpr = stringValue2(prop.initializer);
       if (ts4.isObjectLiteralExpression(prop.initializer)) visitObject(prop.initializer);
     }
   }
@@ -733,8 +859,8 @@ function collectReturnedObjectBindings(fn) {
       for (const prop of node.expression.properties) {
         if (ts5.isShorthandPropertyAssignment(prop)) returns.set(prop.name.text, prop.name.text);
         if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
-          const propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-          if (propertyName2) returns.set(propertyName2, prop.initializer.text);
+          const propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+          if (propertyName3) returns.set(propertyName3, prop.initializer.text);
         }
       }
     }
@@ -742,9 +868,9 @@ function collectReturnedObjectBindings(fn) {
   }
   visit(fn);
   const out = /* @__PURE__ */ new Map();
-  for (const [propertyName2, variableName] of returns) {
+  for (const [propertyName3, variableName] of returns) {
     const fact = bindings.get(variableName);
-    if (fact) out.set(propertyName2, fact);
+    if (fact) out.set(propertyName3, fact);
   }
   return out;
 }
@@ -1028,8 +1154,8 @@ async function parseServiceBindings(repoPath, filePath) {
     if (helpers.length === 0) return;
     for (const el of decl.name.elements) {
       if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName2 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
-      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName2);
+      const propertyName3 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
       const resolved2 = matches2[0];
       out.push({
@@ -1042,7 +1168,7 @@ async function parseServiceBindings(repoPath, filePath) {
         placeholders: resolved2.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, decl),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName2, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
       });
     }
   }
@@ -1052,17 +1178,17 @@ async function parseServiceBindings(repoPath, filePath) {
     const helpers = await helpersForCall(call);
     if (helpers.length === 0) return;
     for (const prop of pattern.properties) {
-      let propertyName2;
+      let propertyName3;
       let targetName;
       if (ts5.isShorthandPropertyAssignment(prop)) {
-        propertyName2 = prop.name.text;
+        propertyName3 = prop.name.text;
         targetName = prop.name.text;
       } else if (ts5.isPropertyAssignment(prop)) {
-        propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+        propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
         targetName = ts5.isIdentifier(prop.initializer) ? prop.initializer.text : void 0;
       }
-      if (!propertyName2 || !targetName) continue;
-      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName2);
+      if (!propertyName3 || !targetName) continue;
+      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
       const resolved2 = matches2[0];
       out.push({
@@ -1075,7 +1201,7 @@ async function parseServiceBindings(repoPath, filePath) {
         placeholders: resolved2.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, node),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName2, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
       });
     }
   }
@@ -1087,9 +1213,9 @@ async function parseServiceBindings(repoPath, filePath) {
     if (target.expression.kind !== ts5.SyntaxKind.ThisKeyword) return;
     for (const el of decl.name.elements) {
       if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName2 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const propertyName3 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const helper = classHelpers.find(
-        (h) => h.helperName === target.name.text && h.propertyName === propertyName2
+        (h) => h.helperName === target.name.text && h.propertyName === propertyName3
       );
       if (!helper) continue;
       out.push({
@@ -1242,13 +1368,13 @@ function collectClassHelpers(sf) {
                 });
             }
             if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
-              const propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-              const fact = propertyName2 ? bindings.get(prop.initializer.text) : void 0;
-              if (propertyName2 && fact)
+              const propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+              const fact = propertyName3 ? bindings.get(prop.initializer.text) : void 0;
+              if (propertyName3 && fact)
                 helpers.push({
                   className,
                   helperName,
-                  propertyName: propertyName2,
+                  propertyName: propertyName3,
                   variableName: prop.initializer.text,
                   fact,
                   sourceLine: lineOf3(sf, prop)
@@ -1276,7 +1402,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 +1678,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 +1921,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 +1933,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 +1961,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 +1983,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 +1999,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 +2014,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 +2056,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) && propertyName2(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;
+function propertyName2(name) {
+  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 +2088,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 +2142,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 +2150,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 +2269,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 +2283,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 +2331,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 +2339,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 +2353,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 +2364,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 +2401,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 +2444,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 +2467,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 +2478,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 +2503,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 +2547,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         }
       }
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -2226,21 +2560,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 +2597,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") {
@@ -2710,46 +3044,6 @@ function linkHelperPackages(db, workspaceId, generation) {
   return summary;
 }
 
-// src/linker/operation-decorator-normalizer.ts
-function lowerFirst(value) {
-  return value ? `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}` : value;
-}
-function normalizedOperationName(value) {
-  return value.replace(/^\//, "");
-}
-function clean(value) {
-  return value.replace(/^[`'"]|[`'"]$/g, "");
-}
-function generatedFromConstantName(value) {
-  for (const prefix of ["Action", "Func"]) {
-    if (value.startsWith(prefix) && value.length > prefix.length && /^[A-Z]/.test(value.slice(prefix.length))) return lowerFirst(value.slice(prefix.length));
-  }
-  return void 0;
-}
-function resolved(value, raw) {
-  const literal2 = clean(value);
-  const generated = generatedFromConstantName(literal2);
-  return { status: "resolved", operationName: generated ?? normalizedOperationName(literal2), raw };
-}
-function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
-  if (value) return resolved(value, raw);
-  if (!raw || raw.trim().length === 0) return { status: "none", raw };
-  const expression = raw.trim();
-  const nameMatch = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(expression);
-  if (nameMatch?.[1]) return resolved(nameMatch[1], expression);
-  const stringMatch = /^String\(([A-Za-z_$][\w$]*)\)$/.exec(expression);
-  if (stringMatch?.[1]) {
-    const identifier = stringMatch[1];
-    const generated = generatedFromConstantName(identifier);
-    const normalizedCandidate = 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 };
-    return { status: "unsupported", raw: expression, reason: "string_wrapper_identifier_not_resolved" };
-  }
-  if (/^[`'"]/.test(expression) && !/[`'"]$/.test(expression)) return { status: "malformed", raw: expression, reason: "unterminated_literal" };
-  return { status: "unsupported", raw: expression, reason: "unsupported_decorator_expression" };
-}
-
 // src/linker/cross-repo-linker.ts
 function linkWorkspace(db, workspaceId, vars = {}) {
   return db.transaction(() => {
@@ -2807,7 +3101,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 +3176,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";
@@ -2875,7 +3226,7 @@ function objectJson(value) {
 }
 function callEvidence(call, resolution, servicePath, op, destination, normalized, odataPathIntent) {
   const bindingHasDynamicExpression = Boolean(Number(call.isDynamic ?? 0));
-  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue2(call.aliasExpr), stringValue2(call.alias)]);
+  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue3(call.aliasExpr), stringValue3(call.alias)]);
   return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArguments: normalized?.wasInvocation ? normalized.invocationArguments : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, routingPlaceholderKeys: routingPlaceholderKeys.length ? routingPlaceholderKeys : void 0, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === "local_service_call" ? "local" : void 0, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateScores: compactCandidateScores(resolution.candidates), candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || void 0, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : void 0, bindingHasDynamicExpression: bindingHasDynamicExpression || void 0, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
 }
 function compactCandidateScores(candidates) {
@@ -2892,7 +3243,7 @@ function placeholderKeys(values) {
 function objectValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function linkImplementations(db, workspaceId, generation) {
@@ -2911,7 +3262,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 +3276,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 };
@@ -2947,13 +3298,54 @@ function implementationContextForOperation(db, operation) {
 }
 function rankedImplementationCandidates(db, workspaceId, operation) {
   const rows2 = implementationCandidates(db, workspaceId, operation);
-  return deduplicateCandidates(rows2.map((row) => scoreImplementationCandidate(row, operation))).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+  const invalid = rows2.filter((row) => !validRegistrationPair(row));
+  recordRegistrationInvariantDiagnostics(db, invalid);
+  return deduplicateCandidates(
+    rows2.filter(validRegistrationPair).map((row) => scoreImplementationCandidate(row, operation))
+  ).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+}
+function validRegistrationPair(row) {
+  if (row.registrationHandlerClassId === null || row.registrationHandlerClassId === void 0)
+    return registrationPairingStrategy(row) !== "unproven";
+  return Number(row.registrationHandlerClassId) === Number(row.classId);
+}
+function registrationPairingStrategy(row) {
+  if (row.registrationHandlerClassId !== null && row.registrationHandlerClassId !== void 0)
+    return "exact_handler_class_id";
+  if (Number(row.applicationRepoId) === Number(row.handlerRepoId))
+    return "same_repository_class_name_fallback";
+  const source = stringValue3(row.importSource);
+  const separator = source?.lastIndexOf("#") ?? -1;
+  if (!source || separator <= 0) return "unproven";
+  const moduleName = source.slice(0, separator);
+  const importedName = source.slice(separator + 1);
+  const matchesClass = importedName === row.className || importedName === "default" && row.registrationClassName === row.className;
+  return moduleName === row.handlerPackage && matchesClass ? "explicit_package_import" : "unproven";
+}
+function recordRegistrationInvariantDiagnostics(db, rows2) {
+  const insert = db.prepare(`INSERT INTO diagnostics(repo_id,severity,code,message,source_file,source_line)
+    SELECT ?,'error','handler_registration_class_mismatch',
+      'Implementation candidate registration did not match its persisted handler class id',?,?
+    WHERE NOT EXISTS (
+      SELECT 1 FROM diagnostics
+      WHERE repo_id=? AND code='handler_registration_class_mismatch'
+        AND source_file=? AND source_line=?
+    )`);
+  for (const row of rows2)
+    insert.run(
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine,
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine
+    );
 }
 function deduplicateCandidates(rows2) {
   const merged = /* @__PURE__ */ new Map();
   for (const row of rows2) {
     const key = [row.methodId, row.classId, row.handlerRepoId].join(":");
-    const registration = { file: row.registrationFile, line: row.registrationLine, kind: row.registrationKind, importSource: row.importSource };
+    const registration = registrationEvidence(row);
     const existing = merged.get(key);
     if (!existing) {
       merged.set(key, { ...row, registrations: [registration] });
@@ -2967,6 +3359,17 @@ function deduplicateCandidates(rows2) {
   }
   return [...merged.values()];
 }
+function registrationEvidence(row) {
+  return {
+    id: row.registrationId,
+    handlerClassId: row.registrationHandlerClassId,
+    file: row.registrationFile,
+    line: row.registrationLine,
+    kind: row.registrationKind,
+    importSource: row.importSource,
+    pairingStrategy: registrationPairingStrategy(row)
+  };
+}
 function uniqueRegistrations(rows2) {
   const seen = /* @__PURE__ */ new Set();
   return rows2.filter((row) => {
@@ -2995,10 +3398,14 @@ function implementationCandidates(db, workspaceId, operation) {
       hm.method_name methodName,
       hm.decorator_value decoratorValue,
       hm.decorator_raw_expression decoratorRawExpression,
+      hm.decorator_resolution_json decoratorResolutionJson,
       hc.id classId,
       hc.class_name className,
       hc.source_file sourceFile,
       hc.source_line sourceLine,
+      hr.id registrationId,
+      hr.handler_class_id registrationHandlerClassId,
+      hr.class_name registrationClassName,
       hr.repo_id applicationRepoId,
       hr.registration_file registrationFile,
       hr.registration_line registrationLine,
@@ -3021,14 +3428,36 @@ function implementationCandidates(db, workspaceId, operation) {
       CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
-      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON (localClass.id=localReg.handler_class_id OR localClass.class_name=localReg.class_name) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
+      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
     FROM handler_methods hm
     JOIN handler_classes hc ON hc.id=hm.handler_class_id
     JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
-    JOIN handler_registrations hr ON (hr.handler_class_id=hc.id OR (hr.class_name=hc.class_name AND (hr.repo_id=hc.repo_id OR hr.import_source IS NOT NULL)))
+    JOIN handler_registrations hr ON (
+      (hr.handler_class_id IS NOT NULL AND hr.handler_class_id=hc.id)
+      OR (
+        hr.handler_class_id IS NULL
+        AND (
+          (hr.class_name=hc.class_name AND hr.repo_id=hc.repo_id)
+          OR (
+            instr(hr.import_source,'#')>1
+            AND substr(hr.import_source,1,instr(hr.import_source,'#')-1)
+              =handlerRepo.package_name
+            AND (
+              substr(hr.import_source,instr(hr.import_source,'#')+1)
+                =hc.class_name
+              OR (
+                substr(hr.import_source,instr(hr.import_source,'#')+1)
+                  ='default'
+                AND hr.class_name=hc.class_name
+              )
+            )
+          )
+        )
+      )
+    )
     JOIN repositories appRepo ON appRepo.id=hr.repo_id
     WHERE appRepo.workspace_id=?
       AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=? OR hm.decorator_raw_expression LIKE ?)`).all(
@@ -3130,8 +3559,16 @@ function candidateEvidence(candidate, rank) {
     className: candidate.className,
     sourceFile: candidate.sourceFile,
     sourceLine: candidate.sourceLine,
-    registration: { file: candidate.registrationFile, line: candidate.registrationLine, kind: candidate.registrationKind, importSource: candidate.importSource },
+    decoratorResolution: objectJson(candidate.decoratorResolutionJson),
+    registration: registrationEvidence(candidate),
     registrations: candidate.registrations ?? [],
+    registrationPairing: {
+      strategy: registrationPairingStrategy(candidate),
+      registrationId: candidate.registrationId,
+      registrationHandlerClassId: candidate.registrationHandlerClassId,
+      candidateHandlerClassId: candidate.classId,
+      invariantStatus: validRegistrationPair(candidate) ? "valid" : "invalid"
+    },
     applicationPackage: { id: candidate.applicationRepoId, name: candidate.applicationRepo, packageName: candidate.applicationPackage },
     handlerPackage: { id: candidate.handlerRepoId, name: candidate.handlerRepo, packageName: candidate.handlerPackage },
     modelPackage: { id: candidate.modelRepoId, name: candidate.modelRepo, packageName: candidate.modelPackage },
@@ -3171,6 +3608,40 @@ function normalizedOperation(value) {
   return value.startsWith("/") ? value.slice(1) : value;
 }
 
+// src/trace/selectors.ts
+function parseVars(values) {
+  const out = {};
+  for (const value of values ?? []) {
+    const [key, ...rest] = value.split("=");
+    if (key && rest.length > 0) out[key] = rest.join("=");
+  }
+  return out;
+}
+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,
+    selectorSuggestions: fullSelectorSuggestions(candidates)
+  };
+}
+function fullSelectorSuggestions(candidates) {
+  const includeRepo = new Set(candidates.map((row) => row.repoName)).size > 1;
+  return [...new Set(candidates.flatMap((row) => {
+    if (typeof row.servicePath !== "string" || typeof row.operationPath !== "string") return [];
+    const repoSelector = includeRepo && typeof row.repoName === "string" ? `--repo ${row.repoName} ` : "";
+    return [
+      `${repoSelector}--service ${row.servicePath} --path ${row.operationPath}`
+    ];
+  }))].sort();
+}
+
 // src/trace/evidence.ts
 function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
   const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
@@ -3189,11 +3660,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 +3678,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))
@@ -3223,20 +3698,20 @@ function runtimeVariableDiagnostic(edges) {
 }
 function edgeTarget(row, evidence) {
   const effective = parseObject(evidence.effectiveResolution);
-  const targetServicePath = stringValue3(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue3(effective.targetOperationPath ?? evidence.targetOperationPath);
+  const targetServicePath = stringValue4(effective.targetServicePath ?? evidence.targetServicePath);
+  const targetOperationPath = stringValue4(effective.targetOperationPath ?? evidence.targetOperationPath);
   if (targetServicePath && targetOperationPath) return `${targetServicePath}${targetOperationPath}`;
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath) return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
-  const servicePath = stringValue3(evidence.servicePath);
-  const operationPath = stringValue3(evidence.operationPath);
-  const targetOperation = stringValue3(evidence.targetOperation);
-  const targetRepo = stringValue3(evidence.targetRepo) ?? "";
+  const servicePath = stringValue4(evidence.servicePath);
+  const operationPath = stringValue4(evidence.operationPath);
+  const targetOperation = stringValue4(evidence.targetOperation);
+  const targetRepo = stringValue4(evidence.targetRepo) ?? "";
   if (row.edge_type === "HANDLER_RUNS_DB_QUERY") return `Entity: ${row.to_id || "unknown"}`;
-  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue3(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
+  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue4(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
   if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
     const target = parseObject(evidence.externalTarget);
-    return stringValue3(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
+    return stringValue4(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
   }
   if (servicePath && operationPath) return `${servicePath}${operationPath}`;
   return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
@@ -3275,12 +3750,12 @@ function withEffectiveResolution(evidence, row, unresolvedReason, resolution) {
   return { ...rest, effectiveResolution: current, linker: { status: current.status, confidence: current.confidence, reason: unresolvedReason, edgeType: current.edgeType } };
 }
 function resolveRuntimeOperation(db, evidence, workspaceId) {
-  const servicePath = stringValue3(evidence.servicePath);
-  const rawOperationPath = stringValue3(evidence.operationPath);
+  const servicePath = stringValue4(evidence.servicePath);
+  const rawOperationPath = stringValue4(evidence.operationPath);
   const normalized = normalizeODataOperationInvocationPath(rawOperationPath);
-  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue3(evidence.normalizedOperationPath) ?? rawOperationPath;
-  const alias = stringValue3(evidence.serviceAliasExpr ?? evidence.serviceAlias);
-  const destination = stringValue3(evidence.destination);
+  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue4(evidence.normalizedOperationPath) ?? rawOperationPath;
+  const alias = stringValue4(evidence.serviceAliasExpr ?? evidence.serviceAlias);
+  const destination = stringValue4(evidence.destination);
   return resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceId);
 }
 function evidenceWithRuntimeVariables(evidence, vars) {
@@ -3295,11 +3770,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 = stringValue4(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;
@@ -3317,7 +3798,7 @@ function runtimeUnresolvedReason(resolution) {
 function parseObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue3(value) {
+function stringValue4(value) {
   return typeof value === "string" ? value : void 0;
 }
 
@@ -3332,32 +3813,40 @@ 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 sourceFilesForStart(db, repoId, start) {
   const handler = start.handler;
   const operation = normalizeOperation(start.operation ?? start.operationPath);
@@ -3385,7 +3874,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 +3883,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 +3903,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 +4050,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 +4152,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 +4199,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 +4269,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}`;
@@ -3824,6 +4368,7 @@ export {
   parseImplementationHint,
   implementationHintSuggestions,
   linkWorkspace,
+  parseVars,
   trace
 };
-//# sourceMappingURL=chunk-EGY2A4AT.js.map
+//# sourceMappingURL=chunk-52OUS3MO.js.map