@saptools/service-flow 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.30
+
+- Normalize balanced OData operation invocations when multiline template placeholders appear inside function/action argument lists.
+- Preserve invocation argument placeholders as non-routing evidence instead of treating them as missing operation-target runtime variables.
+- Reuse the shared OData invocation normalizer during contextual trace resolution so persisted links and trace-time helper propagation handle the same path shapes.
+- Keep GET entity key reads, navigation reads, and collection queries terminal unless strong indexed operation evidence resolves them.
+
+## 0.1.29
+
+- Classify GET OData entity/query paths with query strings, filter functions, key predicates, navigation reads, and query placeholders as terminal remote query/entity edges when no strong indexed CDS operation candidate resolves them.
+- Preserve raw path, entity segment, query-string presence, query placeholders, method, and classifier reason in link evidence without creating dynamic operation edges from query parameters.
+- Keep balanced top-level OData action/function invocation normalization for real operation imports while avoiding truncation at parentheses inside query strings.
+- Document the conservative entity-query versus operation-invocation distinction for neutral CAP service-client calls.
+
 ## 0.1.28
 
 - Propagate contextual service-client bindings through one-level object-parameter destructuring aliases, including renamed and assignment destructuring in neutral CAP helpers.

package/README.md

@@ -419,7 +419,7 @@ Run `service-flow index` after source, CDS, package metadata, or helper-package
 <summary><b>Why is an expected call unresolved?</b></summary>
 
 Check `service-flow doctor`, then inspect the facts with `service-flow list services`, `service-flow list operations`, and `service-flow list calls`. Dynamic destinations may need `--var key=value`; the key is the full trimmed expression inside `${...}` and is matched literally without JavaScript evaluation. Operation-path-only ambiguous remote actions usually mean the call had no service binding id; same-file identity aliases are propagated, while property/call-expression aliases and ambiguous wrapper flows remain conservative; inspect `list calls`, `inspect operation`, and `doctor --strict` to determine whether helper-return propagation or wrapper support is missing. Contextual implementation selection only continues into a handler when static evidence such as caller repository, resolved service path, destination/alias expression, dependency edges, registration package, and local service ownership makes exactly one candidate stronger; ties remain ambiguous with reasons.
-Default doctor output is intended to focus on actionable indexing or trace-impacting issues; use `--strict` when you need exhaustive model-shape diagnostics for entity-only or extension-heavy CDS models. Strict mode also reports normalized OData invocation ambiguity, remote-action target quality, likely missed identity aliases, no-binding remote actions, contextual implementation stops, and wrapper dynamic-path candidates, including whether unresolved unknown/dynamic paths are semantic instead of numeric call ids.
+Default doctor output is intended to focus on actionable indexing or trace-impacting issues; use `--strict` when you need exhaustive model-shape diagnostics for entity-only or extension-heavy CDS models. Strict mode also reports normalized OData invocation ambiguity, remote-action target quality, likely missed identity aliases, no-binding remote actions, contextual implementation stops, and wrapper dynamic-path candidates, including whether unresolved unknown/dynamic paths are semantic instead of numeric call ids. GET OData entity/query reads such as `/Books?$filter=contains(title,'A')`, `/Books(ID='1000')`, and navigation queries are terminal remote query/entity edges unless strong indexed CDS operation evidence resolves them; placeholders inside query strings are preserved as query evidence rather than dynamic operation selectors.
 
 </details>
 

package/TECHNICAL-NOTE.md

@@ -1,5 +1,18 @@
 # Service Flow Resolution Notes
 
