@saptools/service-flow 0.1.49 → 0.1.51

package/dist/{chunk-XOROZHW4.js → chunk-YZJKE5UX.js}

@@ -315,6 +315,46 @@ import fs4 from "fs/promises";
 import path5 from "path";
 import ts2 from "typescript";
 
+// src/linker/operation-decorator-normalizer.ts
+function lowerFirst(value) {
+  return value ? `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}` : value;
+}
+function normalizedOperationName(value) {
+  return value.replace(/^\//, "");
+}
+function clean(value) {
+  return value.replace(/^[`'"]|[`'"]$/g, "");
+}
+function generatedOperationNameFromConstant(value) {
+  for (const prefix of ["Action", "Func"]) {
+    if (value.startsWith(prefix) && value.length > prefix.length && /^[A-Z]/.test(value.slice(prefix.length))) return lowerFirst(value.slice(prefix.length));
+  }
+  return void 0;
+}
+function resolved(value, raw) {
+  const literal2 = clean(value);
+  const generated = generatedOperationNameFromConstant(literal2);
+  return { status: "resolved", operationName: generated ?? normalizedOperationName(literal2), raw };
+}
+function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
+  if (value) return resolved(value, raw);
+  if (!raw || raw.trim().length === 0) return { status: "none", raw };
+  const expression = raw.trim();
+  const nameMatch = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(expression);
+  if (nameMatch?.[1]) return resolved(nameMatch[1], expression);
+  const stringMatch = /^String\(([A-Za-z_$][\w$]*)\)$/.exec(expression);
+  if (stringMatch?.[1]) {
+    const identifier = stringMatch[1];
+    const generated = generatedOperationNameFromConstant(identifier);
+    const normalizedCandidate2 = candidateOperation ? normalizedOperationName(candidateOperation) : void 0;
+    if (generated) return { status: "resolved", operationName: generated, raw: expression };
+    if (normalizedCandidate2 && identifier === normalizedCandidate2) return { status: "resolved", operationName: identifier, raw: expression };
+    return { status: "unsupported", raw: expression, reason: "string_wrapper_identifier_not_resolved" };
+  }
+  if (/^[`'"]/.test(expression) && !/[`'"]$/.test(expression)) return { status: "malformed", raw: expression, reason: "unterminated_literal" };
+  return { status: "unsupported", raw: expression, reason: "unsupported_decorator_expression" };
+}
+
 // src/parsers/ts-project.ts
 import ts from "typescript";
 function createSourceFile(filePath, text) {
@@ -340,16 +380,102 @@ function callName(d) {
 }
 function firstArg(d) {
   const e = d.expression;
-  return ts2.isCallExpression(e) && e.arguments[0] ? e.arguments[0].getText() : "";
+  return ts2.isCallExpression(e) ? e.arguments[0] : void 0;
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (ts2.isParenthesizedExpression(current) || ts2.isAsExpression(current) || ts2.isTypeAssertionExpression(current) || ts2.isSatisfiesExpression(current)) current = current.expression;
+  return current;
+}
+function stringValue(expression) {
+  if (!expression) return void 0;
+  const unwrapped = unwrapExpression(expression);
+  return ts2.isStringLiteralLike(unwrapped) ? unwrapped.text : void 0;
+}
+function propertyName(node) {
+  if (ts2.isIdentifier(node) || ts2.isStringLiteralLike(node)) return node.text;
+  return void 0;
+}
+function collectEnumMembers(statement, lookups) {
+  for (const member of statement.members) {
+    const name = propertyName(member.name);
+    const value = stringValue(member.initializer);
+    if (name && value !== void 0)
+      lookups.enumMembers.set(`${statement.name.text}.${name}`, value);
+  }
+}
+function collectObjectProperties(name, initializer, lookups) {
+  const object = unwrapExpression(initializer);
+  if (!ts2.isObjectLiteralExpression(object)) return;
+  for (const property of object.properties) {
+    if (!ts2.isPropertyAssignment(property)) continue;
+    const key = propertyName(property.name);
+    const value = stringValue(property.initializer);
+    if (key && value !== void 0)
+      lookups.objectProperties.set(`${name}.${key}`, value);
+  }
+}
+function collectStringLookups(source) {
+  const lookups = {
+    identifiers: /* @__PURE__ */ new Map(),
+    enumMembers: /* @__PURE__ */ new Map(),
+    objectProperties: /* @__PURE__ */ new Map()
+  };
+  for (const statement of source.statements) {
+    if (ts2.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
+    if (!ts2.isVariableStatement(statement) || !(statement.declarationList.flags & ts2.NodeFlags.Const)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts2.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      const value = stringValue(declaration.initializer);
+      if (value !== void 0) lookups.identifiers.set(declaration.name.text, value);
+      collectObjectProperties(declaration.name.text, declaration.initializer, lookups);
+    }
+  }
+  return lookups;
+}
+function unresolved(rawExpression, reason) {
+  return { rawExpression, resolutionKind: "unresolved", unresolvedReason: reason };
+}
+function generatedConstant(rawExpression) {
+  const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(rawExpression.trim());
+  return match?.[1] ? generatedOperationNameFromConstant(match[1]) : void 0;
+}
+function resolveDecoratorArgument(argument, lookups) {
+  if (!argument) return unresolved("", "decorator_argument_missing");
+  const rawExpression = argument.getText();
+  const expression = unwrapExpression(argument);
+  if (ts2.isStringLiteralLike(expression))
+    return { rawExpression, resolvedValue: expression.text, resolutionKind: "literal" };
+  if (ts2.isIdentifier(expression)) {
+    const value = lookups.identifiers.get(expression.text);
+    return value === void 0 ? unresolved(rawExpression, "identifier_not_resolved_to_local_const_string") : { rawExpression, resolvedValue: value, resolutionKind: "const_identifier" };
+  }
+  if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression)) {
+    const key = `${expression.expression.text}.${expression.name.text}`;
+    const enumValue = lookups.enumMembers.get(key);
+    if (enumValue !== void 0)
+      return { rawExpression, resolvedValue: enumValue, resolutionKind: "enum_member" };
+    const objectValue2 = lookups.objectProperties.get(key);
+    if (objectValue2 !== void 0)
+      return { rawExpression, resolvedValue: objectValue2, resolutionKind: "const_object_property" };
+  }
+  const generatedValue = generatedConstant(rawExpression);
+  if (generatedValue !== void 0)
+    return {
+      rawExpression,
+      resolvedValue: generatedValue,
+      resolutionKind: "generated_constant_name"
+    };
+  if (ts2.isPropertyAccessExpression(expression))
+    return unresolved(rawExpression, "property_access_not_resolved_to_local_string");
+  return unresolved(rawExpression, "unsupported_decorator_expression");
 }
 async function parseDecorators(repoPath, filePath) {
   const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
   const sf = createSourceFile(filePath, text);
-  const constants = /* @__PURE__ */ new Map();
+  const lookups = collectStringLookups(sf);
   const handlers = [];
   function visit(node) {
-    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isStringLiteralLike(node.initializer))
-      constants.set(node.name.text, node.initializer.text);
     if (ts2.isClassDeclaration(node)) {
       const className = node.name?.text ?? "AnonymousHandler";
       const hasHandler = decs(node).some((d) => callName(d) === "Handler");
@@ -357,13 +483,13 @@ async function parseDecorators(repoPath, filePath) {
         (m) => decs(m).filter(
           (d) => ["Func", "Action", "On", "Event"].includes(callName(d))
         ).map((d) => {
-          const raw = firstArg(d);
-          const value = raw.startsWith('"') || raw.startsWith("'") || raw.startsWith("`") ? stripQuotes(raw) : constants.get(raw) ?? (raw.endsWith(".name") ? raw.split(".").at(-2) : void 0);
+          const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
           return {
             methodName: m.name.getText(),
             decoratorKind: callName(d),
-            decoratorValue: value,
-            decoratorRawExpression: raw,
+            decoratorValue: decoratorResolution.resolvedValue,
+            decoratorRawExpression: decoratorResolution.rawExpression,
+            decoratorResolution,
             sourceFile: normalizePath(filePath),
             sourceLine: line(sf, m.getStart())
           };
@@ -588,7 +714,7 @@ import ts4 from "typescript";
 function lineOf3(sf, node) {
   return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
 }
-function stringValue(node) {
+function stringValue2(node) {
   if (!node) return void 0;
   if (ts4.isStringLiteralLike(node) || ts4.isNoSubstitutionTemplateLiteral(node)) return node.text;
   if (ts4.isTemplateExpression(node)) return node.getText().replace(/^`|`$/g, "");
@@ -609,7 +735,7 @@ function connectFactFromCall(call) {
   let alias;
   let aliasExpr;
   if (ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first)) alias = first.text;
-  else if (!ts4.isObjectLiteralExpression(first)) aliasExpr = stringValue(first);
+  else if (!ts4.isObjectLiteralExpression(first)) aliasExpr = stringValue2(first);
   if ((ts4.isStringLiteralLike(first) || ts4.isNoSubstitutionTemplateLiteral(first)) && !objectArg) return { alias: first.text, isDynamic: false, placeholders: [] };
   if (!objectArg && aliasExpr) return { aliasExpr, isDynamic: true, placeholders: placeholders(aliasExpr) };
   const expressions = objectArg ? objectExpressions(objectArg) : {};
@@ -622,8 +748,8 @@ function objectExpressions(objectArg) {
     for (const prop of obj.properties) {
       if (!ts4.isPropertyAssignment(prop)) continue;
       const name = ts4.isIdentifier(prop.name) || ts4.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-      if (name === "destination") out.destinationExpr = stringValue(prop.initializer);
-      if (name === "path" || name === "servicePath") out.servicePathExpr = stringValue(prop.initializer);
+      if (name === "destination") out.destinationExpr = stringValue2(prop.initializer);
+      if (name === "path" || name === "servicePath") out.servicePathExpr = stringValue2(prop.initializer);
       if (ts4.isObjectLiteralExpression(prop.initializer)) visitObject(prop.initializer);
     }
   }
@@ -733,8 +859,8 @@ function collectReturnedObjectBindings(fn) {
       for (const prop of node.expression.properties) {
         if (ts5.isShorthandPropertyAssignment(prop)) returns.set(prop.name.text, prop.name.text);
         if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
-          const propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-          if (propertyName2) returns.set(propertyName2, prop.initializer.text);
+          const propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+          if (propertyName3) returns.set(propertyName3, prop.initializer.text);
         }
       }
     }
@@ -742,9 +868,9 @@ function collectReturnedObjectBindings(fn) {
   }
   visit(fn);
   const out = /* @__PURE__ */ new Map();
-  for (const [propertyName2, variableName] of returns) {
+  for (const [propertyName3, variableName] of returns) {
     const fact = bindings.get(variableName);
-    if (fact) out.set(propertyName2, fact);
+    if (fact) out.set(propertyName3, fact);
   }
   return out;
 }
@@ -1028,8 +1154,8 @@ async function parseServiceBindings(repoPath, filePath) {
     if (helpers.length === 0) return;
     for (const el of decl.name.elements) {
       if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName2 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
-      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName2);
+      const propertyName3 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
       const resolved2 = matches2[0];
       out.push({
@@ -1042,7 +1168,7 @@ async function parseServiceBindings(repoPath, filePath) {
         placeholders: resolved2.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, decl),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName2, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
       });
     }
   }
@@ -1052,17 +1178,17 @@ async function parseServiceBindings(repoPath, filePath) {
     const helpers = await helpersForCall(call);
     if (helpers.length === 0) return;
     for (const prop of pattern.properties) {
-      let propertyName2;
+      let propertyName3;
       let targetName;
       if (ts5.isShorthandPropertyAssignment(prop)) {
-        propertyName2 = prop.name.text;
+        propertyName3 = prop.name.text;
         targetName = prop.name.text;
       } else if (ts5.isPropertyAssignment(prop)) {
-        propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+        propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
         targetName = ts5.isIdentifier(prop.initializer) ? prop.initializer.text : void 0;
       }
-      if (!propertyName2 || !targetName) continue;
-      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName2);
+      if (!propertyName3 || !targetName) continue;
+      const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
       const resolved2 = matches2[0];
       out.push({
@@ -1075,7 +1201,7 @@ async function parseServiceBindings(repoPath, filePath) {
         placeholders: resolved2.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, node),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName2, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
       });
     }
   }
@@ -1087,9 +1213,9 @@ async function parseServiceBindings(repoPath, filePath) {
     if (target.expression.kind !== ts5.SyntaxKind.ThisKeyword) return;
     for (const el of decl.name.elements) {
       if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName2 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      const propertyName3 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const helper = classHelpers.find(
-        (h) => h.helperName === target.name.text && h.propertyName === propertyName2
+        (h) => h.helperName === target.name.text && h.propertyName === propertyName3
       );
       if (!helper) continue;
       out.push({
@@ -1242,13 +1368,13 @@ function collectClassHelpers(sf) {
                 });
             }
             if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
-              const propertyName2 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-              const fact = propertyName2 ? bindings.get(prop.initializer.text) : void 0;
-              if (propertyName2 && fact)
+              const propertyName3 = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+              const fact = propertyName3 ? bindings.get(prop.initializer.text) : void 0;
+              if (propertyName3 && fact)
                 helpers.push({
                   className,
                   helperName,
-                  propertyName: propertyName2,
+                  propertyName: propertyName3,
                   variableName: prop.initializer.text,
                   fact,
                   sourceLine: lineOf3(sf, prop)
@@ -1944,12 +2070,12 @@ function mappedParameterIndex(expr, parameters) {
 }
 function propertyExpression(object, key) {
   for (const property of object.properties) {
-    if (ts7.isPropertyAssignment(property) && propertyName(property.name) === key) return property.initializer;
+    if (ts7.isPropertyAssignment(property) && propertyName2(property.name) === key) return property.initializer;
     if (ts7.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
   }
   return void 0;
 }
-function propertyName(name) {
+function propertyName2(name) {
   return ts7.isIdentifier(name) || ts7.isStringLiteralLike(name) ? name.text : void 0;
 }
 function literal(expr) {
@@ -2716,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(
@@ -2728,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(/^\//, "");
@@ -2744,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)
@@ -2918,46 +3053,6 @@ function linkHelperPackages(db, workspaceId, generation) {
   return summary;
 }
 
-// src/linker/operation-decorator-normalizer.ts
-function lowerFirst(value) {
-  return value ? `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}` : value;
-}
-function normalizedOperationName(value) {
-  return value.replace(/^\//, "");
-}
-function clean(value) {
-  return value.replace(/^[`'"]|[`'"]$/g, "");
-}
-function generatedFromConstantName(value) {
-  for (const prefix of ["Action", "Func"]) {
-    if (value.startsWith(prefix) && value.length > prefix.length && /^[A-Z]/.test(value.slice(prefix.length))) return lowerFirst(value.slice(prefix.length));
-  }
-  return void 0;
-}
-function resolved(value, raw) {
-  const literal2 = clean(value);
-  const generated = generatedFromConstantName(literal2);
-  return { status: "resolved", operationName: generated ?? normalizedOperationName(literal2), raw };
-}
-function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
-  if (value) return resolved(value, raw);
-  if (!raw || raw.trim().length === 0) return { status: "none", raw };
-  const expression = raw.trim();
-  const nameMatch = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(expression);
-  if (nameMatch?.[1]) return resolved(nameMatch[1], expression);
-  const stringMatch = /^String\(([A-Za-z_$][\w$]*)\)$/.exec(expression);
-  if (stringMatch?.[1]) {
-    const identifier = stringMatch[1];
-    const generated = generatedFromConstantName(identifier);
-    const normalizedCandidate2 = candidateOperation ? normalizedOperationName(candidateOperation) : void 0;
-    if (generated) return { status: "resolved", operationName: generated, raw: expression };
-    if (normalizedCandidate2 && identifier === normalizedCandidate2) return { status: "resolved", operationName: identifier, raw: expression };
-    return { status: "unsupported", raw: expression, reason: "string_wrapper_identifier_not_resolved" };
-  }
-  if (/^[`'"]/.test(expression) && !/[`'"]$/.test(expression)) return { status: "malformed", raw: expression, reason: "unterminated_literal" };
-  return { status: "unsupported", raw: expression, reason: "unsupported_decorator_expression" };
-}
-
 // src/linker/cross-repo-linker.ts
 function linkWorkspace(db, workspaceId, vars = {}) {
   return db.transaction(() => {
@@ -3140,14 +3235,20 @@ function objectJson(value) {
 }
 function callEvidence(call, resolution, servicePath, op, destination, normalized, odataPathIntent) {
   const bindingHasDynamicExpression = Boolean(Number(call.isDynamic ?? 0));
-  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue2(call.aliasExpr), stringValue2(call.alias)]);
+  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue3(call.aliasExpr), stringValue3(call.alias)]);
   return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArguments: normalized?.wasInvocation ? normalized.invocationArguments : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, routingPlaceholderKeys: routingPlaceholderKeys.length ? routingPlaceholderKeys : void 0, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === "local_service_call" ? "local" : void 0, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateScores: compactCandidateScores(resolution.candidates), candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || void 0, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : void 0, bindingHasDynamicExpression: bindingHasDynamicExpression || void 0, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
 }
 function compactCandidateScores(candidates) {
   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) {
@@ -3157,7 +3258,7 @@ function placeholderKeys(values) {
 function objectValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function linkImplementations(db, workspaceId, generation) {
@@ -3212,13 +3313,54 @@ function implementationContextForOperation(db, operation) {
 }
 function rankedImplementationCandidates(db, workspaceId, operation) {
   const rows2 = implementationCandidates(db, workspaceId, operation);
-  return deduplicateCandidates(rows2.map((row) => scoreImplementationCandidate(row, operation))).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+  const invalid = rows2.filter((row) => !validRegistrationPair(row));
+  recordRegistrationInvariantDiagnostics(db, invalid);
+  return deduplicateCandidates(
+    rows2.filter(validRegistrationPair).map((row) => scoreImplementationCandidate(row, operation))
+  ).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+}
+function validRegistrationPair(row) {
+  if (row.registrationHandlerClassId === null || row.registrationHandlerClassId === void 0)
+    return registrationPairingStrategy(row) !== "unproven";
+  return Number(row.registrationHandlerClassId) === Number(row.classId);
+}
+function registrationPairingStrategy(row) {
+  if (row.registrationHandlerClassId !== null && row.registrationHandlerClassId !== void 0)
+    return "exact_handler_class_id";
+  if (Number(row.applicationRepoId) === Number(row.handlerRepoId))
+    return "same_repository_class_name_fallback";
+  const source = stringValue3(row.importSource);
+  const separator = source?.lastIndexOf("#") ?? -1;
+  if (!source || separator <= 0) return "unproven";
+  const moduleName = source.slice(0, separator);
+  const importedName = source.slice(separator + 1);
+  const matchesClass = importedName === row.className || importedName === "default" && row.registrationClassName === row.className;
+  return moduleName === row.handlerPackage && matchesClass ? "explicit_package_import" : "unproven";
+}
+function recordRegistrationInvariantDiagnostics(db, rows2) {
+  const insert = db.prepare(`INSERT INTO diagnostics(repo_id,severity,code,message,source_file,source_line)
+    SELECT ?,'error','handler_registration_class_mismatch',
+      'Implementation candidate registration did not match its persisted handler class id',?,?
+    WHERE NOT EXISTS (
+      SELECT 1 FROM diagnostics
+      WHERE repo_id=? AND code='handler_registration_class_mismatch'
+        AND source_file=? AND source_line=?
+    )`);
+  for (const row of rows2)
+    insert.run(
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine,
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine
+    );
 }
 function deduplicateCandidates(rows2) {
   const merged = /* @__PURE__ */ new Map();
   for (const row of rows2) {
     const key = [row.methodId, row.classId, row.handlerRepoId].join(":");
-    const registration = { file: row.registrationFile, line: row.registrationLine, kind: row.registrationKind, importSource: row.importSource };
+    const registration = registrationEvidence(row);
     const existing = merged.get(key);
     if (!existing) {
       merged.set(key, { ...row, registrations: [registration] });
@@ -3232,6 +3374,17 @@ function deduplicateCandidates(rows2) {
   }
   return [...merged.values()];
 }
+function registrationEvidence(row) {
+  return {
+    id: row.registrationId,
+    handlerClassId: row.registrationHandlerClassId,
+    file: row.registrationFile,
+    line: row.registrationLine,
+    kind: row.registrationKind,
+    importSource: row.importSource,
+    pairingStrategy: registrationPairingStrategy(row)
+  };
+}
 function uniqueRegistrations(rows2) {
   const seen = /* @__PURE__ */ new Set();
   return rows2.filter((row) => {
@@ -3260,10 +3413,14 @@ function implementationCandidates(db, workspaceId, operation) {
       hm.method_name methodName,
       hm.decorator_value decoratorValue,
       hm.decorator_raw_expression decoratorRawExpression,
+      hm.decorator_resolution_json decoratorResolutionJson,
       hc.id classId,
       hc.class_name className,
       hc.source_file sourceFile,
       hc.source_line sourceLine,
+      hr.id registrationId,
+      hr.handler_class_id registrationHandlerClassId,
+      hr.class_name registrationClassName,
       hr.repo_id applicationRepoId,
       hr.registration_file registrationFile,
       hr.registration_line registrationLine,
@@ -3286,14 +3443,36 @@ function implementationCandidates(db, workspaceId, operation) {
       CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
-      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON (localClass.id=localReg.handler_class_id OR localClass.class_name=localReg.class_name) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
+      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
     FROM handler_methods hm
     JOIN handler_classes hc ON hc.id=hm.handler_class_id
     JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
-    JOIN handler_registrations hr ON (hr.handler_class_id=hc.id OR (hr.class_name=hc.class_name AND (hr.repo_id=hc.repo_id OR hr.import_source IS NOT NULL)))
+    JOIN handler_registrations hr ON (
+      (hr.handler_class_id IS NOT NULL AND hr.handler_class_id=hc.id)
+      OR (
+        hr.handler_class_id IS NULL
+        AND (
+          (hr.class_name=hc.class_name AND hr.repo_id=hc.repo_id)
+          OR (
+            instr(hr.import_source,'#')>1
+            AND substr(hr.import_source,1,instr(hr.import_source,'#')-1)
+              =handlerRepo.package_name
+            AND (
+              substr(hr.import_source,instr(hr.import_source,'#')+1)
+                =hc.class_name
+              OR (
+                substr(hr.import_source,instr(hr.import_source,'#')+1)
+                  ='default'
+                AND hr.class_name=hc.class_name
+              )
+            )
+          )
+        )
+      )
+    )
     JOIN repositories appRepo ON appRepo.id=hr.repo_id
     WHERE appRepo.workspace_id=?
       AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=? OR hm.decorator_raw_expression LIKE ?)`).all(
@@ -3395,8 +3574,16 @@ function candidateEvidence(candidate, rank) {
     className: candidate.className,
     sourceFile: candidate.sourceFile,
     sourceLine: candidate.sourceLine,
-    registration: { file: candidate.registrationFile, line: candidate.registrationLine, kind: candidate.registrationKind, importSource: candidate.importSource },
+    decoratorResolution: objectJson(candidate.decoratorResolutionJson),
+    registration: registrationEvidence(candidate),
     registrations: candidate.registrations ?? [],
+    registrationPairing: {
+      strategy: registrationPairingStrategy(candidate),
+      registrationId: candidate.registrationId,
+      registrationHandlerClassId: candidate.registrationHandlerClassId,
+      candidateHandlerClassId: candidate.classId,
+      invariantStatus: validRegistrationPair(candidate) ? "valid" : "invalid"
+    },
     applicationPackage: { id: candidate.applicationRepoId, name: candidate.applicationRepo, packageName: candidate.applicationPackage },
     handlerPackage: { id: candidate.handlerRepoId, name: candidate.handlerRepo, packageName: candidate.handlerPackage },
     modelPackage: { id: candidate.modelRepoId, name: candidate.modelRepo, packageName: candidate.modelPackage },
@@ -3436,6 +3623,337 @@ function normalizedOperation(value) {
   return value.startsWith("/") ? value.slice(1) : value;
 }
 
+// src/trace/selectors.ts
+function parseVars(values) {
+  const out = {};
+  for (const value of values ?? []) {
+    const [key, ...rest] = value.split("=");
+    if (key && rest.length > 0) out[key] = rest.join("=");
+  }
+  return out;
+}
+function ambiguousStartDiagnostic(requested, candidates, message) {
+  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+  return {
+    severity: "warning",
+    code: "trace_start_ambiguous",
+    message,
+    normalizedSelectorValue: requested,
+    resolutionStage: "operation",
+    resolutionStatus: "ambiguous_operation",
+    candidates,
+    serviceSuggestions,
+    selectorSuggestions: fullSelectorSuggestions(candidates)
+  };
+}
+function fullSelectorSuggestions(candidates) {
+  const includeRepo = new Set(candidates.map((row) => row.repoName)).size > 1;
+  return [...new Set(candidates.flatMap((row) => {
+    if (typeof row.servicePath !== "string" || typeof row.operationPath !== "string") return [];
+    const repoSelector = includeRepo && typeof row.repoName === "string" ? `--repo ${row.repoName} ` : "";
+    return [
+      `${repoSelector}--service ${row.servicePath} --path ${row.operationPath}`
+    ];
+  }))].sort();
+}
+
+// src/trace/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 ?? {} };
@@ -3454,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 ?? "")))
@@ -3479,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;
@@ -3487,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 = stringValue3(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue3(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 = stringValue3(evidence.servicePath);
-  const operationPath = stringValue3(evidence.operationPath);
-  const targetOperation = stringValue3(evidence.targetOperation);
-  const targetRepo = stringValue3(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 stringValue3(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 stringValue3(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;
@@ -3544,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 = stringValue3(evidence.servicePath);
-  const rawOperationPath = stringValue3(evidence.operationPath);
+  const servicePath = stringValue5(evidence.servicePath);
+  const rawOperationPath = stringValue5(evidence.operationPath);
   const normalized = normalizeODataOperationInvocationPath(rawOperationPath);
-  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue3(evidence.normalizedOperationPath) ?? rawOperationPath;
-  const alias = stringValue3(evidence.serviceAliasExpr ?? evidence.serviceAlias);
-  const destination = stringValue3(evidence.destination);
+  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : 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) {
@@ -3561,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"]) {
@@ -3570,7 +4141,7 @@ function runtimeSubstitutions(evidence, vars) {
   return substitutions;
 }
 function substitutionValue(evidence, key) {
-  const value = stringValue3(evidence[key]);
+  const value = stringValue5(evidence[key]);
   if (key !== "operationPath") return value;
   const normalized = normalizeODataOperationInvocationPath(value);
   return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
@@ -3581,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));
 }
@@ -3592,9 +4186,56 @@ function runtimeUnresolvedReason(resolution) {
 function parseObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue3(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) {
@@ -3641,19 +4282,6 @@ function implementationRejectionReasons(evidence) {
   const reasons = candidates.flatMap((candidate) => Array.isArray(candidate.rejectedReasons) ? candidate.rejectedReasons.filter((reason) => typeof reason === "string") : []);
   return [...new Set(reasons)].sort();
 }
-function ambiguousStartDiagnostic(requested, candidates, message) {
-  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
-  return {
-    severity: "warning",
-    code: "trace_start_ambiguous",
-    message,
-    normalizedSelectorValue: requested,
-    resolutionStage: "operation",
-    resolutionStatus: "ambiguous_operation",
-    candidates,
-    serviceSuggestions
-  };
-}
 function sourceFilesForStart(db, repoId, start) {
   const handler = start.handler;
   const operation = normalizeOperation(start.operation ?? start.operationPath);
@@ -4076,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}`;
@@ -4096,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);
@@ -4175,6 +4809,7 @@ export {
   parseImplementationHint,
   implementationHintSuggestions,
   linkWorkspace,
+  parseVars,
   trace
 };
-//# sourceMappingURL=chunk-XOROZHW4.js.map
+//# sourceMappingURL=chunk-YZJKE5UX.js.map