@saptools/service-flow 0.1.50 → 0.1.51

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

@@ -2842,8 +2842,8 @@ function buildRemoteQueryTarget(input) {
 // src/linker/service-resolver.ts
 function rows(db, operationPath, workspaceId) {
   const names = operationLookupNames(operationPath);
-  return db.prepare(
-    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score,'' reasons
+  const result = db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score
        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.workspace_id=?) AND (o.operation_path IN (?,?) OR o.operation_name IN (?,?)) ORDER BY r.name,s.service_path,o.operation_name`
   ).all(
@@ -2854,6 +2854,11 @@ function rows(db, operationPath, workspaceId) {
     names.name,
     names.simpleName
   );
+  return result.map((row) => ({
+    ...row,
+    score: Number(row.score ?? 0),
+    reasons: []
+  }));
 }
 function operationLookupNames(operationPath) {
   const name = operationPath.replace(/^\//, "");
@@ -2870,7 +2875,11 @@ function resolveOperation(db, signals, workspaceId) {
   if (missing.length > 0)
     return {
       status: "dynamic",
-      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId) : [],
+      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId).map((candidate) => ({
+        ...candidate,
+        score: 0.2,
+        reasons: ["operation_path_match"]
+      })) : [],
       reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
     };
   if (!signals.operationPath)
@@ -3233,7 +3242,13 @@ function compactCandidateScores(candidates) {
   return candidates.flatMap((candidate) => {
     const row = objectValue(candidate);
     if (!row) return [];
-    return [{ repo: row.repoName, servicePath: row.servicePath, operationPath: row.operationPath, score: row.score, reasons: row.reasons }];
+    return [{
+      repo: row.repoName,
+      servicePath: row.servicePath,
+      operationPath: row.operationPath,
+      score: row.score,
+      reasons: Array.isArray(row.reasons) ? row.reasons.filter((reason) => typeof reason === "string") : ["operation_path_match"]
+    }];
   });
 }
 function placeholderKeys(values) {
@@ -3642,6 +3657,303 @@ function fullSelectorSuggestions(candidates) {
   }))].sort();
 }
 
+// src/trace/dynamic-targets.ts
+function analyzeDynamicTargetCandidates(db, evidence, workspaceId, mode, maxCandidates) {
+  const templates = templatesFromEvidence(evidence);
+  const missingVariables = allMissingVariables(evidence, templates);
+  if (missingVariables.length === 0) return void 0;
+  const order = variableOrder(templates, missingVariables);
+  const candidates = rankedCandidates(
+    db,
+    candidateTargets(db, evidence, workspaceId),
+    referenceRows(db, workspaceId),
+    templates,
+    order
+  );
+  const inference = inferenceDecision(candidates);
+  const shownCandidates = candidates.slice(0, maxCandidates);
+  return {
+    mode,
+    candidateCount: candidates.length,
+    shownCandidateCount: shownCandidates.length,
+    omittedCandidateCount: Math.max(0, candidates.length - shownCandidates.length),
+    missingVariables,
+    candidates,
+    shownCandidates,
+    suggestedVarSets: suggestedVarSets(candidates, missingVariables, order),
+    inference
+  };
+}
+function candidateTargets(db, evidence, workspaceId) {
+  const embedded = rowsFromEvidence(evidence.candidates);
+  if (embedded.length > 0) return embedded;
+  const operationPath = stringValue4(evidence.operationPath);
+  if (!operationPath || extractPlaceholders(operationPath).length > 0) return [];
+  return queryOperationTargets(db, operationPath, workspaceId);
+}
+function rowsFromEvidence(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const row = record(item);
+    const operationId = numberValue(row.operationId);
+    const repoName = stringValue4(row.repoName);
+    const servicePath = stringValue4(row.servicePath);
+    const operationPath = stringValue4(row.operationPath);
+    const operationName = stringValue4(row.operationName) ?? operationPath?.replace(/^\//, "");
+    if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName) return [];
+    return [{
+      operationId,
+      repoName,
+      serviceName: stringValue4(row.serviceName) ?? "",
+      qualifiedName: stringValue4(row.qualifiedName) ?? "",
+      servicePath,
+      operationPath,
+      operationName,
+      sourceFile: stringValue4(row.sourceFile) ?? "",
+      sourceLine: numberValue(row.sourceLine) ?? 0,
+      repoId: numberValue(row.repoId),
+      packageName: stringValue4(row.packageName),
+      score: numberValue(row.score) ?? 0,
+      reasons: stringArray(row.reasons)
+    }];
+  });
+}
+function queryOperationTargets(db, operationPath, workspaceId) {
+  const simple = operationPath.replace(/^\//, "").split(".").at(-1) ?? operationPath;
+  const rows2 = db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,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 r.workspace_id=?)
+       AND (o.operation_path IN (?,?) OR o.operation_name=?)
+     ORDER BY r.name,s.service_path,o.operation_name`
+  ).all(workspaceId, workspaceId, operationPath, `/${simple}`, simple);
+  return rows2.map((row) => ({
+    operationId: Number(row.operationId),
+    repoId: numberValue(row.repoId),
+    repoName: String(row.repoName),
+    packageName: stringValue4(row.packageName),
+    serviceName: String(row.serviceName),
+    qualifiedName: String(row.qualifiedName),
+    servicePath: String(row.servicePath),
+    operationPath: String(row.operationPath),
+    operationName: String(row.operationName),
+    sourceFile: String(row.sourceFile),
+    sourceLine: Number(row.sourceLine),
+    score: 0.2,
+    reasons: ["operation_path_match"]
+  }));
+}
+function rankedCandidates(db, candidates, references, templates, order) {
+  const ranked = candidates.map((candidate) => candidateEvidence2(db, candidate, references, templates, order));
+  return ranked.sort((a, b) => b.score - a.score || a.repoName.localeCompare(b.repoName) || a.servicePath.localeCompare(b.servicePath));
+}
+function candidateEvidence2(db, candidate, references, templates, order) {
+  const state = emptyCandidate(candidate);
+  applyDirectTemplate(state, templates.operationPath, candidate.operationPath, "operation_path");
+  applyDirectTemplate(state, templates.servicePath, candidate.servicePath, "service_path");
+  const refs = references.filter((item) => item.servicePath === candidate.servicePath);
+  applyReferenceTemplate(state, templates.alias, refs, "alias");
+  applyReferenceTemplate(state, templates.destination, refs, "destination");
+  if (hasResolvedImplementation(db, candidate.operationId)) addScore(state, 0.1, "implementation_edge_resolved");
+  state.missingVariables = order.filter((key) => state.derivedVariables[key] === void 0);
+  if (state.missingVariables.length === 0) addScore(state, 0.15, "all_runtime_variables_derived");
+  else state.rejectedReasons.push("missing_required_runtime_variable");
+  state.score = Math.max(0, Math.min(1, state.score));
+  state.cli = state.missingVariables.length === 0 ? cliFor(state.derivedVariables, order) : void 0;
+  return state;
+}
+function emptyCandidate(candidate) {
+  return {
+    candidateOperationId: candidate.operationId,
+    repoName: candidate.repoName,
+    packageName: candidate.packageName ?? void 0,
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    operationName: candidate.operationName,
+    derivedVariables: {},
+    derivedVariableSources: {},
+    missingVariables: [],
+    score: Math.max(0.2, Number(candidate.score ?? 0)),
+    reasons: nonEmptyStrings(candidate.reasons, ["operation_path_match"]),
+    rejectedReasons: []
+  };
+}
+function applyDirectTemplate(state, template, concrete, kind) {
+  const matched = matchTemplate(template, concrete);
+  if (!template) return;
+  if (!matched) {
+    state.rejectedReasons.push(`${kind}_template_mismatch`);
+    return;
+  }
+  mergeDerived(state, matched, `${kind}_template`);
+  addScore(state, kind === "service_path" ? 0.35 : 0.25, `${kind}_template_match`);
+}
+function applyReferenceTemplate(state, template, refs, kind) {
+  if (!template || extractPlaceholders(template).length === 0) return;
+  for (const ref of refs) {
+    const concrete = kind === "alias" ? ref.alias : ref.destination;
+    const matched = isConcrete(concrete) ? matchTemplate(template, concrete) : void 0;
+    if (!matched) continue;
+    mergeDerived(state, matched, `${ref.sourceKind}.${kind}`);
+    addScore(state, 0.2, `${kind}_template_match`);
+    return;
+  }
+  if (refs.some((ref) => isConcrete(kind === "alias" ? ref.alias : ref.destination)))
+    state.rejectedReasons.push(`${kind}_template_mismatch`);
+}
+function inferenceDecision(candidates) {
+  const complete = candidates.filter((candidate) => candidate.missingVariables.length === 0 && candidate.rejectedReasons.length === 0);
+  const first = complete[0];
+  const second = complete[1];
+  if (!first) return { status: "unresolved", reason: "missing_required_runtime_variable" };
+  if (first.score < 0.85) return { status: "unresolved", reason: "candidate_score_below_inference_threshold" };
+  if (second && first.score - second.score <= 0.05) {
+    for (const candidate of complete.filter((item) => first.score - item.score <= 0.05))
+      candidate.rejectedReasons.push("candidate_tied_with_equal_score");
+    return { status: "ambiguous", reason: "candidate_tied_with_equal_score" };
+  }
+  return {
+    status: "resolved",
+    candidateOperationId: first.candidateOperationId,
+    inferredVariables: first.derivedVariables,
+    score: first.score,
+    reasons: first.reasons
+  };
+}
+function suggestedVarSets(candidates, required, order) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.flatMap((candidate) => {
+    if (required.some((key) => candidate.derivedVariables[key] === void 0)) return [];
+    const cli = cliFor(candidate.derivedVariables, order);
+    if (seen.has(cli)) return [];
+    seen.add(cli);
+    return [{ variables: candidate.derivedVariables, cli }];
+  });
+}
+function referenceRows(db, workspaceId) {
+  const rows2 = db.prepare(
+    `SELECT req.alias alias,req.destination destination,req.service_path servicePath,
+      'cds_require' sourceKind,r.name repoName
+     FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+     UNION ALL
+     SELECT COALESCE(b.alias,b.alias_expr) alias,b.destination_expr destination,
+      b.service_path_expr servicePath,'service_binding' sourceKind,r.name repoName
+     FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)`
+  ).all(workspaceId, workspaceId, workspaceId, workspaceId);
+  return rows2.map((row) => ({
+    alias: stringValue4(row.alias),
+    destination: stringValue4(row.destination),
+    servicePath: stringValue4(row.servicePath),
+    sourceKind: String(row.sourceKind),
+    repoName: String(row.repoName)
+  }));
+}
+function allMissingVariables(evidence, templates) {
+  const fromSubstitutions = Object.values(record(evidence.runtimeSubstitutions)).flatMap((value) => stringArray(record(value).missing));
+  const fromTemplates = [
+    templates.servicePath,
+    templates.operationPath,
+    templates.alias,
+    templates.destination
+  ].flatMap((value) => extractPlaceholders(value));
+  return [.../* @__PURE__ */ new Set([...fromSubstitutions, ...fromTemplates])].sort();
+}
+function variableOrder(templates, missingVariables) {
+  const ordered = [
+    templates.servicePath,
+    templates.operationPath,
+    templates.alias,
+    templates.destination
+  ].flatMap((value) => extractPlaceholders(value));
+  return [.../* @__PURE__ */ new Set([...ordered, ...missingVariables])];
+}
+function templatesFromEvidence(evidence) {
+  return {
+    servicePath: stringValue4(evidence.servicePath),
+    operationPath: stringValue4(evidence.operationPath),
+    alias: stringValue4(evidence.serviceAliasExpr ?? evidence.serviceAlias),
+    destination: stringValue4(evidence.destination)
+  };
+}
+function matchTemplate(template, concrete) {
+  if (!template || !concrete) return void 0;
+  const keys = extractPlaceholders(template);
+  if (keys.length === 0) return template === concrete ? {} : void 0;
+  const regex = new RegExp(`^${templateToPattern(template)}$`);
+  const match = regex.exec(concrete);
+  if (!match) return void 0;
+  const values = {};
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    const value = match[index + 1];
+    if (!key || value === void 0) return void 0;
+    if (values[key] !== void 0 && values[key] !== value) return void 0;
+    values[key] = value;
+  }
+  return values;
+}
+function templateToPattern(template) {
+  let pattern = "";
+  let lastIndex = 0;
+  for (const match of template.matchAll(/\$\{([^}]*)\}/g)) {
+    pattern += escapeRegex(template.slice(lastIndex, match.index));
+    pattern += "([^/]+?)";
+    lastIndex = (match.index ?? 0) + match[0].length;
+  }
+  return `${pattern}${escapeRegex(template.slice(lastIndex))}`;
+}
+function mergeDerived(state, values, sourceKind) {
+  for (const [key, value] of Object.entries(values)) {
+    if (state.derivedVariables[key] !== void 0 && state.derivedVariables[key] !== value) {
+      state.rejectedReasons.push("template_variable_conflict");
+      continue;
+    }
+    state.derivedVariables[key] = value;
+    state.derivedVariableSources[key] = { sourceKind, value };
+  }
+}
+function addScore(state, amount, reason) {
+  state.score += amount;
+  if (!state.reasons.includes(reason)) state.reasons.push(reason);
+}
+function hasResolvedImplementation(db, operationId) {
+  const row = db.prepare(
+    "SELECT 1 FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND status='resolved' AND from_kind='operation' AND from_id=? LIMIT 1"
+  ).get(String(operationId));
+  return Boolean(row);
+}
+function cliFor(variables, order) {
+  return order.filter((key) => variables[key] !== void 0).map((key) => `--var ${key}=${variables[key]}`).join(" ");
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue4(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function nonEmptyStrings(value, fallback) {
+  const values = stringArray(value).filter((item) => item.length > 0);
+  return values.length > 0 ? values : fallback;
+}
+function isConcrete(value) {
+  return typeof value === "string" && value.length > 0 && extractPlaceholders(value).length === 0;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/trace/evidence.ts
 function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
   const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
@@ -3660,23 +3972,45 @@ function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
     persistedResolution: persistedResolution(row)
   };
 }
-function runtimeResolution(db, row, evidence, vars, workspaceId, contextualUnresolvedReason) {
-  const substituted = evidenceWithRuntimeVariables(evidence, vars);
-  if (!isRemoteRuntimeCandidate(row, evidence, vars)) {
+function runtimeResolution(db, row, evidence, options, workspaceId, contextualUnresolvedReason) {
+  const substituted = evidenceWithRuntimeVariables(evidence, options.vars);
+  const dynamicMode = options.dynamicMode ?? "strict";
+  const analysis = analyzeDynamicTargetCandidates(
+    db,
+    substituted,
+    workspaceId,
+    dynamicMode,
+    positiveCandidateCap(options.maxDynamicCandidates)
+  );
+  const enriched = analysis ? evidenceWithDynamicAnalysis(substituted, analysis) : substituted;
+  if (dynamicMode === "infer") {
+    const inferred = inferredTarget(analysis);
+    if (inferred) {
+      const resolvedRow = { ...row, status: "resolved", to_kind: "operation", to_id: String(inferred.operationId), unresolved_reason: void 0, confidence: inferred.score };
+      const resolution2 = { status: "resolved", target: inferred, candidates: [], reasons: inferred.reasons };
+      return { row: resolvedRow, evidence: withEffectiveResolution(enriched, resolvedRow, void 0, resolution2), target: inferred };
+    }
+  }
+  if (!isRemoteRuntimeCandidate(row, evidence, options.vars)) {
     const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason;
-    const withSections = withEffectiveResolution(substituted, row, unresolvedReason2);
+    const withSections = withEffectiveResolution(enriched, row, unresolvedReason2);
     return { row, evidence: withSections, unresolvedReason: unresolvedReason2 };
   }
-  const resolution = resolveRuntimeOperation(db, substituted, workspaceId);
+  const resolution = resolveRuntimeOperation(db, enriched, workspaceId);
   if (resolution.target) {
     const resolvedRow = { ...row, status: "resolved", to_kind: "operation", to_id: String(resolution.target.operationId), unresolved_reason: void 0, confidence: Math.max(0, Math.min(1, resolution.target.score)) };
-    return { row: resolvedRow, evidence: withEffectiveResolution(substituted, resolvedRow, void 0, resolution), target: resolution.target };
+    return { row: resolvedRow, evidence: withEffectiveResolution(enriched, resolvedRow, void 0, resolution), target: resolution.target };
   }
   const unresolvedReason = runtimeUnresolvedReason(resolution);
-  return { row, evidence: withEffectiveResolution(substituted, row, unresolvedReason, resolution), unresolvedReason };
+  return { row, evidence: withEffectiveResolution(enriched, row, unresolvedReason, resolution), unresolvedReason };
 }
 function runtimeVariableDiagnostic(edges) {
   const missing = /* @__PURE__ */ new Set();
+  let candidateCount = 0;
+  let shownCandidateCount = 0;
+  let omittedCandidateCount = 0;
+  const candidateSuggestions = [];
+  const suggestedVarSets2 = [];
   for (const edge of edges) {
     const effective = parseObject(edge.evidence.effectiveResolution);
     if (!["dynamic", "unresolved", "ambiguous"].includes(String(effective.status ?? "")))
@@ -3685,6 +4019,12 @@ function runtimeVariableDiagnostic(edges) {
     if (!substitutions || typeof substitutions !== "object" || Array.isArray(substitutions)) continue;
     for (const value of Object.values(substitutions))
       for (const key of value.missing ?? []) missing.add(key);
+    const exploration = parseObject(edge.evidence.dynamicTargetExploration);
+    candidateCount += numeric(exploration.candidateCount);
+    shownCandidateCount += numeric(exploration.shownCandidateCount);
+    omittedCandidateCount += numeric(exploration.omittedCandidateCount);
+    candidateSuggestions.push(...recordArray(edge.evidence.dynamicTargetCandidateSuggestions));
+    suggestedVarSets2.push(...recordArray(exploration.suggestedVarSets));
   }
   const missingVariables = [...missing].sort();
   if (missingVariables.length === 0) return void 0;
@@ -3693,25 +4033,34 @@ function runtimeVariableDiagnostic(edges) {
     code: "trace_runtime_variables_missing",
     message: `Runtime variables are required to resolve dynamic trace targets: ${missingVariables.join(", ")}`,
     missingVariables,
-    suggestions: missingVariables.map((key) => `--var ${key}=<value>`)
+    suggestions: missingVariables.map((key) => `--var ${key}=<value>`),
+    candidateCount,
+    shownCandidateCount,
+    omittedCandidateCount,
+    candidateSuggestions: candidateSuggestions.slice(0, 5),
+    suggestedVarSets: uniqueCliRows(suggestedVarSets2).slice(0, 5),
+    copyableExamples: [
+      ...uniqueCliRows(suggestedVarSets2).slice(0, 3).flatMap((row) => typeof row.cli === "string" ? [row.cli] : []),
+      ...candidateCount > 0 ? ["--dynamic-mode candidates --max-dynamic-candidates 20"] : []
+    ]
   };
 }
 function edgeTarget(row, evidence) {
   const effective = parseObject(evidence.effectiveResolution);
-  const targetServicePath = stringValue4(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue4(effective.targetOperationPath ?? evidence.targetOperationPath);
+  const targetServicePath = stringValue5(effective.targetServicePath ?? evidence.targetServicePath);
+  const targetOperationPath = stringValue5(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 = stringValue4(evidence.servicePath);
-  const operationPath = stringValue4(evidence.operationPath);
-  const targetOperation = stringValue4(evidence.targetOperation);
-  const targetRepo = stringValue4(evidence.targetRepo) ?? "";
+  const servicePath = stringValue5(evidence.servicePath);
+  const operationPath = stringValue5(evidence.operationPath);
+  const targetOperation = stringValue5(evidence.targetOperation);
+  const targetRepo = stringValue5(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 stringValue4(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
+  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue5(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
   if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
     const target = parseObject(evidence.externalTarget);
-    return stringValue4(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
+    return stringValue5(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
   }
   if (servicePath && operationPath) return `${servicePath}${operationPath}`;
   return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
@@ -3750,12 +4099,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 = stringValue4(evidence.servicePath);
-  const rawOperationPath = stringValue4(evidence.operationPath);
+  const servicePath = stringValue5(evidence.servicePath);
+  const rawOperationPath = stringValue5(evidence.operationPath);
   const normalized = normalizeODataOperationInvocationPath(rawOperationPath);
-  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue4(evidence.normalizedOperationPath) ?? rawOperationPath;
-  const alias = stringValue4(evidence.serviceAliasExpr ?? evidence.serviceAlias);
-  const destination = stringValue4(evidence.destination);
+  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue5(evidence.normalizedOperationPath) ?? rawOperationPath;
+  const alias = stringValue5(evidence.serviceAliasExpr ?? evidence.serviceAlias);
+  const destination = stringValue5(evidence.destination);
   return resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceId);
 }
 function evidenceWithRuntimeVariables(evidence, vars) {
@@ -3767,6 +4116,22 @@ function evidenceWithRuntimeVariables(evidence, vars) {
   if (Object.keys(vars ?? {}).length > 0) next.runtimeVariablesApplied = true;
   return next;
 }
+function evidenceWithDynamicAnalysis(evidence, analysis) {
+  return {
+    ...evidence,
+    dynamicTargetExploration: {
+      mode: analysis.mode,
+      missingVariables: analysis.missingVariables,
+      candidateCount: analysis.candidateCount,
+      shownCandidateCount: analysis.shownCandidateCount,
+      omittedCandidateCount: analysis.omittedCandidateCount,
+      suggestedVarSets: analysis.suggestedVarSets
+    },
+    dynamicTargetCandidates: analysis.candidates,
+    dynamicTargetCandidateSuggestions: analysis.shownCandidates,
+    dynamicTargetInference: analysis.inference
+  };
+}
 function runtimeSubstitutions(evidence, vars) {
   const substitutions = {};
   for (const key of ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"]) {
@@ -3776,7 +4141,7 @@ function runtimeSubstitutions(evidence, vars) {
   return substitutions;
 }
 function substitutionValue(evidence, key) {
-  const value = stringValue4(evidence[key]);
+  const value = stringValue5(evidence[key]);
   if (key !== "operationPath") return value;
   const normalized = normalizeODataOperationInvocationPath(value);
   return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
@@ -3787,6 +4152,29 @@ function isRemoteRuntimeCandidate(row, evidence, vars) {
   if (!["DYNAMIC_EDGE_CANDIDATE", "UNRESOLVED_EDGE", "REMOTE_CALL_RESOLVES_TO_OPERATION"].includes(row.edge_type)) return false;
   return ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"].some((key) => hasRuntimeVariable(evidence[key], vars));
 }
+function inferredTarget(analysis) {
+  if (analysis?.inference.status !== "resolved") return void 0;
+  const id = Number(analysis.inference.candidateOperationId);
+  const candidate = analysis.candidates.find((item) => item.candidateOperationId === id);
+  if (!candidate) return void 0;
+  return targetFromCandidate(candidate);
+}
+function targetFromCandidate(candidate) {
+  return {
+    operationId: candidate.candidateOperationId,
+    repoName: candidate.repoName,
+    serviceName: "",
+    qualifiedName: "",
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    operationName: candidate.operationName,
+    packageName: candidate.packageName,
+    score: candidate.score,
+    reasons: candidate.reasons,
+    sourceFile: "",
+    sourceLine: 0
+  };
+}
 function hasRuntimeVariable(value, vars) {
   return typeof value === "string" && extractPlaceholders(value).some((key) => Object.hasOwn(vars, key));
 }
@@ -3798,9 +4186,56 @@ function runtimeUnresolvedReason(resolution) {
 function parseObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue4(value) {
+function stringValue5(value) {
   return typeof value === "string" ? value : void 0;
 }
+function numeric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function uniqueCliRows(rows2) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows2.filter((row) => {
+    const cli = typeof row.cli === "string" ? row.cli : JSON.stringify(row);
+    if (seen.has(cli)) return false;
+    seen.add(cli);
+    return true;
+  });
+}
+function positiveCandidateCap(value) {
+  return Number.isFinite(value) && Number(value) > 0 ? Math.floor(Number(value)) : 5;
+}
+
+// src/trace/dynamic-branches.ts
+function dynamicCandidateBranches(depth, call, evidence) {
+  const exploration = objectRecord(evidence.dynamicTargetExploration);
+  return recordArray2(evidence.dynamicTargetCandidateSuggestions).map((candidate) => ({
+    step: depth,
+    type: "dynamic_candidate_branch",
+    from: `${call.repoName}:${call.source_file}:${call.source_line}`,
+    to: `${String(candidate.servicePath ?? "")}${String(candidate.operationPath ?? "")}`,
+    evidence: {
+      ...candidate,
+      exploratory: true,
+      dynamicMode: String(exploration.mode ?? "candidates"),
+      selected: false,
+      omittedCandidateCount: numericValue(exploration.omittedCandidateCount)
+    },
+    confidence: numericValue(candidate.score),
+    unresolvedReason: "Exploratory dynamic target candidate; provide runtime variables to select it"
+  }));
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function recordArray2(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 
 // src/trace/trace-engine.ts
 function normalizeOperation(value) {
@@ -4269,7 +4704,11 @@ 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)), contextual.unresolvedReason);
+        const effective = runtimeResolution(db, row, rawEvidence, {
+          vars: options.vars,
+          dynamicMode: options.dynamicMode ?? "strict",
+          maxDynamicCandidates: options.maxDynamicCandidates
+        }, workspaceIdForCall(db, String(call.id)), contextual.unresolvedReason);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
@@ -4289,6 +4728,8 @@ function trace(db, start, options) {
           confidence: Number(effectiveRow.confidence ?? call.confidence),
           unresolvedReason: effective.unresolvedReason
         });
+        if ((options.dynamicMode ?? "strict") === "candidates")
+          edges.push(...dynamicCandidateBranches(current.depth, call, evidence));
         if (effectiveRow.to_kind === "operation") {
           const implementation = implementationScope(db, effectiveRow.to_id);
           const contextSelection = contextImplementationMethodId(implementation.edge, current.repoId, evidence, hintOptions);
@@ -4371,4 +4812,4 @@ export {
   parseVars,
   trace
 };
-//# sourceMappingURL=chunk-52OUS3MO.js.map
+//# sourceMappingURL=chunk-YZJKE5UX.js.map