+## 0.1.30 OData invocation argument placeholder notes
+
+- Balanced top-level OData function/action imports such as `/readDetails(ID='${id}',version=0)` now normalize to the operation segment even when placeholder expressions span multiple lines or contain nested JavaScript parentheses.
+- Placeholders inside the invocation argument list are recorded as `invocationArgumentPlaceholderKeys` evidence. They are not route selectors and do not produce `missing_variable:*` operation-target diagnostics after a stable operation segment has been identified.
+- Runtime `--var` substitution still applies to actual route selectors: service path, destination, alias, and dynamic operation path segments. GET entity key reads, navigation reads, and query-string placeholders remain conservative terminal remote query/entity evidence unless strong indexed operation evidence resolves them.
+- Trace-time contextual service-client resolution uses the same shared OData invocation normalizer as persisted linking, keeping helper-propagated calls consistent with full graph linking.
+
+## 0.1.29 OData entity-query intent notes
+
+- Service-client `GET` paths with OData collection queries, filter/search functions in the query string, entity key predicates, navigation reads, or query-string placeholders are classified conservatively as terminal remote entity/query reads when no strong indexed CDS operation candidate resolves the path. Examples include `/Books?$filter=contains(title,'A')`, `/Books(ID='1000')`, and `/Authors('A1')/books?$select=ID`.
+- Query-string placeholders are recorded as query evidence and do not make the operation target dynamic. Runtime variables in service paths, destinations, aliases, and true operation paths still keep the existing dynamic-edge behavior.
+- OData invocation normalization no longer truncates paths at parentheses that appear inside query strings. Balanced top-level operation imports such as `/calculateScore(input='A')` continue to normalize and resolve against indexed CDS functions/actions when service evidence is strong.
+
 ## 0.1.22 alias, wrapper, contextual trace, and strict doctor notes
 
 - Same-file service-client identity aliases now create their own service binding rows when the right-hand side is a known connected client variable. The parser accepts direct identifier aliases plus typed, `as`, and `satisfies` forms, supports source-order transitive aliases, and records `aliasKind: identity` helper-chain evidence. It still does not infer aliases from property reads, indexed access, function calls, object metadata, or cross-scope guesses.

package/dist/{chunk-SWPGRM7Z.js → chunk-UHYHSYCS.js}

@@ -521,6 +521,201 @@ function summarizeExpression(text) {
   return redactText(text).slice(0, 240);
 }
 
