@saptools/service-flow 0.1.3 → 0.1.5

package/dist/{chunk-SIKIGT42.js → chunk-I33ASGX3.js}

@@ -24,6 +24,27 @@ async function discoverRepositories(rootPath, ignore) {
   const root = path2.resolve(rootPath);
   const ignored = new Set(ignore);
   const found = [];
+  async function isRealGitMarker(dir) {
+    const gitPath = path2.join(dir, ".git");
+    try {
+      const st = await fs.stat(gitPath);
+      if (st.isDirectory()) {
+        const children = await fs.readdir(gitPath);
+        return children.includes("HEAD") || children.includes("config");
+      }
+      if (st.isFile()) {
+        const text = await fs.readFile(gitPath, "utf8");
+        return text.trimStart().startsWith("gitdir:");
+      }
+    } catch {
+    }
+    try {
+      const fixture = await fs.stat(path2.join(dir, ".git-fixture"));
+      return fixture.isFile() || fixture.isDirectory();
+    } catch {
+      return false;
+    }
+  }
   async function walk(dir) {
     const rel = relativePath(root, dir);
     if (rel !== "." && rel.split("/").some((part) => ignored.has(part))) return;
@@ -33,14 +54,14 @@ async function discoverRepositories(rootPath, ignore) {
     } catch {
       return;
     }
-    if (entries.some((e) => e.name === ".git" || e.name === ".git-fixture")) {
+    const hasMarker = entries.some((e) => e.name === ".git" || e.name === ".git-fixture");
+    if (hasMarker && await isRealGitMarker(dir)) {
       found.push({
         name: path2.basename(dir),
         absolutePath: dir,
         relativePath: relativePath(root, dir),
         isGitRepo: true
       });
-      return;
     }
     for (const entry of entries)
       if (entry.isDirectory() && !ignore.includes(entry.name))
@@ -507,13 +528,21 @@ function connectFactFromCall(call) {
     return void 0;
   const first = call.arguments[0];
   if (!first) return void 0;
+  const second = call.arguments[1];
+  const objectArg = ts3.isObjectLiteralExpression(first) ? first : second && ts3.isObjectLiteralExpression(second) ? second : void 0;
+  let alias;
+  let aliasExpr;
   if (ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first))
+    alias = first.text;
+  else if (!ts3.isObjectLiteralExpression(first))
+    aliasExpr = stringValue(first);
+  if ((ts3.isStringLiteralLike(first) || ts3.isNoSubstitutionTemplateLiteral(first)) && !objectArg)
     return { alias: first.text, isDynamic: false, placeholders: [] };
-  if (!ts3.isObjectLiteralExpression(first))
+  if (!objectArg && aliasExpr)
     return {
-      servicePathExpr: first.getText(),
+      aliasExpr,
       isDynamic: true,
-      placeholders: []
+      placeholders: placeholders(aliasExpr)
     };
   let destinationExpr;
   let servicePathExpr;
@@ -529,12 +558,15 @@ function connectFactFromCall(call) {
         visitObject(prop.initializer);
     }
   }
-  visitObject(first);
+  if (objectArg) visitObject(objectArg);
   const ph = [
+    ...placeholders(aliasExpr ?? alias),
     ...placeholders(destinationExpr),
     ...placeholders(servicePathExpr)
   ];
   return {
+    alias,
+    aliasExpr,
     destinationExpr,
     servicePathExpr,
     isDynamic: ph.length > 0 || !destinationExpr && !servicePathExpr,
@@ -577,7 +609,9 @@ async function readSource(abs) {
 }
 async function resolveImport(repoPath, fromFile, spec) {
   if (!spec.startsWith(".")) return void 0;
-  const base = path8.resolve(repoPath, path8.dirname(fromFile), spec);
+  const rawBase = path8.resolve(repoPath, path8.dirname(fromFile), spec);
+  const parsed = path8.parse(rawBase);
+  const base = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(parsed.ext) ? path8.join(parsed.dir, parsed.name) : rawBase;
   for (const candidate of [
     base,
     `${base}.ts`,
@@ -622,15 +656,33 @@ async function importsFor(repoPath, filePath, sf) {
   }
   return imports;
 }
+function exportedLocalNames(sf) {
+  const exports = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    const direct = ts3.canHaveModifiers(stmt) ? ts3.getModifiers(stmt)?.some(
+      (m) => m.kind === ts3.SyntaxKind.ExportKeyword
+    ) ?? false : false;
+    if (direct && ts3.isFunctionDeclaration(stmt) && stmt.name)
+      exports.set(stmt.name.text, stmt.name.text);
+    if (direct && ts3.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations)
+        if (ts3.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
+    }
+    if (!ts3.isExportDeclaration(stmt) || !stmt.exportClause) continue;
+    if (!ts3.isNamedExports(stmt.exportClause)) continue;
+    for (const el of stmt.exportClause.elements)
+      exports.set(el.name.text, el.propertyName?.text ?? el.name.text);
+  }
+  return exports;
+}
 async function helperBindings(repoPath, filePath) {
   const sf = await readSource(path8.join(repoPath, filePath));
   if (!sf) return [];
   const sourceFileAst = sf;
   const out = [];
+  const exportedLocals = exportedLocalNames(sf);
+  const factsByLocal = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    const exported = ts3.canHaveModifiers(stmt) ? ts3.getModifiers(stmt)?.some(
-      (m) => m.kind === ts3.SyntaxKind.ExportKeyword
-    ) ?? false : false;
     if (ts3.isFunctionDeclaration(stmt) && stmt.name) {
       let fact;
       stmt.forEachChild(function visit(node) {
@@ -638,27 +690,29 @@ async function helperBindings(repoPath, filePath) {
           fact = findConnectInExpression(node.expression);
         if (!fact) ts3.forEachChild(node, visit);
       });
-      if (fact && exported)
-        out.push({
-          ...fact,
-          exportedName: stmt.name.text,
-          sourceFile: normalizePath(filePath),
-          sourceLine: lineOf4(sf, stmt)
-        });
+      if (fact) factsByLocal.set(stmt.name.text, { ...fact, sourceLine: lineOf4(sf, stmt) });
     }
     if (ts3.isVariableStatement(stmt))
       for (const decl of stmt.declarationList.declarations) {
         if (!ts3.isIdentifier(decl.name) || !decl.initializer) continue;
         const fact = findConnectInExpression(decl.initializer);
-        if (fact && exported)
-          out.push({
+        if (fact)
+          factsByLocal.set(decl.name.text, {
             ...fact,
-            exportedName: decl.name.text,
-            sourceFile: normalizePath(filePath),
             sourceLine: lineOf4(sourceFileAst, decl)
           });
       }
   }
+  for (const [exportedName, localName] of exportedLocals) {
+    const fact = factsByLocal.get(localName);
+    if (fact)
+      out.push({
+        ...fact,
+        exportedName,
+        sourceFile: normalizePath(filePath),
+        sourceLine: fact.sourceLine
+      });
+  }
   return out;
 }
 async function parseServiceBindings(repoPath, filePath) {
@@ -668,6 +722,7 @@ async function parseServiceBindings(repoPath, filePath) {
   const out = [];
   const imports = await importsFor(repoPath, filePath, sf);
   const helperCache = /* @__PURE__ */ new Map();
+  const classHelpers = collectClassHelpers(sourceFileAst);
   async function importedHelper(localName) {
     const imp = imports.find((i) => i.localName === localName && i.sourceFile);
     if (!imp?.sourceFile) return void 0;
@@ -697,6 +752,7 @@ async function parseServiceBindings(repoPath, filePath) {
         out.push({
           variableName: decl.name.text,
           alias: resolved.helper.alias,
+          aliasExpr: resolved.helper.aliasExpr,
           destinationExpr: resolved.helper.destinationExpr,
           servicePathExpr: resolved.helper.servicePathExpr,
           isDynamic: resolved.helper.isDynamic,
@@ -716,15 +772,105 @@ async function parseServiceBindings(repoPath, filePath) {
         });
     }
   }
+  function recordDestructuredClassHelper(decl) {
+    if (!ts3.isObjectBindingPattern(decl.name) || !decl.initializer) return;
+    const call = unwrapCall(decl.initializer);
+    if (!call || !ts3.isPropertyAccessExpression(call.expression)) return;
+    const target = call.expression;
+    if (target.expression.kind !== ts3.SyntaxKind.ThisKeyword) return;
+    for (const el of decl.name.elements) {
+      if (!ts3.isIdentifier(el.name)) continue;
+      const propertyName = el.propertyName && ts3.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const helper = classHelpers.find(
+        (h) => h.helperName === target.name.text && h.propertyName === propertyName
+      );
+      if (!helper) continue;
+      out.push({
+        variableName: el.name.text,
+        ...helper.fact,
+        sourceFile: normalizePath(filePath),
+        sourceLine: lineOf4(sourceFileAst, decl),
+        helperChain: [
+          {
+            callerVariable: el.name.text,
+            className: helper.className,
+            classHelper: helper.helperName,
+            returnedProperty: helper.propertyName,
+            helperVariable: helper.variableName,
+            helperSourceFile: normalizePath(filePath),
+            helperSourceLine: helper.sourceLine
+          }
+        ]
+      });
+    }
+  }
   const declarations = [];
   function collectDeclarations(node) {
     if (ts3.isVariableDeclaration(node)) declarations.push(node);
     ts3.forEachChild(node, collectDeclarations);
   }
   collectDeclarations(sourceFileAst);
-  for (const decl of declarations) await recordVariable(decl);
+  for (const decl of declarations) {
+    recordDestructuredClassHelper(decl);
+    await recordVariable(decl);
+  }
   return out;
 }
+function collectClassHelpers(sf) {
+  const helpers = [];
+  for (const stmt of sf.statements) {
+    if (!ts3.isClassDeclaration(stmt) || !stmt.name) continue;
+    for (const member of stmt.members) {
+      let visit2 = function(node) {
+        if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
+          const fact = findConnectInExpression(node.initializer);
+          if (fact) bindings.set(node.name.text, fact);
+        }
+        if (ts3.isReturnStatement(node) && node.expression && ts3.isObjectLiteralExpression(node.expression)) {
+          for (const prop of node.expression.properties) {
+            if (ts3.isShorthandPropertyAssignment(prop)) {
+              const fact = bindings.get(prop.name.text);
+              if (fact)
+                helpers.push({
+                  className,
+                  helperName,
+                  propertyName: prop.name.text,
+                  variableName: prop.name.text,
+                  fact,
+                  sourceLine: lineOf4(sf, prop)
+                });
+            }
+            if (ts3.isPropertyAssignment(prop) && ts3.isIdentifier(prop.initializer)) {
+              const propertyName = ts3.isIdentifier(prop.name) || ts3.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+              const fact = propertyName ? bindings.get(prop.initializer.text) : void 0;
+              if (propertyName && fact)
+                helpers.push({
+                  className,
+                  helperName,
+                  propertyName,
+                  variableName: prop.initializer.text,
+                  fact,
+                  sourceLine: lineOf4(sf, prop)
+                });
+            }
+          }
+        }
+        ts3.forEachChild(node, visit2);
+      };
+      var visit = visit2;
+      if (!ts3.isPropertyDeclaration(member) || !member.initializer) continue;
+      if (!ts3.isIdentifier(member.name)) continue;
+      const className = stmt.name.text;
+      const helperName = member.name.text;
+      const initializer = member.initializer;
+      if (!ts3.isArrowFunction(initializer) && !ts3.isFunctionExpression(initializer))
+        continue;
+      const bindings = /* @__PURE__ */ new Map();
+      visit2(initializer);
+    }
+  }
+  return helpers;
+}
 
 // src/linker/dynamic-edge-resolver.ts
 function applyVariables(template, vars) {
@@ -749,6 +895,13 @@ function rows(db, operationPath, workspaceId) {
   );
 }
 function resolveOperation(db, signals, workspaceId) {
+  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath].flatMap((value) => [...(value ?? "").matchAll(/\$\{\s*(\w+)\s*\}/g)].map((match) => match[1] ?? "")).filter(Boolean);
+  if (missing.length > 0)
+    return {
+      status: "dynamic",
+      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId) : [],
+      reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
+    };
   if (!signals.operationPath)
     return {
       status: "unresolved",
@@ -800,7 +953,7 @@ function resolveOperation(db, signals, workspaceId) {
       candidates,
       reasons: ["operation_path_only_has_no_strong_target_signal"]
     };
-  if (best && best.score >= 0.9 && (!second || best.score - second.score >= 0.25))
+  if (best && best.score >= 0.9 && best.servicePath === signals.servicePath && (best.operationPath === signals.operationPath || best.operationName === signals.operationPath.replace(/^\//, "")) && (!second || best.score - second.score >= 0.25))
     return {
       status: "resolved",
       target: best,
@@ -847,90 +1000,105 @@ function linkHelperPackages(db, workspaceId) {
 
 // src/linker/cross-repo-linker.ts
 function linkWorkspace(db, workspaceId, vars = {}) {
-  db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
-  let edges = linkHelperPackages(db, workspaceId);
-  let unresolved = 0;
-  const calls = db.prepare(
-    `SELECT c.*,r.name repoName,b.alias,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`
-  ).all(workspaceId);
-  for (const call of calls) {
-    const callType = String(call.call_type);
-    const op = applyVariables(String(call.operation_path_expr ?? ""), vars);
-    const servicePath = applyVariables(
-      call.servicePathExpr ?? call.requireServicePath,
-      vars
-    );
-    const destination = call.destinationExpr ?? call.requireDestination;
-    const isDynamic = Boolean(Number(call.isDynamic ?? 0));
-    const resolution = callType.startsWith("remote") ? resolveOperation(
-      db,
-      {
+  return db.transaction(() => {
+    db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
+    let edges = linkHelperPackages(db, workspaceId);
+    let unresolved = 0;
+    let resolvedCount = 0;
+    let ambiguousCount = 0;
+    let dynamicCount = 0;
+    let terminalCount = 0;
+    const calls = db.prepare(
+      `SELECT c.*,r.name repoName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`
+    ).all(workspaceId);
+    for (const call of calls) {
+      const callType = String(call.call_type);
+      const op = applyVariables(String(call.operation_path_expr ?? ""), vars);
+      const servicePath = applyVariables(
+        call.servicePathExpr ?? call.requireServicePath,
+        vars
+      );
+      const destination = call.destinationExpr ?? call.requireDestination;
+      const isDynamic = Boolean(Number(call.isDynamic ?? 0));
+      const resolution = callType.startsWith("remote") ? resolveOperation(
+        db,
+        {
+          servicePath,
+          operationPath: op,
+          alias: applyVariables(call.aliasExpr ?? call.alias, vars),
+          destination: applyVariables(destination, vars),
+          isDynamic,
+          hasExplicitOverride: Object.keys(vars).length > 0
+        },
+        workspaceId
+      ) : { status: "unresolved", candidates: [], reasons: [] };
+      const target = resolution.target;
+      const evidence = {
+        sourceFile: call.source_file,
+        sourceLine: call.source_line,
+        file: call.source_file,
+        line: call.source_line,
+        repo: call.repoName,
+        serviceAlias: call.alias,
+        serviceAliasExpr: call.aliasExpr,
+        destination: applyVariables(destination, vars),
         servicePath,
         operationPath: op,
-        alias: call.alias,
-        destination,
-        isDynamic,
-        hasExplicitOverride: Object.keys(vars).length > 0
-      },
-      workspaceId
-    ) : { status: "unresolved", candidates: [], reasons: [] };
-    const target = resolution.target;
-    const evidence = {
-      sourceFile: call.source_file,
-      sourceLine: call.source_line,
-      file: call.source_file,
-      line: call.source_line,
-      repo: call.repoName,
-      serviceAlias: call.alias,
-      destination,
-      servicePath,
-      operationPath: op,
-      targetRepo: target?.repoName,
-      targetOperation: target?.operationName,
-      helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0,
-      candidates: resolution.candidates,
-      candidateCount: resolution.candidates.length,
-      resolutionStatus: resolution.status,
-      resolutionReasons: resolution.reasons
-    };
-    if (target) {
-      db.prepare(
-        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic) VALUES(?,?,?,?,?,?,?,?,?)"
-      ).run(
-        workspaceId,
-        "REMOTE_CALL_RESOLVES_TO_OPERATION",
-        "call",
-        String(call.id),
-        "operation",
-        String(target.operationId),
-        target.score,
-        JSON.stringify(evidence),
-        isDynamic ? 1 : 0
-      );
-      edges += 1;
-    } else {
-      const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
-      db.prepare(
-        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?)"
-      ).run(
-        workspaceId,
-        edgeType,
-        "call",
-        String(call.id),
-        callType.startsWith("async_") ? "event" : "external",
-        String(call.event_name_expr ?? call.query_entity ?? op ?? call.id),
-        Number(call.confidence ?? 0.2),
-        JSON.stringify(evidence),
-        isDynamic || resolution.status === "dynamic" ? 1 : 0,
-        String(
-          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? "Dynamic target requires runtime variable overrides" : "No indexed target operation matched")
-        )
-      );
-      edges += 1;
-      unresolved += edgeType === "UNRESOLVED_EDGE" ? 1 : 0;
+        targetRepo: target?.repoName,
+        targetOperation: target?.operationName,
+        helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0,
+        candidates: resolution.candidates,
+        candidateCount: resolution.candidates.length,
+        resolutionStatus: resolution.status,
+        resolutionReasons: resolution.reasons
+      };
+      if (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) VALUES(?,?,?,?,?,?,?,?,?,?)"
+        ).run(
+          workspaceId,
+          "REMOTE_CALL_RESOLVES_TO_OPERATION",
+          "resolved",
+          "call",
+          String(call.id),
+          "operation",
+          String(target.operationId),
+          target.score,
+          JSON.stringify(evidence),
+          isDynamic ? 1 : 0
+        );
+        edges += 1;
+        resolvedCount += 1;
+      } else {
+        const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
+        const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
+        const unresolvedReason = status === "terminal" ? null : String(
+          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}` : "No indexed target operation matched")
+        );
+        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) VALUES(?,?,?,?,?,?,?,?,?,?,?)"
+        ).run(
+          workspaceId,
+          edgeType,
+          status,
+          "call",
+          String(call.id),
+          callType.startsWith("async_") ? "event" : "external",
+          String(call.event_name_expr ?? call.query_entity ?? op ?? call.id),
+          Number(call.confidence ?? 0.2),
+          JSON.stringify(evidence),
+          isDynamic || resolution.status === "dynamic" ? 1 : 0,
+          unresolvedReason
+        );
+        edges += 1;
+        unresolved += status === "unresolved" ? 1 : 0;
+        ambiguousCount += status === "ambiguous" ? 1 : 0;
+        dynamicCount += status === "dynamic" ? 1 : 0;
+        terminalCount += status === "terminal" ? 1 : 0;
+      }
     }
-  }
-  return { edgeCount: edges, unresolvedCount: unresolved };
+    return { edgeCount: edges, unresolvedCount: unresolved, resolvedCount, ambiguousCount, dynamicCount, terminalCount };
+  });
 }
 
 // src/trace/trace-engine.ts
@@ -949,7 +1117,8 @@ function sourceFilesForStart(db, repoId, start) {
     `SELECT DISTINCT hc.source_file sourceFile
        FROM handler_classes hc LEFT JOIN handler_methods hm ON hm.handler_class_id=hc.id
        WHERE (? IS NULL OR hc.repo_id=?) AND (? IS NULL OR hc.class_name=? OR hm.method_name=?)
-         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)`
+         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)
+         AND (? IS NULL OR EXISTS (SELECT 1 FROM cds_services s JOIN cds_operations o ON o.service_id=s.id WHERE s.repo_id=hc.repo_id AND s.service_path=? AND (? IS NULL OR o.operation_path=? OR o.operation_name=? OR hm.decorator_value=? OR hm.method_name=?)))`
   ).all(
     repoId,
     repoId,
@@ -958,8 +1127,16 @@ function sourceFilesForStart(db, repoId, start) {
     handler,
     operation,
     operation,
+    operation,
+    start.servicePath,
+    start.servicePath,
+    operation,
+    operation,
+    operation,
+    operation,
     operation
   );
+  if (start.servicePath && rows2.length === 0) return void 0;
   if (rows2.length === 0) return void 0;
   return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
 }
@@ -1003,7 +1180,7 @@ function graphForCalls(db, callIds) {
   if (callIds.length === 0) return map;
   const rows2 = db.prepare(
     `SELECT * FROM graph_edges WHERE from_kind='call' AND from_id IN (${callIds.map(() => "?").join(",")}) ORDER BY id`
-  ).all(...callIds);
+  ).all(...callIds.map((id) => String(id)));
   for (const row of rows2) {
     const id = Number(row.from_id);
     map.set(id, [...map.get(id) ?? [], row]);
@@ -1035,6 +1212,30 @@ function evidenceWithRuntimeVariables(evidence, vars) {
     } : void 0
   };
 }
+function operationNode(db, operationId) {
+  const row = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_type operationType,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.id serviceId,s.service_name serviceName,s.qualified_name qualifiedName,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 o.id=?`).get(operationId);
+  if (!row) return void 0;
+  return { id: `operation:${operationId}`, kind: "operation", label: `${String(row.repoName)}:${String(row.servicePath)}${String(row.operationPath)}`, ...row };
+}
+function workspaceIdForCall(db, callId) {
+  return db.prepare("SELECT r.workspace_id workspaceId FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE c.id=?").get(callId)?.workspaceId;
+}
+function runtimeResolution(db, row, evidence, vars) {
+  if (!vars || Object.keys(vars).length === 0) return { row, evidence, unresolvedReason: row.unresolved_reason };
+  const nextEvidence = evidenceWithRuntimeVariables(evidence, vars);
+  const servicePath = typeof nextEvidence.servicePath === "string" ? nextEvidence.servicePath : void 0;
+  const operationPath = typeof nextEvidence.operationPath === "string" ? nextEvidence.operationPath : void 0;
+  const alias = typeof nextEvidence.serviceAliasExpr === "string" ? applyVariables(nextEvidence.serviceAliasExpr, vars) : typeof nextEvidence.serviceAlias === "string" ? applyVariables(nextEvidence.serviceAlias, vars) : void 0;
+  const destination = typeof nextEvidence.destination === "string" ? applyVariables(nextEvidence.destination, vars) : void 0;
+  const resolution = resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: Boolean(row.status === "dynamic" || nextEvidence.resolutionStatus === "dynamic") }, workspaceIdForCall(db, row.from_id));
+  nextEvidence.runtimeResolutionStatus = resolution.status;
+  nextEvidence.runtimeResolutionReasons = resolution.reasons;
+  if (resolution.target) {
+    nextEvidence.runtimeResolvedCandidate = resolution.target;
+    return { row: { ...row, to_kind: "operation", to_id: String(resolution.target.operationId), unresolved_reason: void 0, confidence: resolution.target.score }, evidence: nextEvidence, target: resolution.target };
+  }
+  return { row, evidence: nextEvidence, 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" };
+}
 function edgeTarget(row, evidence) {
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
@@ -1095,33 +1296,32 @@ function trace(db, start, options) {
         const rawEvidence = JSON.parse(
           String(row.evidence_json || "{}")
         );
-        const evidence = evidenceWithRuntimeVariables(
-          rawEvidence,
-          options.vars
-        );
-        const targetNode = `${row.to_kind}:${row.to_id}`;
-        nodes.set(targetNode, {
+        const effective = runtimeResolution(db, row, rawEvidence, options.vars);
+        const evidence = effective.evidence;
+        const effectiveRow = effective.row;
+        const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
+        const opNode = effectiveRow.to_kind === "operation" ? operationNode(db, effectiveRow.to_id) : void 0;
+        nodes.set(targetNode, opNode ?? {
           id: targetNode,
-          kind: row.to_kind,
-          label: row.to_id,
-          ...evidence
+          kind: effectiveRow.to_kind,
+          label: effectiveRow.to_id
         });
-        const to = edgeTarget(row, evidence);
+        const to = edgeTarget(effectiveRow, evidence);
         edges.push({
           step: current.depth,
           type: String(call.call_type),
           from: `${call.repoName}:${call.source_file}`,
           to,
           evidence,
-          confidence: Number(row.confidence ?? call.confidence),
-          unresolvedReason: row.unresolved_reason
+          confidence: Number(effectiveRow.confidence ?? call.confidence),
+          unresolvedReason: effective.unresolvedReason
         });
-        if (row.to_kind === "operation" && current.depth < maxDepth) {
-          const files = handlerFilesForOperation(db, row.to_id);
+        if (effectiveRow.to_kind === "operation" && current.depth < maxDepth) {
+          const files = handlerFilesForOperation(db, effectiveRow.to_id);
           if (files.size > 0) {
             const targetRepoId = db.prepare(
               "SELECT s.repo_id repoId FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?"
-            ).get(row.to_id)?.repoId;
+            ).get(effectiveRow.to_id)?.repoId;
             const nextKey = `${targetRepoId ?? "*"}:${[...files].sort().join(",")}`;
             if (seenScopes.has(nextKey))
               edges.push({
@@ -1163,4 +1363,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-SIKIGT42.js.map
+//# sourceMappingURL=chunk-I33ASGX3.js.map