@saptools/service-flow 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.24
+
+- Add conservative class instance method symbol-call resolution for same-file and relatively imported helper classes, with auditable class-instance evidence.
+- Propagate service-client binding context through resolved local symbol calls for explicit positional and object-literal helper arguments during trace rendering.
+- Harden one-hop higher-order send wrapper literal path propagation for returned async closures and expose wrapper definition evidence.
+- Refine strict doctor categories for no-binding remote actions and split ambiguous versus unresolved implementation diagnostics with capped examples.
+
+## 0.1.23
+
+- Retrospective note: preserve same-file late-assignment service binding extraction for connected clients, `cds.connect.to(...)` assignments, identity aliases, and simple transaction aliases before outbound `send(...)` calls.
+- Retrospective note: preserve explicit object destructuring from safe helper-returned client objects so binding rows remain available for downstream remote action linking.
+
 ## 0.1.22
 
 - Propagate conservative same-file identity aliases of connected service clients, including typed, `as`, `satisfies`, helper-returned, and transitive aliases, while preserving `.tx()` alias evidence.

package/dist/{chunk-JIY37C44.js → chunk-RXJNPONU.js}

@@ -642,28 +642,25 @@ function collectWrapperSpecs(source) {
   const specs = /* @__PURE__ */ new Map();
   const scanFunction = (name, fn) => {
     const params = fn.parameters.map((param) => ts4.isIdentifier(param.name) ? param.name.text : void 0);
-    let found;
+    const closure = returnedClosure(fn) ?? fn;
+    const sends = [];
     const visit = (node) => {
-      if (found) return;
-      if (node !== fn && (ts4.isFunctionDeclaration(node) || ts4.isArrowFunction(node) || ts4.isFunctionExpression(node))) {
-        ts4.forEachChild(node, visit);
-        return;
-      }
       if (ts4.isCallExpression(node) && ts4.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts4.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
         if (objectArg && ts4.isObjectLiteralExpression(objectArg)) {
           const pathProp = objectArg.properties.find((property) => ts4.isShorthandPropertyAssignment(property) && property.name.text === "path");
-          if (pathProp) found = { client: node.expression.expression.text, path: pathProp.name.text, method: objectPropertyText(objectArg, "method") };
+          if (pathProp) sends.push({ client: node.expression.expression.text, path: pathProp.name.text, method: objectPropertyText(objectArg, "method") });
         }
       }
       ts4.forEachChild(node, visit);
     };
-    visit(fn);
-    if (!found) return;
+    visit(closure);
+    if (sends.length !== 1) return;
+    const found = sends[0];
     const clientIndex = params.indexOf(found.client);
     const pathIndex = params.indexOf(found.path);
     const methodIndex = found.method && params.includes(found.method) ? params.indexOf(found.method) : void 0;
-    if (clientIndex >= 0 && pathIndex >= 0) specs.set(name, { clientIndex, pathIndex, methodIndex });
+    if (clientIndex >= 0 && pathIndex >= 0) specs.set(name, { clientIndex, pathIndex, methodIndex, definitionLine: lineOf3(source.text, fn.getStart(source)) });
   };
   for (const stmt of source.statements) {
     if (ts4.isFunctionDeclaration(stmt) && stmt.name) scanFunction(stmt.name.text, stmt);
@@ -673,6 +670,16 @@ function collectWrapperSpecs(source) {
   }
   return specs;
 }
+function returnedClosure(fn) {
+  const body = fn.body;
+  if (!body) return void 0;
+  if (ts4.isArrowFunction(fn) && !ts4.isBlock(body)) return ts4.isArrowFunction(body) || ts4.isFunctionExpression(body) ? body : void 0;
+  if (!ts4.isBlock(body)) return void 0;
+  const returns = body.statements.filter(ts4.isReturnStatement);
+  if (returns.length !== 1) return void 0;
+  const expr = returns[0]?.expression;
+  return expr && (ts4.isArrowFunction(expr) || ts4.isFunctionExpression(expr)) ? expr : void 0;
+}
 function classifyOutboundCallsInSource(source, filePath) {
   const calls = [];
   const sourceFile = normalizePath(filePath);
@@ -691,22 +698,24 @@ 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 (ts4.isPropertyAccessExpression(expr) && expr.name.text === "send" && ts4.isIdentifier(expr.expression)) {
+      } else if (ts4.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts4.isIdentifier(expr.expression) || ts4.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
         if (objectArg && ts4.isObjectLiteralExpression(objectArg)) {
-          const receiver = expr.expression.text;
+          const receiver = receiverName(expr.expression);
           const query = objectPropertyText(objectArg, "query");
           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 });
         }
-      } else if (ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text)) {
-        const spec = wrapperSpecs.get(expr.expression.text);
-        const clientArg = spec ? expr.arguments[spec.clientIndex] : void 0;
-        const pathArg = spec ? expr.arguments[spec.pathIndex] : void 0;
-        const methodArg = spec?.methodIndex === void 0 ? void 0 : expr.arguments[spec.methodIndex];
+      } 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 : "";
+        const wrapperArgs = ts4.isIdentifier(expr) ? node.arguments : ts4.isCallExpression(expr) ? expr.arguments : node.arguments;
+        const spec = wrapperSpecs.get(wrapperName);
+        const clientArg = spec ? wrapperArgs[spec.clientIndex] : void 0;
+        const pathArg = spec ? wrapperArgs[spec.pathIndex] : void 0;
+        const methodArg = spec?.methodIndex === void 0 ? void 0 : wrapperArgs[spec.methodIndex];
         if (spec && clientArg && ts4.isIdentifier(clientArg) && isStringLike(pathArg)) {
-          add(node, { callType: "remote_action", serviceVariableName: clientArg.text, method: stripQuotes(methodArg?.getText(source) ?? "POST"), operationPathExpr: `/${pathArg.text.replace(/^\//, "")}`, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver: clientArg.text, classifier: "local_wrapper_literal_path", wrapperFunction: expr.expression.text, literalCallerArgumentDetected: true });
+          add(node, { callType: "remote_action", serviceVariableName: clientArg.text, method: stripQuotes(methodArg?.getText(source) ?? "POST"), operationPathExpr: `/${pathArg.text.replace(/^\//, "")}`, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver: clientArg.text, classifier: "higher_order_wrapper_literal_path", wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, literalCallerArgumentDetected: true });
         }
       } else if (ts4.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
         const receiver = receiverName(expr.expression);
@@ -859,13 +868,17 @@ function connectFactFromCall(call) {
 }
 function unwrapCall(expr) {
   if (ts5.isAwaitExpression(expr)) return unwrapCall(expr.expression);
+  if (ts5.isParenthesizedExpression(expr)) return unwrapCall(expr.expression);
   if (ts5.isAsExpression(expr) || ts5.isSatisfiesExpression(expr)) return unwrapCall(expr.expression);
+  if (ts5.isTypeAssertionExpression(expr)) return unwrapCall(expr.expression);
   if (ts5.isCallExpression(expr)) return expr;
   return void 0;
 }
 function unwrapIdentityExpression(expr) {
   if (ts5.isAwaitExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts5.isParenthesizedExpression(expr)) return unwrapIdentityExpression(expr.expression);
   if (ts5.isAsExpression(expr) || ts5.isSatisfiesExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts5.isTypeAssertionExpression(expr)) return unwrapIdentityExpression(expr.expression);
   return expr;
 }
 function findConnectInExpression(expr) {
@@ -1129,18 +1142,17 @@ async function parseServiceBindings(repoPath, filePath) {
     const sourceFile = normalizePath(filePath);
     return [...out].reverse().find((row) => row.variableName === variableName && row.sourceFile === sourceFile);
   }
-  function cloneAliasBinding(decl, sourceName, aliasKind) {
-    if (!ts5.isIdentifier(decl.name)) return;
+  function cloneAliasBinding(targetName, sourceName, aliasKind, node) {
     const existing = bindingForVariable(sourceName);
     if (!existing) return;
     out.push({
       ...existing,
-      variableName: decl.name.text,
-      sourceLine: lineOf4(sourceFileAst, decl),
+      variableName: targetName,
+      sourceLine: lineOf4(sourceFileAst, node),
       helperChain: [
         ...existing.helperChain ?? [],
         {
-          callerVariable: decl.name.text,
+          callerVariable: targetName,
           aliasOf: sourceName,
           aliasKind,
           scopeRule: "same-file-source-order"
@@ -1152,25 +1164,25 @@ async function parseServiceBindings(repoPath, filePath) {
     if (!ts5.isIdentifier(decl.name) || !decl.initializer) return;
     const unwrapped = unwrapIdentityExpression(decl.initializer);
     if (!ts5.isIdentifier(unwrapped)) return;
-    cloneAliasBinding(decl, unwrapped.text, "identity");
+    cloneAliasBinding(decl.name.text, unwrapped.text, "identity", decl);
   }
-  async function recordVariable(decl) {
-    if (!ts5.isIdentifier(decl.name) || !decl.initializer) return;
-    const call = unwrapCall(decl.initializer);
+  async function recordBindingFromExpression(targetName, expr, node, aliasKind) {
+    const call = unwrapCall(expr);
     if (!call) return;
     const direct = connectFactFromCall(call);
     if (direct)
       out.push({
-        variableName: decl.name.text,
+        variableName: targetName,
         ...direct,
         sourceFile: normalizePath(filePath),
-        sourceLine: lineOf4(sourceFileAst, decl)
+        sourceLine: lineOf4(sourceFileAst, node),
+        helperChain: aliasKind === "assignment" ? [{ callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind, scopeRule: "same-file-source-order" }] : void 0
       });
     else if (ts5.isIdentifier(call.expression)) {
       const resolved = await importedHelper(call.expression.text);
       if (resolved)
         out.push({
-          variableName: decl.name.text,
+          variableName: targetName,
           alias: resolved.helper.alias,
           aliasExpr: resolved.helper.aliasExpr,
           destinationExpr: resolved.helper.destinationExpr,
@@ -1178,10 +1190,11 @@ async function parseServiceBindings(repoPath, filePath) {
           isDynamic: resolved.helper.isDynamic,
           placeholders: resolved.helper.placeholders,
           sourceFile: normalizePath(filePath),
-          sourceLine: lineOf4(sourceFileAst, decl),
+          sourceLine: lineOf4(sourceFileAst, node),
           helperChain: [
             {
-              callerVariable: decl.name.text,
+              callerVariable: targetName,
+              ...aliasKind === "assignment" ? { assignedFrom: call.expression.text, aliasKind, scopeRule: "same-file-source-order" } : {},
               importedHelper: call.expression.text,
               importSource: resolved.imp.sourceFile,
               exportedSymbol: resolved.imp.exportedName,
@@ -1192,6 +1205,10 @@ async function parseServiceBindings(repoPath, filePath) {
         });
     }
   }
+  async function recordVariable(decl) {
+    if (!ts5.isIdentifier(decl.name) || !decl.initializer) return;
+    await recordBindingFromExpression(decl.name.text, decl.initializer, decl, "declaration");
+  }
   async function helpersForCall(call) {
     if (!ts5.isIdentifier(call.expression)) return [];
     const local = localObjectHelpers.get(call.expression.text) ?? [];
@@ -1224,6 +1241,39 @@ async function parseServiceBindings(repoPath, filePath) {
       });
     }
   }
+  async function recordDestructuredAssignment(pattern, expr, node) {
+    const call = unwrapCall(expr);
+    if (!call) return;
+    const helpers = await helpersForCall(call);
+    if (helpers.length === 0) return;
+    for (const prop of pattern.properties) {
+      let propertyName;
+      let targetName;
+      if (ts5.isShorthandPropertyAssignment(prop)) {
+        propertyName = prop.name.text;
+        targetName = prop.name.text;
+      } else if (ts5.isPropertyAssignment(prop)) {
+        propertyName = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+        targetName = ts5.isIdentifier(prop.initializer) ? prop.initializer.text : void 0;
+      }
+      if (!propertyName || !targetName) continue;
+      const matches = helpers.filter((row) => row.helper.returnedProperty === propertyName);
+      if (matches.length !== 1) continue;
+      const resolved = matches[0];
+      out.push({
+        variableName: targetName,
+        alias: resolved.helper.alias,
+        aliasExpr: resolved.helper.aliasExpr,
+        destinationExpr: resolved.helper.destinationExpr,
+        servicePathExpr: resolved.helper.servicePathExpr,
+        isDynamic: resolved.helper.isDynamic,
+        placeholders: resolved.helper.placeholders,
+        sourceFile: normalizePath(filePath),
+        sourceLine: lineOf4(sourceFileAst, node),
+        helperChain: [{ callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName, importSource: resolved.imp?.sourceFile, exportedSymbol: resolved.imp?.exportedName, helperSourceFile: resolved.helper.sourceFile, helperSourceLine: resolved.helper.sourceLine }]
+      });
+    }
+  }
   function recordDestructuredClassHelper(decl) {
     if (!ts5.isObjectBindingPattern(decl.name) || !decl.initializer) return;
     const call = unwrapCall(decl.initializer);
@@ -1256,20 +1306,40 @@ async function parseServiceBindings(repoPath, filePath) {
       });
     }
   }
-  const declarations = [];
-  function collectDeclarations(node) {
-    if (ts5.isVariableDeclaration(node)) declarations.push(node);
-    ts5.forEachChild(node, collectDeclarations);
-  }
-  collectDeclarations(sourceFileAst);
-  for (const decl of declarations) {
-    await recordDestructuredHelper(decl);
-    recordDestructuredClassHelper(decl);
-    await recordVariable(decl);
-    recordIdentityAlias(decl);
-    if (ts5.isIdentifier(decl.name) && decl.initializer && ts5.isCallExpression(decl.initializer) && ts5.isPropertyAccessExpression(decl.initializer.expression) && decl.initializer.expression.name.text === "tx" && ts5.isIdentifier(decl.initializer.expression.expression)) {
-      cloneAliasBinding(decl, decl.initializer.expression.expression.text, "transaction");
+  const events = [];
+  function collectEvents(node) {
+    if (ts5.isVariableDeclaration(node)) events.push({ pos: node.getStart(sourceFileAst), node });
+    if (ts5.isBinaryExpression(node) && node.operatorToken.kind === ts5.SyntaxKind.EqualsToken)
+      events.push({ pos: node.getStart(sourceFileAst), node });
+    ts5.forEachChild(node, collectEvents);
+  }
+  collectEvents(sourceFileAst);
+  events.sort((a, b) => a.pos - b.pos);
+  for (const event of events) {
+    if (ts5.isVariableDeclaration(event.node)) {
+      const decl = event.node;
+      await recordDestructuredHelper(decl);
+      recordDestructuredClassHelper(decl);
+      await recordVariable(decl);
+      recordIdentityAlias(decl);
+      if (ts5.isIdentifier(decl.name) && decl.initializer && ts5.isCallExpression(decl.initializer) && ts5.isPropertyAccessExpression(decl.initializer.expression) && decl.initializer.expression.name.text === "tx" && ts5.isIdentifier(decl.initializer.expression.expression)) {
+        cloneAliasBinding(decl.name.text, decl.initializer.expression.expression.text, "transaction", decl);
+      }
+      continue;
+    }
+    const assignment = event.node;
+    if (ts5.isIdentifier(assignment.left)) {
+      const rhs = unwrapIdentityExpression(assignment.right);
+      if (ts5.isIdentifier(rhs)) {
+        cloneAliasBinding(assignment.left.text, rhs.text, "identity-assignment", assignment);
+        continue;
+      }
+      await recordBindingFromExpression(assignment.left.text, assignment.right, assignment, "assignment");
+      continue;
     }
+    const left = ts5.isParenthesizedExpression(assignment.left) ? assignment.left.expression : assignment.left;
+    if (ts5.isObjectLiteralExpression(left))
+      await recordDestructuredAssignment(left, assignment.right, assignment);
   }
   return out;
 }
@@ -2176,6 +2246,65 @@ function runtimeResolution(db, row, evidence, vars) {
   const unresolvedReason = resolution.status === "dynamic" ? `Dynamic target is missing runtime variables: ${resolution.reasons.join(", ")}` : resolution.status === "ambiguous" ? "Ambiguous runtime operation candidates" : "No runtime operation candidate matched substituted service and operation path";
   return { row, evidence: nextEvidence, unresolvedReason };
 }
+function parseEvidence(value) {
+  try {
+    const parsed = JSON.parse(String(value || "{}"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function receiverFromEvidence(value) {
+  const evidence = parseEvidence(value);
+  return typeof evidence.receiver === "string" ? evidence.receiver : void 0;
+}
+function knownBindingsForCalls(db, calls) {
+  const map = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const receiver = receiverFromEvidence(call.evidence_json);
+    const bindingId = Number(call.service_binding_id ?? 0);
+    if (!receiver || !bindingId) continue;
+    const row = db.prepare("SELECT id,alias,alias_expr aliasExpr,destination_expr destinationExpr,service_path_expr servicePathExpr,source_file sourceFile,source_line sourceLine FROM service_bindings WHERE id=?").get(bindingId);
+    if (row) map.set(receiver, { ...row, bindingId, source: "local_service_binding", calleeReceiver: receiver });
+  }
+  return map;
+}
+function contextForSymbolCall(db, symbolCall, callerBindings) {
+  const next = /* @__PURE__ */ new Map();
+  if (callerBindings.size === 0) return next;
+  const callEvidence2 = parseEvidence(symbolCall.evidence_json);
+  const callee = db.prepare("SELECT evidence_json evidenceJson FROM symbols WHERE id=?").get(symbolCall.callee_symbol_id);
+  const calleeEvidence = parseEvidence(callee?.evidenceJson);
+  const params = Array.isArray(calleeEvidence.parameters) ? calleeEvidence.parameters.filter((item) => typeof item === "string") : [];
+  const args = Array.isArray(callEvidence2.callArguments) ? callEvidence2.callArguments : [];
+  args.forEach((arg, index) => {
+    const param = params[index];
+    if (!param) return;
+    if (arg.kind === "identifier" && typeof arg.name === "string") {
+      const binding = callerBindings.get(arg.name);
+      if (binding) next.set(param, { ...binding, source: "local_symbol_argument", callerArgument: arg.name, calleeParameter: param, calleeReceiver: param });
+    }
+    if (arg.kind === "object_literal" && Array.isArray(arg.properties)) {
+      for (const prop of arg.properties) {
+        if (typeof prop.property !== "string" || typeof prop.argument !== "string") continue;
+        const binding = callerBindings.get(prop.argument);
+        if (binding) next.set(`${param}.${prop.property}`, { ...binding, source: "local_symbol_object_argument", callerProperty: prop.property, callerArgument: prop.argument, calleeParameter: param, calleeReceiver: `${param}.${prop.property}` });
+      }
+    }
+  });
+  return next;
+}
+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 resolution = resolveOperation(db, { servicePath: binding.servicePathExpr, operationPath: op, alias: binding.aliasExpr ?? binding.alias, destination: binding.destinationExpr, hasExplicitOverride: true, isDynamic: false }, workspaceId);
+  const evidence = { contextualServiceBindingSelected: true, contextualBinding: { source: binding.source, callerArgument: binding.callerArgument, callerProperty: binding.callerProperty, calleeParameter: binding.calleeParameter, calleeReceiver: binding.calleeReceiver, bindingSourceFile: binding.sourceFile, bindingSourceLine: binding.sourceLine }, operationPath: op, servicePath: binding.servicePathExpr, serviceAlias: binding.alias, serviceAliasExpr: binding.aliasExpr, destination: binding.destinationExpr, contextualResolutionStatus: resolution.status, candidates: resolution.candidates, resolutionReasons: resolution.reasons };
+  if (!resolution.target) return { evidence, unresolvedReason: resolution.status === "ambiguous" ? "Ambiguous contextual operation candidates" : "No contextual operation candidate matched" };
+  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(evidence), status: "resolved" }, evidence: { ...evidence, targetRepo: resolution.target.repoName, targetServicePath: resolution.target.servicePath, targetOperationPath: resolution.target.operationPath, targetOperation: resolution.target.operationName }, unresolvedReason: void 0 };
+}
+function normalizeODataOperationInvocationPathForTrace(raw) {
+  return raw.startsWith("/") ? raw : `/${raw}`;
+}
 function edgeTarget(row, evidence) {
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
@@ -2208,7 +2337,7 @@ function trace(db, start, options) {
   const maxDepth = positiveDepth(options.depth);
   const edges = [];
   const nodes = /* @__PURE__ */ new Map();
-  const queue = scope.selectorMatched ? [{ repoId: scope.repo?.id, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1 }] : [];
+  const queue = scope.selectorMatched ? [{ repoId: scope.repo?.id, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: /* @__PURE__ */ new Map() }] : [];
   if (start.servicePath && (start.operation ?? start.operationPath)) {
     const startOperation = normalizeOperation(start.operation ?? start.operationPath);
     const startRows = db.prepare(`SELECT o.id operationId,r.name repoName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine 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 s.repo_id=?) AND s.service_path=? AND (o.operation_path=? OR o.operation_name=?) ORDER BY r.name,o.id LIMIT 2`).all(scope.repo?.id, scope.repo?.id, start.servicePath, startOperation, startOperation);
@@ -2241,6 +2370,7 @@ function trace(db, start, options) {
     const filtered = calls.filter(
       (c) => (!current.symbolIds || current.symbolIds.has(Number(c.source_symbol_id))) && (!current.files || current.files.has(String(c.source_file))) && includeCall(String(c.call_type), options)
     );
+    const callerBindings = new Map([...current.context ?? /* @__PURE__ */ new Map(), ...knownBindingsForCalls(db, filtered)]);
     if (current.symbolIds && current.symbolIds.size > 0 && current.depth < maxDepth) {
       const symbolRows = db.prepare(`SELECT sc.*,s.repo_id calleeRepoId,s.source_file calleeFile FROM symbol_calls sc LEFT JOIN symbols s ON s.id=sc.callee_symbol_id WHERE sc.caller_symbol_id IN (${[...current.symbolIds].map(() => "?").join(",")}) ORDER BY sc.source_file,sc.source_line`).all(...current.symbolIds);
       for (const symbolCall of symbolRows) {
@@ -2254,7 +2384,7 @@ function trace(db, start, options) {
         const evidence = { ...JSON.parse(String(symbolCall.evidence_json || "{}")), sourceFile: symbolCall.source_file, sourceLine: symbolCall.source_line, calleeSymbolId: symbolCall.callee_symbol_id, calleeSymbolName: calleeNode?.symbolName, calleeSymbolFile: calleeNode?.sourceFile, resolutionStatus: symbolCall.status };
         edges.push({ step: current.depth, type: "local_symbol_call", from: String(symbolCall.callee_expression), to: calleeNode?.label ? String(calleeNode.label) : `symbol:${String(symbolCall.callee_symbol_id)}`, evidence, confidence: Number(symbolCall.confidence ?? 0.8), unresolvedReason: String(symbolCall.status) === "resolved" ? void 0 : symbolCall.unresolved_reason ? String(symbolCall.unresolved_reason) : void 0 });
         if (seenScopes.has(nextKey)) edges.push({ step: current.depth, type: "cycle", from: String(symbolCall.callee_expression), to: nextKey, evidence: { cycle: true, symbolCallId: symbolCall.id }, confidence: 1, unresolvedReason: "Cycle detected; downstream symbol already visited" });
-        else queue.push({ repoId: nextRepoId, files: nextFiles, symbolIds: nextSymbols, depth: current.depth + 1 });
+        else queue.push({ repoId: nextRepoId, files: nextFiles, symbolIds: nextSymbols, depth: current.depth + 1, context: contextForSymbolCall(db, symbolCall, callerBindings) });
       }
     }
     const graph = graphForCalls(
@@ -2271,11 +2401,12 @@ function trace(db, start, options) {
         line: call.source_line,
         callType: call.call_type
       });
-      const graphRows = graph.get(Number(call.id)) ?? [];
+      const contextual = contextualRuntimeResolution(db, call, (current.context ?? /* @__PURE__ */ new Map()).get(receiverFromEvidence(call.evidence_json) ?? ""), workspaceIdForCall(db, String(call.id)));
+      const graphRows = contextual.row ? [contextual.row] : graph.get(Number(call.id)) ?? [];
       for (const row of graphRows) {
         if (seenEdges.has(Number(row.id))) continue;
         seenEdges.add(Number(row.id));
-        const rawEvidence = JSON.parse(
+        const rawEvidence = contextual.evidence && row.id < 0 ? contextual.evidence : JSON.parse(
           String(row.evidence_json || "{}")
         );
         const effective = runtimeResolution(db, row, rawEvidence, options.vars);
@@ -2372,4 +2503,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-JIY37C44.js.map
+//# sourceMappingURL=chunk-RXJNPONU.js.map