+// src/linker/odata-path-normalizer.ts
+function normalizeODataOperationInvocationPath(path9) {
+  if (path9 === void 0) return void 0;
+  const raw = path9.trim();
+  if (!raw) return void 0;
+  const rejected = (reason) => ({ rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false, invocationArgumentPlaceholderKeys: [], normalizationRejectedReason: reason });
+  const open = raw.indexOf("(");
+  if (open < 0) return rejected("no_top_level_parenthesis");
+  const query = topLevelQueryIndex(raw);
+  if (query >= 0) return rejected("query_string_paths_are_not_operation_invocations");
+  if (!raw.startsWith("/")) return rejected("path_is_not_absolute");
+  if (raw.slice(1, open).includes("/")) return rejected("operation_segment_contains_navigation_separator");
+  const close = matchingClose(raw, open);
+  if (close === void 0) return rejected("top_level_invocation_parenthesis_is_unbalanced");
+  if (raw.slice(close + 1).trim().length > 0) return rejected("top_level_invocation_does_not_cover_remaining_path");
+  const operationSegment = raw.slice(0, open).trim();
+  if (operationSegment.length <= 1) return rejected("operation_segment_is_empty");
+  return {
+    rawOperationPath: raw,
+    normalizedOperationPath: operationSegment,
+    wasInvocation: true,
+    invocationArgumentPlaceholderKeys: [...new Set(extractTemplatePlaceholders(raw.slice(open + 1, close)))],
+    normalizationReason: "balanced_top_level_operation_invocation"
+  };
+}
+function classifyODataPathIntent(path9, method) {
+  const rawPath = (path9 ?? "").trim();
+  const normalizedMethod = (method ?? "GET").trim().toUpperCase() || "GET";
+  const queryIndex = rawPath.indexOf("?");
+  const pathWithoutQuery = queryIndex >= 0 ? rawPath.slice(0, queryIndex) : rawPath;
+  const queryString = queryIndex >= 0 ? rawPath.slice(queryIndex + 1) : void 0;
+  const segments = pathWithoutQuery.replace(/^\//, "").split("/").filter(Boolean);
+  const firstSegment = segments[0] ?? "";
+  const hasNavigationSegments = segments.length > 1;
+  const entitySegment = entitySegmentFromPath(pathWithoutQuery);
+  const placeholderKeys = [...new Set(extractTemplatePlaceholders(rawPath))];
+  const base = { rawPath, method: normalizedMethod, pathWithoutQuery, queryString, hasQueryString: queryIndex >= 0, entitySegment, placeholderKeys };
+  if (!rawPath || !rawPath.startsWith("/")) return { ...base, kind: "unknown", reason: "path_missing_or_not_absolute" };
+  if (normalizedMethod !== "GET") return { ...base, kind: "operation_invocation", reason: "non_get_service_send_defaults_to_operation" };
+  if (queryIndex >= 0) {
+    if (hasNavigationSegments) return { ...base, kind: "entity_navigation_query", reason: "get_path_has_navigation_and_query_string" };
+    if (looksLikeLowerCamelInvocation(firstSegment)) return { ...base, kind: "unknown", reason: "get_invocation_with_query_string_requires_indexed_operation_evidence" };
+    return { ...base, kind: "entity_query", reason: "get_collection_path_has_query_string" };
+  }
+  if (hasNavigationSegments) return { ...base, kind: "entity_navigation_query", reason: "get_path_has_navigation_segments" };
+  if (firstSegment.includes("(")) {
+    return looksLikeLowerCamelInvocation(firstSegment) ? { ...base, kind: "operation_invocation", reason: "get_single_lower_camel_segment_has_top_level_invocation" } : { ...base, kind: "entity_key_read", reason: "get_entity_segment_has_key_predicate" };
+  }
+  return { ...base, kind: "unknown", reason: "get_path_has_no_query_key_or_navigation_signal" };
+}
+function entitySegmentFromPath(path9) {
+  const first = path9.replace(/^\//, "").split("/")[0]?.trim();
+  if (!first) return void 0;
+  const open = first.indexOf("(");
+  const entity = (open >= 0 ? first.slice(0, open) : first).trim();
+  return entity || void 0;
+}
+function looksLikeLowerCamelInvocation(segment) {
+  const open = segment.indexOf("(");
+  if (open <= 0) return false;
+  const name = segment.slice(0, open).split(".").at(-1) ?? segment.slice(0, open);
+  return /^[a-z][A-Za-z0-9_]*$/.test(name);
+}
+function extractTemplatePlaceholders(text) {
+  const keys = [];
+  for (let index = 0; index < text.length - 1; index += 1) {
+    if (text[index] !== "$" || text[index + 1] !== "{") continue;
+    const close = matchingPlaceholderClose(text, index + 1);
+    if (close === void 0) continue;
+    const key = text.slice(index + 2, close).trim();
+    if (key) keys.push(key);
+    index = close;
+  }
+  return keys;
+}
+function matchingClose(text, openIndex) {
+  let depth = 0;
+  let quote;
+  for (let index = openIndex; index < text.length; index += 1) {
+    const char = text[index];
+    const prev = text[index - 1];
+    if (quote) {
+      if (prev === "\\") continue;
+      if (quote === "template" && char === "$" && text[index + 1] === "{") {
+        const close = matchingPlaceholderClose(text, index + 1);
+        if (close === void 0) return void 0;
+        index = close;
+        continue;
+      }
+      if (quote === "single" && char === "'" || quote === "double" && char === '"' || quote === "template" && char === "`") quote = void 0;
+      continue;
+    }
+    if (char === "$" && text[index + 1] === "{") {
+      const close = matchingPlaceholderClose(text, index + 1);
+      if (close === void 0) return void 0;
+      index = close;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = "double";
+      continue;
+    }
+    if (char === "`") {
+      quote = "template";
+      continue;
+    }
+    if (char === "(") depth += 1;
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+      if (depth < 0) return void 0;
+    }
+  }
+  return void 0;
+}
+function matchingPlaceholderClose(text, openBraceIndex) {
+  let depth = 0;
+  let quote;
+  for (let index = openBraceIndex; index < text.length; index += 1) {
+    const char = text[index];
+    const prev = text[index - 1];
+    if (quote) {
+      if (prev === "\\") continue;
+      if (quote === "template" && char === "$" && text[index + 1] === "{") {
+        depth += 1;
+        index += 1;
+        continue;
+      }
+      if (quote === "single" && char === "'" || quote === "double" && char === '"' || quote === "template" && char === "`") quote = void 0;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = "double";
+      continue;
+    }
+    if (char === "`") {
+      quote = "template";
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+      if (depth < 0) return void 0;
+    }
+  }
+  return void 0;
+}
+function topLevelQueryIndex(text) {
+  let quote;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const prev = text[index - 1];
+    if (quote) {
+      if (prev === "\\") continue;
+      if (quote === "template" && char === "$" && text[index + 1] === "{") {
+        const close = matchingPlaceholderClose(text, index + 1);
+        if (close === void 0) return -1;
+        index = close;
+        continue;
+      }
+      if (quote === "single" && char === "'" || quote === "double" && char === '"' || quote === "template" && char === "`") quote = void 0;
+      continue;
+    }
+    if (char === "$" && text[index + 1] === "{") {
+      const close = matchingPlaceholderClose(text, index + 1);
+      if (close === void 0) return -1;
+      index = close;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      continue;
+    }
+    if (char === '"') {
+      quote = "double";
+      continue;
+    }
+    if (char === "`") {
+      quote = "template";
+      continue;
+    }
+    if (char === "?") return index;
+  }
+  return -1;
+}
+
 // src/parsers/outbound-call-parser.ts
 import fs6 from "fs/promises";
 import path7 from "path";
@@ -708,9 +903,13 @@ function classifyOutboundCallsInSource(source, filePath) {
         if (objectArg && ts4.isObjectLiteralExpression(objectArg)) {
           const receiver = receiverName(expr.expression);
           const query = objectPropertyText(objectArg, "query");
+          const method = stripQuotes(objectPropertyText(objectArg, "method") ?? "POST");
           const op = objectPropertyText(objectArg, "path") ?? objectPropertyText(objectArg, "event");
           const shorthandPath = objectPropertyIsShorthand(objectArg, "path");
-          add(node, { callType: query ? "remote_query" : "remote_action", serviceVariableName: receiver, method: stripQuotes(objectPropertyText(objectArg, "method") ?? "POST"), operationPathExpr: op && !shorthandPath ? `/${stripQuotes(op).replace(/^\//, "")}` : void 0, queryEntity: query ? extractQueryEntity(query) : void 0, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason: !query && shorthandPath ? "dynamic_operation_path_identifier" : void 0 }, { receiver, classifier: "service_client_send_object", operationPathExpression: shorthandPath ? op : void 0, parserWarning: shorthandPath ? "dynamic_operation_path_identifier" : void 0 });
+          const operationPathExpr = op && !shorthandPath ? `/${stripQuotes(op).replace(/^\//, "")}` : void 0;
+          const intent = classifyODataPathIntent(operationPathExpr, method);
+          const isODataQueryRead = method.toUpperCase() === "GET" && ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
+          add(node, { callType: query || 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 && shorthandPath ? "dynamic_operation_path_identifier" : void 0 }, { receiver, classifier: "service_client_send_object", operationPathExpression: shorthandPath ? op : void 0, odataPathIntent: operationPathExpr ? intent : void 0, parserWarning: shorthandPath ? "dynamic_operation_path_identifier" : void 0 });
         }
       } else if (ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts4.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
         const wrapperName = ts4.isIdentifier(expr) ? expr.text : ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) ? expr.expression.text : "";
@@ -1433,53 +1632,6 @@ function substituteVariables(template, vars) {
   };
 }
 
-// src/linker/odata-path-normalizer.ts
-function normalizeODataOperationInvocationPath(path9) {
-  if (path9 === void 0) return void 0;
-  const raw = path9.trim();
-  if (!raw) return void 0;
-  const open = raw.indexOf("(");
-  if (open < 0) return { rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false };
-  if (!raw.startsWith("/") || raw.slice(1, open).includes("/")) return { rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false };
-  const close = matchingClose(raw, open);
-  if (close === void 0 || raw.slice(close + 1).trim().length > 0) return { rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false };
-  const operationSegment = raw.slice(0, open).trim();
-  if (operationSegment.length <= 1) return { rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false };
-  return { rawOperationPath: raw, normalizedOperationPath: operationSegment, wasInvocation: true };
-}
-function matchingClose(text, openIndex) {
-  let depth = 0;
-  let quote;
-  for (let index = openIndex; index < text.length; index += 1) {
-    const char = text[index];
-    const prev = text[index - 1];
-    if (quote) {
-      if (prev === "\\") continue;
-      if (quote === "single" && char === "'" || quote === "double" && char === '"' || quote === "template" && char === "`") quote = void 0;
-      continue;
-    }
-    if (char === "'") {
-      quote = "single";
-      continue;
-    }
-    if (char === '"') {
-      quote = "double";
-      continue;
-    }
-    if (char === "`") {
-      quote = "template";
-      continue;
-    }
-    if (char === "(") depth += 1;
-    if (char === ")") {
-      depth -= 1;
-      if (depth === 0) return index;
-      if (depth < 0) return void 0;
-    }
-  }
-  return void 0;
-}
-
 // src/linker/remote-query-target.ts
 function buildRemoteQueryTarget(input) {
   const entity = typeof input.queryEntity === "string" && input.queryEntity.trim() ? input.queryEntity.trim() : void 0;
@@ -1751,15 +1903,18 @@ function linkCalls(db, workspaceId, vars, generation) {
 function insertCallEdge(db, workspaceId, call, vars, generation) {
   const callType = String(call.call_type);
   const rawOp = applyVariables(String(call.operation_path_expr ?? ""), vars);
-  const normalized = normalizeODataOperationInvocationPath(rawOp);
-  const op = normalized?.normalizedOperationPath ?? rawOp;
+  const intent = classifyODataPathIntent(rawOp, call.method);
+  const isEntityQueryIntent = ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
+  const resolutionRawOp = callType === "remote_query" && isEntityQueryIntent ? intent.pathWithoutQuery : rawOp;
+  const normalized = normalizeODataOperationInvocationPath(resolutionRawOp);
+  const op = normalized?.normalizedOperationPath ?? resolutionRawOp;
   const servicePath = applyVariables(call.servicePathExpr ?? call.requireServicePath, vars);
   const destination = call.destinationExpr ?? call.requireDestination;
   const isDynamic = Boolean(Number(call.isDynamic ?? 0));
   const isOperationCall = 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);
-  if (callType === "remote_query" && !op) {
+  const evidence = callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0, normalized, intent);
+  if (callType === "remote_query" && (isEntityQueryIntent || !op) && !resolution.target) {
     const target = buildRemoteQueryTarget({ queryEntity: call.query_entity, servicePath, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination: destination ? applyVariables(destination, vars) : void 0, isDynamic, parserWarning: evidence.parserWarning });
     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, "HANDLER_RUNS_REMOTE_QUERY", "terminal", "call", String(call.id), target.toKind, target.toId, Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, ...target.evidence }), 0, generation);
     return { status: "terminal", callType };
@@ -1801,9 +1956,9 @@ function objectJson(value) {
   const parsed = parseJson(value);
   return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
 }
-function callEvidence(call, resolution, servicePath, op, destination, normalized) {
+function callEvidence(call, resolution, servicePath, op, destination, normalized, odataPathIntent) {
   const bindingHasDynamicExpression = Boolean(Number(call.isDynamic ?? 0));
-  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 : void 0, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, 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, candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, 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 };
+  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, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : 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, 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 linkImplementations(db, workspaceId, generation) {
   const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId);
@@ -2352,18 +2507,16 @@ function contextForSymbolCall(db, symbolCall, callerBindings) {
 }
 function contextualRuntimeResolution(db, call, binding, workspaceId) {
   if (!binding || String(call.call_type) !== "remote_action" || call.operation_path_expr === void 0 || call.operation_path_expr === null) return {};
-  const op = normalizeODataOperationInvocationPathForTrace(String(call.operation_path_expr));
+  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;
   const destination = binding.effectiveDestination ?? binding.destinationExpr ?? binding.requireDestination;
   const resolution = resolveOperation(db, { servicePath, operationPath: op, alias: binding.aliasExpr ?? binding.alias, destination, hasExplicitOverride: true, isDynamic: false }, workspaceId);
-  const evidence = { contextualServiceBindingAttempted: true, contextualBinding: { source: binding.source, callerArgument: binding.callerArgument, callerProperty: binding.callerProperty, calleeParameter: binding.calleeParameter, calleeReceiver: binding.calleeReceiver, bindingSourceFile: binding.sourceFile, bindingSourceLine: binding.sourceLine, alias: binding.alias, aliasExpr: binding.aliasExpr, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination }, operationPath: op, servicePath, serviceAlias: binding.alias, serviceAliasExpr: binding.aliasExpr, destination, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination, contextualResolutionStatus: resolution.status, contextualCandidateCount: resolution.candidates.length, candidates: resolution.candidates, contextualResolutionReasons: resolution.reasons, resolutionReasons: resolution.reasons };
+  const evidence = { contextualServiceBindingAttempted: true, contextualBinding: { source: binding.source, callerArgument: binding.callerArgument, callerProperty: binding.callerProperty, calleeParameter: binding.calleeParameter, calleeReceiver: binding.calleeReceiver, bindingSourceFile: binding.sourceFile, bindingSourceLine: binding.sourceLine, alias: binding.alias, aliasExpr: binding.aliasExpr, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination }, operationPath: op, rawOperationPath: normalized?.rawOperationPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, servicePath, serviceAlias: binding.alias, serviceAliasExpr: binding.aliasExpr, destination, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination, contextualResolutionStatus: resolution.status, contextualCandidateCount: resolution.candidates.length, candidates: resolution.candidates, contextualResolutionReasons: resolution.reasons, resolutionReasons: resolution.reasons };
   if (!resolution.target) return { evidence, unresolvedReason: resolution.status === "ambiguous" ? "Ambiguous contextual operation candidates" : resolution.status === "dynamic" ? `Dynamic contextual target is missing runtime variables: ${resolution.reasons.join(", ")}` : "No contextual operation candidate matched" };
   const resolvedEvidence = { ...evidence, contextualServiceBindingSelected: true, targetRepo: resolution.target.repoName, targetServicePath: resolution.target.servicePath, targetOperationPath: resolution.target.operationPath, targetOperation: resolution.target.operationName };
   return { row: { id: -Number(call.id), edge_type: "REMOTE_CALL_RESOLVES_TO_OPERATION", from_id: String(call.id), to_kind: "operation", to_id: String(resolution.target.operationId), confidence: resolution.target.score, evidence_json: JSON.stringify(resolvedEvidence), status: "resolved" }, evidence: resolvedEvidence, unresolvedReason: void 0 };
 }
-function normalizeODataOperationInvocationPathForTrace(raw) {
-  return raw.startsWith("/") ? raw : `/${raw}`;
-}
 function edgeTarget(row, evidence) {
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
@@ -2554,14 +2707,14 @@ export {
   parseHandlerRegistrations,
   redactText,
   redactValue,
+  normalizeODataOperationInvocationPath,
   containsSupportedOutboundCall,
   parseOutboundCalls,
   parseServiceBindings,
   applyVariables,
   extractPlaceholders,
   substituteVariables,
-  normalizeODataOperationInvocationPath,
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-SWPGRM7Z.js.map
+//# sourceMappingURL=chunk-UHYHSYCS.js.map