@saptools/service-flow 0.1.42 → 0.1.44

package/dist/{chunk-RP3BJ64F.js → chunk-UKNPHTUS.js}

@@ -577,10 +577,64 @@ function summarizeExpression(text) {
   return redactText(text).slice(0, 240);
 }
 
+// src/parsers/outbound-call-parser.ts
+import fs6 from "fs/promises";
+import path7 from "path";
+import ts4 from "typescript";
+
+// src/linker/external-http-target.ts
+import { createHash } from "crypto";
+var sensitiveKeys = /* @__PURE__ */ new Set(["token", "access_token", "id_token", "api_key", "apikey", "key", "password", "passwd", "pwd", "secret", "client_secret", "authorization", "cookie", "signature"]);
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function methodPrefix(method) {
+  return typeof method === "string" && method.length > 0 ? `${method.toUpperCase()} ` : "";
+}
+function redactUrl(value) {
+  try {
+    const url = new URL(value, value.startsWith("/") ? "https://relative.invalid" : void 0);
+    url.username = "";
+    url.password = "";
+    for (const key of [...url.searchParams.keys()]) url.searchParams.set(key, sensitiveKeys.has(key.toLowerCase()) ? "<redacted>" : "<redacted>");
+    const path10 = `${url.pathname}${url.search ? url.search : ""}`;
+    return value.startsWith("/") ? path10 : `${url.origin}${path10}`;
+  } catch {
+    return value.replace(/([?&][^=;&]*(?:token|key|password|secret|cookie|authorization)[^=;&]*=)[^&]*/gi, "$1<redacted>");
+  }
+}
+function externalHttpTarget(call) {
+  const evidence = typeof call.evidence_json === "string" ? safeParse(call.evidence_json) : {};
+  const target = evidence.externalTarget && typeof evidence.externalTarget === "object" && !Array.isArray(evidence.externalTarget) ? evidence.externalTarget : {};
+  const method = typeof call.method === "string" ? call.method : typeof target.method === "string" ? target.method : void 0;
+  const kind = typeof target.kind === "string" ? target.kind : "unknown";
+  const expression = typeof target.expression === "string" ? target.expression : void 0;
+  if (kind === "destination" && target.dynamic === true) {
+    const shape = typeof target.expressionShape === "string" ? target.expressionShape : "expression";
+    const candidates = Array.isArray(target.candidateLiterals) ? target.candidateLiterals.filter((item) => typeof item === "string") : [];
+    return { kind, toKind: "external_destination", toId: `destination:dynamic:${hash(`${shape}:${candidates.join("|")}`)}`, label: "External destination: dynamic destination", method, dynamic: true, expression: candidates.length ? `candidates:${candidates.join("|")}` : `shape:${shape}` };
+  }
+  if (kind === "destination" && expression) return { kind, toKind: "external_destination", toId: `destination:${expression}`, label: `External destination: ${expression}`, method, dynamic: false, expression };
+  if (kind === "static_url" && expression) {
+    const redacted = redactUrl(expression);
+    return { kind, toKind: "external_endpoint", toId: `endpoint:${hash(`${method ?? ""}:${redacted}`)}`, label: `External endpoint: ${methodPrefix(method)}${redacted}`, method, dynamic: false, expression: redacted };
+  }
+  if (kind === "url_expression" && expression) return { kind, toKind: "external_endpoint", toId: `dynamic:${hash(expression)}`, label: `External endpoint: ${methodPrefix(method)}dynamic URL`, method, dynamic: true, expression: `expr:${hash(expression)}` };
+  return { kind: "unknown", toKind: "external_endpoint", toId: "unknown", label: "External endpoint: unknown", method, dynamic: false };
+}
+function safeParse(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
 // src/linker/odata-path-normalizer.ts
-function normalizeODataOperationInvocationPath(path9) {
-  if (path9 === void 0) return void 0;
-  const raw = path9.trim();
+function normalizeODataOperationInvocationPath(path10) {
+  if (path10 === void 0) return void 0;
+  const raw = path10.trim();
   if (!raw) return void 0;
   const rejected = (reason) => ({ rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false, invocationArgumentPlaceholderKeys: [], normalizationRejectedReason: reason });
   const open = raw.indexOf("(");
@@ -602,8 +656,8 @@ function normalizeODataOperationInvocationPath(path9) {
     normalizationReason: "balanced_top_level_operation_invocation"
   };
 }
-function classifyODataPathIntent(path9, method) {
-  const rawPath = (path9 ?? "").trim();
+function classifyODataPathIntent(path10, method) {
+  const rawPath = (path10 ?? "").trim();
   const normalizedMethod = (method ?? "GET").trim().toUpperCase() || "GET";
   const queryIndex = rawPath.indexOf("?");
   const pathWithoutQuery = queryIndex >= 0 ? rawPath.slice(0, queryIndex) : rawPath;
@@ -651,8 +705,8 @@ function classifyODataPathIntent(path9, method) {
   if (/^[A-Z][A-Za-z0-9_]*$/.test(firstSegment)) return { ...base, kind: "entity_candidate", reason: "uppercase_collection_segment_without_indexed_entity_evidence" };
   return { ...base, kind: "unknown", reason: "get_path_has_no_query_key_or_navigation_signal" };
 }
-function entitySegmentFromPath(path9) {
-  const first = path9.replace(/^\//, "").split("/")[0]?.trim();
+function entitySegmentFromPath(path10) {
+  const first = path10.replace(/^\//, "").split("/")[0]?.trim();
   if (!first) return void 0;
   const open = first.indexOf("(");
   const entity = (open >= 0 ? first.slice(0, open) : first).trim();
@@ -799,60 +853,6 @@ function topLevelQueryIndex(text) {
   return -1;
 }
 
-// src/parsers/outbound-call-parser.ts
-import fs6 from "fs/promises";
-import path7 from "path";
-import ts4 from "typescript";
-
-// src/linker/external-http-target.ts
-import { createHash } from "crypto";
-var sensitiveKeys = /* @__PURE__ */ new Set(["token", "access_token", "id_token", "api_key", "apikey", "key", "password", "passwd", "pwd", "secret", "client_secret", "authorization", "cookie", "signature"]);
-function hash(value) {
-  return createHash("sha256").update(value).digest("hex").slice(0, 12);
-}
-function methodPrefix(method) {
-  return typeof method === "string" && method.length > 0 ? `${method.toUpperCase()} ` : "";
-}
-function redactUrl(value) {
-  try {
-    const url = new URL(value, value.startsWith("/") ? "https://relative.invalid" : void 0);
-    url.username = "";
-    url.password = "";
-    for (const key of [...url.searchParams.keys()]) url.searchParams.set(key, sensitiveKeys.has(key.toLowerCase()) ? "<redacted>" : "<redacted>");
-    const path9 = `${url.pathname}${url.search ? url.search : ""}`;
-    return value.startsWith("/") ? path9 : `${url.origin}${path9}`;
-  } catch {
-    return value.replace(/([?&][^=;&]*(?:token|key|password|secret|cookie|authorization)[^=;&]*=)[^&]*/gi, "$1<redacted>");
-  }
-}
-function externalHttpTarget(call) {
-  const evidence = typeof call.evidence_json === "string" ? safeParse(call.evidence_json) : {};
-  const target = evidence.externalTarget && typeof evidence.externalTarget === "object" && !Array.isArray(evidence.externalTarget) ? evidence.externalTarget : {};
-  const method = typeof call.method === "string" ? call.method : typeof target.method === "string" ? target.method : void 0;
-  const kind = typeof target.kind === "string" ? target.kind : "unknown";
-  const expression = typeof target.expression === "string" ? target.expression : void 0;
-  if (kind === "destination" && target.dynamic === true) {
-    const shape = typeof target.expressionShape === "string" ? target.expressionShape : "expression";
-    const candidates = Array.isArray(target.candidateLiterals) ? target.candidateLiterals.filter((item) => typeof item === "string") : [];
-    return { kind, toKind: "external_destination", toId: `destination:dynamic:${hash(`${shape}:${candidates.join("|")}`)}`, label: "External destination: dynamic destination", method, dynamic: true, expression: candidates.length ? `candidates:${candidates.join("|")}` : `shape:${shape}` };
-  }
-  if (kind === "destination" && expression) return { kind, toKind: "external_destination", toId: `destination:${expression}`, label: `External destination: ${expression}`, method, dynamic: false, expression };
-  if (kind === "static_url" && expression) {
-    const redacted = redactUrl(expression);
-    return { kind, toKind: "external_endpoint", toId: `endpoint:${hash(`${method ?? ""}:${redacted}`)}`, label: `External endpoint: ${methodPrefix(method)}${redacted}`, method, dynamic: false, expression: redacted };
-  }
-  if (kind === "url_expression" && expression) return { kind, toKind: "external_endpoint", toId: `dynamic:${hash(expression)}`, label: `External endpoint: ${methodPrefix(method)}dynamic URL`, method, dynamic: true, expression: `expr:${hash(expression)}` };
-  return { kind: "unknown", toKind: "external_endpoint", toId: "unknown", label: "External endpoint: unknown", method, dynamic: false };
-}
-function safeParse(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
 // src/parsers/outbound-call-parser.ts
 function lineOf3(text, idx) {
   return text.slice(0, idx).split("\n").length;
@@ -950,6 +950,7 @@ function nodeContains(parent, child) {
 }
 function declarationScope(node) {
   if (ts4.isParameter(node)) return node.parent;
+  if (ts4.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
   const list = node.parent;
   const blockScoped = (list.flags & (ts4.NodeFlags.Const | ts4.NodeFlags.Let)) !== 0;
   let current = list.parent;
@@ -957,26 +958,23 @@ function declarationScope(node) {
     while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
     return current;
   }
-  while (current.parent && !ts4.isBlock(current) && !ts4.isSourceFile(current) && !ts4.isModuleBlock(current) && !ts4.isCaseBlock(current) && !ts4.isCatchClause(current) && !ts4.isForStatement(current) && !ts4.isForInStatement(current) && !ts4.isForOfStatement(current) && !isFunctionLikeScope(current)) current = current.parent;
+  while (current.parent && !ts4.isBlock(current) && !ts4.isSourceFile(current) && !ts4.isModuleBlock(current) && !ts4.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
   return current;
 }
-function declarationScopedAncestor(node) {
-  let current = node.parent;
-  while (current) {
-    if (ts4.isCatchClause(current) || ts4.isForStatement(current) || ts4.isForInStatement(current) || ts4.isForOfStatement(current)) return current;
-    if (ts4.isSourceFile(current) || ts4.isFunctionLike(current)) return void 0;
-    current = current.parent;
-  }
-  return void 0;
+function isLoopInitializerScope(declaration, scope) {
+  const list = declaration.parent;
+  return ts4.isForStatement(scope) && scope.initializer === list || (ts4.isForInStatement(scope) || ts4.isForOfStatement(scope)) && scope.initializer === list;
+}
+function catchBindingScope(declaration) {
+  if (ts4.isParameter(declaration)) return void 0;
+  return ts4.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
 }
 function isAccessibleDeclaration(declaration, use) {
   const source = use.getSourceFile();
   if (declaration.name.getStart(source) >= use.getStart(source)) return false;
-  const scopedAncestor = declarationScopedAncestor(declaration);
-  if (scopedAncestor && ts4.isCatchClause(scopedAncestor)) return nodeContains(scopedAncestor.block, use);
-  if (scopedAncestor && (ts4.isForStatement(scopedAncestor) || ts4.isForInStatement(scopedAncestor) || ts4.isForOfStatement(scopedAncestor))) return nodeContains(scopedAncestor.statement, use);
+  const catchScope = catchBindingScope(declaration);
+  if (catchScope) return nodeContains(catchScope.block, use);
   const scope = declarationScope(declaration);
-  if (ts4.isCatchClause(scope)) return nodeContains(scope.block, use);
   if (ts4.isForStatement(scope) || ts4.isForInStatement(scope) || ts4.isForOfStatement(scope)) return nodeContains(scope.statement, use);
   return ts4.isSourceFile(scope) || nodeContains(scope, use);
 }
@@ -1084,6 +1082,11 @@ function httpMethodFromObject(object, use) {
   const text = resolveExpression(propertyInitializer(object, "method"), use, "literal").value;
   return text ? stripQuotes(text).toUpperCase() : void 0;
 }
+var supportedHttpMethods = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+function safeOperationName(value) {
+  if (!value || !/^[A-Za-z_$][\w$]*(?:[./][A-Za-z_$][\w$]*)*$/.test(value)) return void 0;
+  return operationPathFromStatic(value);
+}
 function hasTemplatePlaceholder(value) {
   return /\$\{|%7B|%7D/i.test(value);
 }
@@ -1201,6 +1204,14 @@ function collectWrapperSpecs(source) {
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
+      if (ts4.isCallExpression(node) && ts4.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+        const nested = specs.get(node.expression.text);
+        const pathArg = nested ? node.arguments[nested.pathIndex] : void 0;
+        const clientArg = nested?.clientIndex === void 0 ? void 0 : node.arguments[nested.clientIndex];
+        const pathName = pathArg && ts4.isIdentifier(pathArg) ? pathArg.text : void 0;
+        const clientName = clientArg && ts4.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        if (nested && pathName && clientName) sends.push({ client: clientName, path: pathName, method: nested.methodName, methodLiteral: nested.methodLiteral, nestedWrapperFunction: node.expression.text, start: node.getStart(source), end: node.getEnd() });
+      }
       ts4.forEachChild(node, visit);
     };
     visit(fn);
@@ -1210,7 +1221,7 @@ function collectWrapperSpecs(source) {
     const pathIndex = params.indexOf(found.path);
     const methodIndex = found.method ? params.indexOf(found.method) : -1;
     const capturesKnownClient = serviceVariables.has(found.client) || /^(srv|service|serviceClient|client|.*Client)$/.test(found.client);
-    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : void 0, clientName: clientIndex >= 0 ? void 0 : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : void 0, methodName: found.method, methodLiteral: found.methodLiteral, definitionLine: lineOf3(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
+    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : void 0, clientName: clientIndex >= 0 ? void 0 : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : void 0, methodName: found.method, methodLiteral: found.methodLiteral, nestedWrapperFunction: found.nestedWrapperFunction, definitionLine: lineOf3(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node) => {
     if (ts4.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
@@ -1263,16 +1274,18 @@ function classifyOutboundCallsInSource(source, filePath) {
         } else {
           const receiver = receiverName(expr.expression);
           const rootReceiver = rootReceiverName(expr.expression);
-          const method = resolveExpression(node.arguments[0], node, "literal").value?.toUpperCase();
+          const firstArg2 = resolveExpression(node.arguments[0], node, "literal");
+          const method = firstArg2.value?.toUpperCase();
           const pathArg = node.arguments[1];
-          const supported = method && ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"].includes(method);
+          const supported = method && supportedHttpMethods.has(method);
           if (receiver && supported && serviceVariables.has(rootReceiver ?? receiver)) {
             const resolvedPath = staticPathExpression(pathArg, node);
             const operationPathExpr = operationPathFromStatic(resolvedPath.text);
             const intent = classifyODataPathIntent(operationPathExpr, method);
             add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" }, { receiver, rootReceiver, classifier: "service_client_send_method_path", rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : resolvedPath.sourceKind : void 0, odataPathIntent: operationPathExpr ? intent : void 0, parserWarning: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" });
           } else if (receiver && serviceVariables.has(rootReceiver ?? receiver)) {
-            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.35, unresolvedReason: "unsupported_cap_send_signature" }, { receiver, rootReceiver, classifier: "service_client_send_unsupported_signature" });
+            const operationPathExpr = safeOperationName(firstArg2.value);
+            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.75 : 0.35, unresolvedReason: operationPathExpr ? void 0 : "unsupported_cap_send_signature" }, { receiver, rootReceiver, classifier: operationPathExpr ? "service_client_send_operation_event" : "service_client_send_unsupported_signature", rawOperationExpression: firstArg2.rawExpression, literalOperationSource: firstArg2.value ? firstArg2.sourceKind : void 0, parserWarning: operationPathExpr ? void 0 : "unsupported_cap_send_signature" });
           }
         }
       } else if (ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts4.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
@@ -1288,7 +1301,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         const operationPathExpr = operationPathFromStatic(resolvedPath.text);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : void 0;
         if (spec && receiver && operationPathExpr) {
-          add(node, { callType: "remote_action", serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === "literal" ? "higher_order_wrapper_literal_path" : "higher_order_wrapper_static_path", wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf3(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
+          add(node, { callType: "remote_action", serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === "literal" ? "higher_order_wrapper_literal_path" : "higher_order_wrapper_static_path", wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf3(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
         } else if (spec && receiver) {
           add(node, { callType: "remote_action", serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason: "dynamic_operation_path_identifier" }, { receiver, classifier: "higher_order_wrapper_dynamic_path", wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf3(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: "dynamic_operation_path_identifier" });
         }
@@ -1383,6 +1396,10 @@ function serviceOperationCall(node, aliases) {
 }
 
 // src/parsers/service-binding-parser.ts
+import path9 from "path";
+import ts6 from "typescript";
+
+// src/parsers/service-binding-parser-helpers.ts
 import fs7 from "fs/promises";
 import path8 from "path";
 import ts5 from "typescript";
@@ -1391,10 +1408,8 @@ function lineOf4(sf, node) {
 }
 function stringValue(node) {
   if (!node) return void 0;
-  if (ts5.isStringLiteralLike(node) || ts5.isNoSubstitutionTemplateLiteral(node))
-    return node.text;
-  if (ts5.isTemplateExpression(node))
-    return node.getText().replace(/^`|`$/g, "");
+  if (ts5.isStringLiteralLike(node) || ts5.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts5.isTemplateExpression(node)) return node.getText().replace(/^`|`$/g, "");
   return node.getText();
 }
 function placeholders2(value) {
@@ -1402,57 +1417,36 @@ function placeholders2(value) {
 }
 function connectFactFromCall(call) {
   const expr = call.expression;
-  if (!ts5.isPropertyAccessExpression(expr) || expr.name.text !== "to")
-    return void 0;
+  if (!ts5.isPropertyAccessExpression(expr) || expr.name.text !== "to") return void 0;
   const inner = expr.expression;
-  if (!ts5.isPropertyAccessExpression(inner) || inner.name.text !== "connect" || inner.expression.getText() !== "cds")
-    return void 0;
+  if (!ts5.isPropertyAccessExpression(inner) || inner.name.text !== "connect" || inner.expression.getText() !== "cds") return void 0;
   const first = call.arguments[0];
   if (!first) return void 0;
   const second = call.arguments[1];
   const objectArg = ts5.isObjectLiteralExpression(first) ? first : second && ts5.isObjectLiteralExpression(second) ? second : void 0;
   let alias;
   let aliasExpr;
-  if (ts5.isStringLiteralLike(first) || ts5.isNoSubstitutionTemplateLiteral(first))
-    alias = first.text;
-  else if (!ts5.isObjectLiteralExpression(first))
-    aliasExpr = stringValue(first);
-  if ((ts5.isStringLiteralLike(first) || ts5.isNoSubstitutionTemplateLiteral(first)) && !objectArg)
-    return { alias: first.text, isDynamic: false, placeholders: [] };
-  if (!objectArg && aliasExpr)
-    return {
-      aliasExpr,
-      isDynamic: true,
-      placeholders: placeholders2(aliasExpr)
-    };
-  let destinationExpr;
-  let servicePathExpr;
+  if (ts5.isStringLiteralLike(first) || ts5.isNoSubstitutionTemplateLiteral(first)) alias = first.text;
+  else if (!ts5.isObjectLiteralExpression(first)) aliasExpr = stringValue(first);
+  if ((ts5.isStringLiteralLike(first) || ts5.isNoSubstitutionTemplateLiteral(first)) && !objectArg) return { alias: first.text, isDynamic: false, placeholders: [] };
+  if (!objectArg && aliasExpr) return { aliasExpr, isDynamic: true, placeholders: placeholders2(aliasExpr) };
+  const expressions = objectArg ? objectExpressions(objectArg) : {};
+  const ph = [...placeholders2(aliasExpr ?? alias), ...placeholders2(expressions.destinationExpr), ...placeholders2(expressions.servicePathExpr)];
+  return { alias, aliasExpr, ...expressions, isDynamic: ph.length > 0 || !expressions.destinationExpr && !expressions.servicePathExpr, placeholders: ph };
+}
+function objectExpressions(objectArg) {
+  const out = {};
   function visitObject(obj) {
     for (const prop of obj.properties) {
       if (!ts5.isPropertyAssignment(prop)) continue;
       const name = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-      if (name === "destination")
-        destinationExpr = stringValue(prop.initializer);
-      if (name === "path" || name === "servicePath")
-        servicePathExpr = stringValue(prop.initializer);
-      if (ts5.isObjectLiteralExpression(prop.initializer))
-        visitObject(prop.initializer);
-    }
-  }
-  if (objectArg) visitObject(objectArg);
-  const ph = [
-    ...placeholders2(aliasExpr ?? alias),
-    ...placeholders2(destinationExpr),
-    ...placeholders2(servicePathExpr)
-  ];
-  return {
-    alias,
-    aliasExpr,
-    destinationExpr,
-    servicePathExpr,
-    isDynamic: ph.length > 0 || !destinationExpr && !servicePathExpr,
-    placeholders: ph
-  };
+      if (name === "destination") out.destinationExpr = stringValue(prop.initializer);
+      if (name === "path" || name === "servicePath") out.servicePathExpr = stringValue(prop.initializer);
+      if (ts5.isObjectLiteralExpression(prop.initializer)) visitObject(prop.initializer);
+    }
+  }
+  visitObject(objectArg);
+  return out;
 }
 function unwrapCall(expr) {
   if (ts5.isAwaitExpression(expr)) return unwrapCall(expr.expression);
@@ -1473,12 +1467,10 @@ function transactionReceiverName(expr) {
   const call = unwrapCall(expr);
   if (call && ts5.isPropertyAccessExpression(call.expression) && ["tx", "transaction"].includes(call.expression.name.text) && ts5.isIdentifier(call.expression.expression)) return call.expression.expression.text;
   const unwrapped = unwrapIdentityExpression(expr);
-  if (ts5.isConditionalExpression(unwrapped)) {
-    const left = transactionReceiverName(unwrapped.whenTrue);
-    const right = transactionReceiverName(unwrapped.whenFalse);
-    return left && left === right ? left : void 0;
-  }
-  return void 0;
+  if (!ts5.isConditionalExpression(unwrapped)) return void 0;
+  const left = transactionReceiverName(unwrapped.whenTrue);
+  const right = transactionReceiverName(unwrapped.whenFalse);
+  return left && left === right ? left : void 0;
 }
 function findConnectInExpression(expr) {
   const direct = unwrapCall(expr);
@@ -1498,13 +1490,7 @@ function findConnectInExpression(expr) {
 async function readSource(abs) {
   try {
     const text = await fs7.readFile(abs, "utf8");
-    return ts5.createSourceFile(
-      abs,
-      text,
-      ts5.ScriptTarget.Latest,
-      true,
-      ts5.ScriptKind.TS
-    );
+    return ts5.createSourceFile(abs, text, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
   } catch {
     return void 0;
   }
@@ -1514,56 +1500,34 @@ async function resolveImport(repoPath, fromFile, spec) {
   const rawBase = path8.resolve(repoPath, path8.dirname(fromFile), spec);
   const parsed = path8.parse(rawBase);
   const base = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(parsed.ext) ? path8.join(parsed.dir, parsed.name) : rawBase;
-  for (const candidate of [
-    base,
-    `${base}.ts`,
-    `${base}.js`,
-    path8.join(base, "index.ts"),
-    path8.join(base, "index.js")
-  ]) {
-    try {
-      const st = await fs7.stat(candidate);
-      if (st.isFile()) return normalizePath(path8.relative(repoPath, candidate));
-    } catch {
-    }
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path8.join(base, "index.ts"), path8.join(base, "index.js")]) {
+    const stat = await fs7.stat(candidate).catch(() => void 0);
+    if (stat?.isFile()) return normalizePath(path8.relative(repoPath, candidate));
   }
   return void 0;
 }
 async function importsFor(repoPath, filePath, sf) {
   const imports = [];
   for (const stmt of sf.statements) {
-    if (!ts5.isImportDeclaration(stmt) || !ts5.isStringLiteralLike(stmt.moduleSpecifier))
-      continue;
-    const sourceFile = await resolveImport(
-      repoPath,
-      filePath,
-      stmt.moduleSpecifier.text
-    );
+    if (!ts5.isImportDeclaration(stmt) || !ts5.isStringLiteralLike(stmt.moduleSpecifier)) continue;
+    const sourceFile = await resolveImport(repoPath, filePath, stmt.moduleSpecifier.text);
     const clause = stmt.importClause;
     if (!clause) continue;
-    if (clause.name)
-      imports.push({
-        localName: clause.name.text,
-        exportedName: "default",
-        sourceFile
-      });
+    if (clause.name) imports.push({ localName: clause.name.text, exportedName: "default", sourceFile });
     const bindings = clause.namedBindings;
     if (bindings && ts5.isNamedImports(bindings))
-      for (const el of bindings.elements)
-        imports.push({
-          localName: el.name.text,
-          exportedName: el.propertyName?.text ?? el.name.text,
-          sourceFile
-        });
+      for (const el of bindings.elements) imports.push({ localName: el.name.text, exportedName: el.propertyName?.text ?? el.name.text, sourceFile });
   }
   return imports;
 }
+
+// src/parsers/service-binding-parser.ts
 function collectLocalBindingFacts(fn) {
   const bindings = /* @__PURE__ */ new Map();
   function visit(node) {
-    if (node !== fn && (ts5.isFunctionDeclaration(node) || ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)))
+    if (node !== fn && (ts6.isFunctionDeclaration(node) || ts6.isArrowFunction(node) || ts6.isFunctionExpression(node)))
       return;
-    if (ts5.isVariableDeclaration(node) && ts5.isIdentifier(node.name) && node.initializer) {
+    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name) && node.initializer) {
       const fact = findConnectInExpression(node.initializer);
       if (fact) bindings.set(node.name.text, fact);
       const sourceName = transactionReceiverName(node.initializer);
@@ -1572,7 +1536,7 @@ function collectLocalBindingFacts(fn) {
         if (source) bindings.set(node.name.text, { ...source, helperChain: [...source.helperChain ?? [], { aliasOf: sourceName, callerVariable: node.name.text, aliasKind: "transaction", transactionAliasSource: sourceName }] });
       }
     }
-    ts5.forEachChild(node, visit);
+    ts6.forEachChild(node, visit);
   }
   visit(fn);
   return bindings;
@@ -1581,18 +1545,18 @@ function collectReturnedObjectBindings(fn) {
   const bindings = collectLocalBindingFacts(fn);
   const returns = /* @__PURE__ */ new Map();
   function visit(node) {
-    if (node !== fn && (ts5.isFunctionDeclaration(node) || ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)))
+    if (node !== fn && (ts6.isFunctionDeclaration(node) || ts6.isArrowFunction(node) || ts6.isFunctionExpression(node)))
       return;
-    if (ts5.isReturnStatement(node) && node.expression && ts5.isObjectLiteralExpression(node.expression)) {
+    if (ts6.isReturnStatement(node) && node.expression && ts6.isObjectLiteralExpression(node.expression)) {
       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 propertyName = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+        if (ts6.isShorthandPropertyAssignment(prop)) returns.set(prop.name.text, prop.name.text);
+        if (ts6.isPropertyAssignment(prop) && ts6.isIdentifier(prop.initializer)) {
+          const propertyName = ts6.isIdentifier(prop.name) || ts6.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
           if (propertyName) returns.set(propertyName, prop.initializer.text);
         }
       }
     }
-    ts5.forEachChild(node, visit);
+    ts6.forEachChild(node, visit);
   }
   visit(fn);
   const out = /* @__PURE__ */ new Map();
@@ -1604,65 +1568,65 @@ function collectReturnedObjectBindings(fn) {
 }
 function functionLikeInitializer(expr) {
   if (!expr) return void 0;
-  if (ts5.isArrowFunction(expr) || ts5.isFunctionExpression(expr)) return expr;
+  if (ts6.isArrowFunction(expr) || ts6.isFunctionExpression(expr)) return expr;
   return void 0;
 }
 function directReturnConnectFact(fn) {
   const localBindings = collectLocalBindingFacts(fn);
   let returned;
   function visit(node) {
-    if (node !== fn && (ts5.isFunctionDeclaration(node) || ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)))
+    if (node !== fn && (ts6.isFunctionDeclaration(node) || ts6.isArrowFunction(node) || ts6.isFunctionExpression(node)))
       return;
-    if (!returned && ts5.isReturnStatement(node) && node.expression)
+    if (!returned && ts6.isReturnStatement(node) && node.expression)
       returned = node.expression;
-    if (!returned) ts5.forEachChild(node, visit);
+    if (!returned) ts6.forEachChild(node, visit);
   }
   visit(fn);
   if (!returned) return void 0;
-  if (ts5.isIdentifier(returned)) return localBindings.get(returned.text);
+  if (ts6.isIdentifier(returned)) return localBindings.get(returned.text);
   return findConnectInExpression(returned);
 }
 function directConnectFactFromFunctionLike(fn) {
-  if (ts5.isArrowFunction(fn) && fn.body && !ts5.isBlock(fn.body))
+  if (ts6.isArrowFunction(fn) && fn.body && !ts6.isBlock(fn.body))
     return findConnectInExpression(fn.body);
   return directReturnConnectFact(fn);
 }
 function exportedLocalNames(sf) {
   const exports = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    const direct = ts5.canHaveModifiers(stmt) ? ts5.getModifiers(stmt)?.some(
-      (m) => m.kind === ts5.SyntaxKind.ExportKeyword
+    const direct = ts6.canHaveModifiers(stmt) ? ts6.getModifiers(stmt)?.some(
+      (m) => m.kind === ts6.SyntaxKind.ExportKeyword
     ) ?? false : false;
-    if (direct && ts5.isFunctionDeclaration(stmt) && stmt.name)
+    if (direct && ts6.isFunctionDeclaration(stmt) && stmt.name)
       exports.set(stmt.name.text, stmt.name.text);
-    if (direct && ts5.isVariableStatement(stmt)) {
+    if (direct && ts6.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
-        if (ts5.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
+        if (ts6.isIdentifier(decl.name)) exports.set(decl.name.text, decl.name.text);
     }
-    if (!ts5.isExportDeclaration(stmt) || !stmt.exportClause) continue;
-    if (!ts5.isNamedExports(stmt.exportClause)) continue;
+    if (!ts6.isExportDeclaration(stmt) || !stmt.exportClause) continue;
+    if (!ts6.isNamedExports(stmt.exportClause)) continue;
     for (const el of stmt.exportClause.elements)
       exports.set(el.name.text, el.propertyName?.text ?? el.name.text);
   }
   return exports;
 }
 async function helperBindings(repoPath, filePath) {
-  const sf = await readSource(path8.join(repoPath, filePath));
+  const sf = await readSource(path9.join(repoPath, filePath));
   if (!sf) return [];
   const sourceFileAst = sf;
   const out = [];
   const exportedLocals = exportedLocalNames(sf);
   const factsByLocal = /* @__PURE__ */ new Map();
   for (const stmt of sf.statements) {
-    if (ts5.isFunctionDeclaration(stmt) && stmt.name) {
+    if (ts6.isFunctionDeclaration(stmt) && stmt.name) {
       const fact = directConnectFactFromFunctionLike(stmt);
       if (fact) factsByLocal.set(stmt.name.text, { ...fact, sourceLine: lineOf4(sf, stmt) });
       for (const [returnedProperty, objectFact] of collectReturnedObjectBindings(stmt))
         factsByLocal.set(`${stmt.name.text}#${returnedProperty}`, { ...objectFact, returnedProperty, sourceLine: lineOf4(sf, stmt) });
     }
-    if (ts5.isVariableStatement(stmt))
+    if (ts6.isVariableStatement(stmt))
       for (const decl of stmt.declarationList.declarations) {
-        if (!ts5.isIdentifier(decl.name) || !decl.initializer) continue;
+        if (!ts6.isIdentifier(decl.name) || !decl.initializer) continue;
         const helper = functionLikeInitializer(decl.initializer);
         if (helper) {
           const directReturn = directConnectFactFromFunctionLike(helper);
@@ -1708,7 +1672,7 @@ async function helperBindings(repoPath, filePath) {
   return out;
 }
 async function parseServiceBindings(repoPath, filePath) {
-  const sf = await readSource(path8.join(repoPath, filePath));
+  const sf = await readSource(path9.join(repoPath, filePath));
   if (!sf) return [];
   const sourceFileAst = sf;
   const out = [];
@@ -1717,8 +1681,9 @@ async function parseServiceBindings(repoPath, filePath) {
   const classHelpers = collectClassHelpers(sourceFileAst);
   const localObjectHelpers = /* @__PURE__ */ new Map();
   const localDirectHelpers = /* @__PURE__ */ new Map();
+  const objectHelperVariables = /* @__PURE__ */ new Map();
   for (const stmt of sourceFileAst.statements) {
-    if (ts5.isFunctionDeclaration(stmt) && stmt.name) {
+    if (ts6.isFunctionDeclaration(stmt) && stmt.name) {
       const directFact = directConnectFactFromFunctionLike(stmt);
       if (directFact) localDirectHelpers.set(stmt.name.text, { ...directFact, exportedName: stmt.name.text, sourceFile: normalizePath(filePath), sourceLine: lineOf4(sourceFileAst, stmt) });
       const rows2 = [];
@@ -1726,9 +1691,9 @@ async function parseServiceBindings(repoPath, filePath) {
         rows2.push({ ...fact, exportedName: stmt.name.text, returnedProperty, sourceFile: normalizePath(filePath), sourceLine: lineOf4(sourceFileAst, stmt) });
       if (rows2.length > 0) localObjectHelpers.set(stmt.name.text, rows2);
     }
-    if (ts5.isVariableStatement(stmt)) {
+    if (ts6.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) {
-        if (!ts5.isIdentifier(decl.name)) continue;
+        if (!ts6.isIdentifier(decl.name)) continue;
         const helper = functionLikeInitializer(decl.initializer);
         if (!helper) continue;
         const directFact = directConnectFactFromFunctionLike(helper);
@@ -1777,9 +1742,9 @@ async function parseServiceBindings(repoPath, filePath) {
     });
   }
   function recordIdentityAlias(decl) {
-    if (!ts5.isIdentifier(decl.name) || !decl.initializer) return;
+    if (!ts6.isIdentifier(decl.name) || !decl.initializer) return;
     const unwrapped = unwrapIdentityExpression(decl.initializer);
-    if (!ts5.isIdentifier(unwrapped)) return;
+    if (!ts6.isIdentifier(unwrapped)) return;
     cloneAliasBinding(decl.name.text, unwrapped.text, "identity", decl);
   }
   async function recordBindingFromExpression(targetName, expr, node, aliasKind) {
@@ -1794,7 +1759,7 @@ async function parseServiceBindings(repoPath, filePath) {
         sourceLine: lineOf4(sourceFileAst, node),
         helperChain: aliasKind === "assignment" ? [{ callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind, scopeRule: "same-file-source-order" }] : void 0
       });
-    else if (ts5.isIdentifier(call.expression)) {
+    else if (ts6.isIdentifier(call.expression)) {
       const localDirect = localDirectHelpers.get(call.expression.text);
       const resolved2 = localDirect ? { helper: localDirect, imp: void 0 } : await importedHelper(call.expression.text);
       if (resolved2)
@@ -1824,24 +1789,64 @@ async function parseServiceBindings(repoPath, filePath) {
     }
   }
   async function recordVariable(decl) {
-    if (!ts5.isIdentifier(decl.name) || !decl.initializer) return;
+    if (!ts6.isIdentifier(decl.name) || !decl.initializer) return;
     await recordBindingFromExpression(decl.name.text, decl.initializer, decl, "declaration");
   }
   async function helpersForCall(call) {
-    if (!ts5.isIdentifier(call.expression)) return [];
+    if (!ts6.isIdentifier(call.expression)) return [];
     const local = localObjectHelpers.get(call.expression.text) ?? [];
     const imported = await importedHelpers(call.expression.text);
     return [...local.map((helper) => ({ helper })), ...imported];
   }
+  async function rememberObjectHelperVariable(decl) {
+    if (!ts6.isIdentifier(decl.name) || !decl.initializer) return;
+    const call = unwrapCall(decl.initializer);
+    if (!call) return;
+    const helpers = (await helpersForCall(call)).filter((row) => row.helper.returnedProperty);
+    if (helpers.length > 0) objectHelperVariables.set(decl.name.text, helpers);
+  }
+  function recordObjectPropertyBinding(targetName, expr, node) {
+    const unwrapped = unwrapIdentityExpression(expr);
+    if (!ts6.isPropertyAccessExpression(unwrapped) || !ts6.isIdentifier(unwrapped.expression)) return false;
+    const helpers = objectHelperVariables.get(unwrapped.expression.text) ?? [];
+    const matches = helpers.filter((row) => row.helper.returnedProperty === unwrapped.name.text);
+    if (matches.length !== 1) return false;
+    const resolved2 = matches[0];
+    out.push({
+      variableName: targetName,
+      alias: resolved2.helper.alias,
+      aliasExpr: resolved2.helper.aliasExpr,
+      destinationExpr: resolved2.helper.destinationExpr,
+      servicePathExpr: resolved2.helper.servicePathExpr,
+      isDynamic: resolved2.helper.isDynamic,
+      placeholders: resolved2.helper.placeholders,
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf4(sourceFileAst, node),
+      helperChain: [
+        ...resolved2.helper.helperChain ?? [],
+        {
+          callerVariable: targetName,
+          sourceVariable: unwrapped.expression.text,
+          returnedProperty: unwrapped.name.text,
+          assignedFromProperty: unwrapped.getText(sourceFileAst),
+          importSource: resolved2.imp?.sourceFile,
+          exportedSymbol: resolved2.imp?.exportedName,
+          helperSourceFile: resolved2.helper.sourceFile,
+          helperSourceLine: resolved2.helper.sourceLine
+        }
+      ]
+    });
+    return true;
+  }
   async function recordDestructuredHelper(decl) {
-    if (!ts5.isObjectBindingPattern(decl.name) || !decl.initializer) return;
+    if (!ts6.isObjectBindingPattern(decl.name) || !decl.initializer) return;
     const call = unwrapCall(decl.initializer);
     if (!call) return;
     const helpers = await helpersForCall(call);
     if (helpers.length === 0) return;
     for (const el of decl.name.elements) {
-      if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      if (!ts6.isIdentifier(el.name)) continue;
+      const propertyName = el.propertyName && ts6.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const matches = helpers.filter((row) => row.helper.returnedProperty === propertyName);
       if (matches.length !== 1) continue;
       const resolved2 = matches[0];
@@ -1867,12 +1872,12 @@ async function parseServiceBindings(repoPath, filePath) {
     for (const prop of pattern.properties) {
       let propertyName;
       let targetName;
-      if (ts5.isShorthandPropertyAssignment(prop)) {
+      if (ts6.isShorthandPropertyAssignment(prop)) {
         propertyName = prop.name.text;
         targetName = prop.name.text;
-      } else if (ts5.isPropertyAssignment(prop)) {
-        propertyName = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
-        targetName = ts5.isIdentifier(prop.initializer) ? prop.initializer.text : void 0;
+      } else if (ts6.isPropertyAssignment(prop)) {
+        propertyName = ts6.isIdentifier(prop.name) || ts6.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+        targetName = ts6.isIdentifier(prop.initializer) ? prop.initializer.text : void 0;
       }
       if (!propertyName || !targetName) continue;
       const matches = helpers.filter((row) => row.helper.returnedProperty === propertyName);
@@ -1893,14 +1898,14 @@ async function parseServiceBindings(repoPath, filePath) {
     }
   }
   function recordDestructuredClassHelper(decl) {
-    if (!ts5.isObjectBindingPattern(decl.name) || !decl.initializer) return;
+    if (!ts6.isObjectBindingPattern(decl.name) || !decl.initializer) return;
     const call = unwrapCall(decl.initializer);
-    if (!call || !ts5.isPropertyAccessExpression(call.expression)) return;
+    if (!call || !ts6.isPropertyAccessExpression(call.expression)) return;
     const target = call.expression;
-    if (target.expression.kind !== ts5.SyntaxKind.ThisKeyword) return;
+    if (target.expression.kind !== ts6.SyntaxKind.ThisKeyword) return;
     for (const el of decl.name.elements) {
-      if (!ts5.isIdentifier(el.name)) continue;
-      const propertyName = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
+      if (!ts6.isIdentifier(el.name)) continue;
+      const propertyName = el.propertyName && ts6.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const helper = classHelpers.find(
         (h) => h.helperName === target.name.text && h.propertyName === propertyName
       );
@@ -1926,14 +1931,14 @@ async function parseServiceBindings(repoPath, filePath) {
   }
   function arrayElementsFromExpression(expr) {
     const unwrapped = unwrapIdentityExpression(expr);
-    if (ts5.isArrayLiteralExpression(unwrapped)) return { elements: unwrapped.elements, promiseAll: false };
+    if (ts6.isArrayLiteralExpression(unwrapped)) return { elements: unwrapped.elements, promiseAll: false };
     const call = unwrapCall(expr);
     if (!call) return void 0;
-    if (!ts5.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "all" || call.expression.expression.getText(sourceFileAst) !== "Promise") return void 0;
+    if (!ts6.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "all" || call.expression.expression.getText(sourceFileAst) !== "Promise") return void 0;
     const first = call.arguments[0];
     if (!first) return void 0;
     const container = unwrapIdentityExpression(first);
-    if (!ts5.isArrayLiteralExpression(container)) return void 0;
+    if (!ts6.isArrayLiteralExpression(container)) return void 0;
     return { elements: container.elements, promiseAll: true };
   }
   async function recordArrayElementBinding(targetName, expr, node, arrayIndex, promiseAll) {
@@ -1948,7 +1953,7 @@ async function parseServiceBindings(repoPath, filePath) {
       return;
     }
     const unwrapped = unwrapIdentityExpression(expr);
-    if (ts5.isIdentifier(unwrapped)) {
+    if (ts6.isIdentifier(unwrapped)) {
       const existing = bindingForVariable(unwrapped.text);
       if (!existing) return;
       out.push({
@@ -1963,15 +1968,15 @@ async function parseServiceBindings(repoPath, filePath) {
     }
   }
   async function recordArrayDestructuredVariable(decl) {
-    if (!ts5.isArrayBindingPattern(decl.name) || !decl.initializer) return;
+    if (!ts6.isArrayBindingPattern(decl.name) || !decl.initializer) return;
     const container = arrayElementsFromExpression(decl.initializer);
     if (!container) return;
     for (let index = 0; index < decl.name.elements.length; index += 1) {
       const el = decl.name.elements[index];
-      if (!el || ts5.isOmittedExpression(el) || ts5.isBindingElement(el) && el.dotDotDotToken) continue;
-      if (!ts5.isBindingElement(el) || !ts5.isIdentifier(el.name)) continue;
+      if (!el || ts6.isOmittedExpression(el) || ts6.isBindingElement(el) && el.dotDotDotToken) continue;
+      if (!ts6.isBindingElement(el) || !ts6.isIdentifier(el.name)) continue;
       const source = container.elements[index];
-      if (!source || ts5.isOmittedExpression(source)) continue;
+      if (!source || ts6.isOmittedExpression(source)) continue;
       await recordArrayElementBinding(el.name.text, source, decl, index, container.promiseAll);
     }
   }
@@ -1980,49 +1985,52 @@ async function parseServiceBindings(repoPath, filePath) {
     if (!container) return;
     for (let index = 0; index < pattern.elements.length; index += 1) {
       const el = pattern.elements[index];
-      if (!el || ts5.isOmittedExpression(el) || ts5.isSpreadElement(el) || !ts5.isIdentifier(el)) continue;
+      if (!el || ts6.isOmittedExpression(el) || ts6.isSpreadElement(el) || !ts6.isIdentifier(el)) continue;
       const source = container.elements[index];
-      if (!source || ts5.isOmittedExpression(source)) continue;
+      if (!source || ts6.isOmittedExpression(source)) continue;
       await recordArrayElementBinding(el.text, source, node, index, container.promiseAll);
     }
   }
   const events = [];
   function collectEvents(node) {
-    if (ts5.isVariableDeclaration(node)) events.push({ pos: node.getStart(sourceFileAst), node });
-    if (ts5.isBinaryExpression(node) && node.operatorToken.kind === ts5.SyntaxKind.EqualsToken)
+    if (ts6.isVariableDeclaration(node)) events.push({ pos: node.getStart(sourceFileAst), node });
+    if (ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.EqualsToken)
       events.push({ pos: node.getStart(sourceFileAst), node });
-    ts5.forEachChild(node, collectEvents);
+    ts6.forEachChild(node, collectEvents);
   }
   collectEvents(sourceFileAst);
   events.sort((a, b) => a.pos - b.pos);
   for (const event of events) {
-    if (ts5.isVariableDeclaration(event.node)) {
+    if (ts6.isVariableDeclaration(event.node)) {
       const decl = event.node;
       await recordDestructuredHelper(decl);
       await recordArrayDestructuredVariable(decl);
       recordDestructuredClassHelper(decl);
+      await rememberObjectHelperVariable(decl);
+      if (ts6.isIdentifier(decl.name) && decl.initializer) recordObjectPropertyBinding(decl.name.text, decl.initializer, decl);
       await recordVariable(decl);
       recordIdentityAlias(decl);
-      if (ts5.isIdentifier(decl.name) && decl.initializer) {
+      if (ts6.isIdentifier(decl.name) && decl.initializer) {
         const sourceName = transactionReceiverName(decl.initializer);
         if (sourceName) cloneAliasBinding(decl.name.text, sourceName, "transaction", decl);
       }
       continue;
     }
     const assignment = event.node;
-    if (ts5.isIdentifier(assignment.left)) {
+    if (ts6.isIdentifier(assignment.left)) {
       const rhs = unwrapIdentityExpression(assignment.right);
-      if (ts5.isIdentifier(rhs)) {
+      if (ts6.isIdentifier(rhs)) {
         cloneAliasBinding(assignment.left.text, rhs.text, "identity-assignment", assignment);
         continue;
       }
+      if (recordObjectPropertyBinding(assignment.left.text, assignment.right, assignment)) continue;
       await recordBindingFromExpression(assignment.left.text, assignment.right, assignment, "assignment");
       continue;
     }
-    const left = ts5.isParenthesizedExpression(assignment.left) ? assignment.left.expression : assignment.left;
-    if (ts5.isObjectLiteralExpression(left))
+    const left = ts6.isParenthesizedExpression(assignment.left) ? assignment.left.expression : assignment.left;
+    if (ts6.isObjectLiteralExpression(left))
       await recordDestructuredAssignment(left, assignment.right, assignment);
-    if (ts5.isArrayLiteralExpression(left))
+    if (ts6.isArrayLiteralExpression(left))
       await recordArrayDestructuredAssignment(left, assignment.right, assignment);
   }
   return out;
@@ -2030,16 +2038,16 @@ async function parseServiceBindings(repoPath, filePath) {
 function collectClassHelpers(sf) {
   const helpers = [];
   for (const stmt of sf.statements) {
-    if (!ts5.isClassDeclaration(stmt) || !stmt.name) continue;
+    if (!ts6.isClassDeclaration(stmt) || !stmt.name) continue;
     for (const member of stmt.members) {
       let visit2 = function(node) {
-        if (ts5.isVariableDeclaration(node) && ts5.isIdentifier(node.name) && node.initializer) {
+        if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name) && node.initializer) {
           const fact = findConnectInExpression(node.initializer);
           if (fact) bindings.set(node.name.text, fact);
         }
-        if (ts5.isReturnStatement(node) && node.expression && ts5.isObjectLiteralExpression(node.expression)) {
+        if (ts6.isReturnStatement(node) && node.expression && ts6.isObjectLiteralExpression(node.expression)) {
           for (const prop of node.expression.properties) {
-            if (ts5.isShorthandPropertyAssignment(prop)) {
+            if (ts6.isShorthandPropertyAssignment(prop)) {
               const fact = bindings.get(prop.name.text);
               if (fact)
                 helpers.push({
@@ -2051,8 +2059,8 @@ function collectClassHelpers(sf) {
                   sourceLine: lineOf4(sf, prop)
                 });
             }
-            if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.initializer)) {
-              const propertyName = ts5.isIdentifier(prop.name) || ts5.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+            if (ts6.isPropertyAssignment(prop) && ts6.isIdentifier(prop.initializer)) {
+              const propertyName = ts6.isIdentifier(prop.name) || ts6.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
               const fact = propertyName ? bindings.get(prop.initializer.text) : void 0;
               if (propertyName && fact)
                 helpers.push({
@@ -2066,15 +2074,15 @@ function collectClassHelpers(sf) {
             }
           }
         }
-        ts5.forEachChild(node, visit2);
+        ts6.forEachChild(node, visit2);
       };
       var visit = visit2;
-      if (!ts5.isPropertyDeclaration(member) || !member.initializer) continue;
-      if (!ts5.isIdentifier(member.name)) continue;
+      if (!ts6.isPropertyDeclaration(member) || !member.initializer) continue;
+      if (!ts6.isIdentifier(member.name)) continue;
       const className = stmt.name.text;
       const helperName = member.name.text;
       const initializer = member.initializer;
-      if (!ts5.isArrowFunction(initializer) && !ts5.isFunctionExpression(initializer))
+      if (!ts6.isArrowFunction(initializer) && !ts6.isFunctionExpression(initializer))
         continue;
       const bindings = /* @__PURE__ */ new Map();
       visit2(initializer);
@@ -2519,7 +2527,11 @@ function linkImplementations(db, workspaceId, generation) {
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
     const winners = accepted.filter((candidate) => candidate.score === topScore);
-    const unique = winners.length === 1 ? winners[0] : void 0;
+    const duplicateFamilies = duplicatePackageFamilies(accepted);
+    const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
+    const selected = duplicatePackageAmbiguous ? accepted : winners;
+    const unique = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
+    const ambiguityReasons = duplicatePackageAmbiguous ? ["duplicate_package_name_candidates"] : winners.length > 1 ? ["multiple_equal_score_implementation_candidates"] : [];
     const evidence = {
       servicePath: operation.servicePath,
       operationPath: operation.operationPath,
@@ -2528,6 +2540,8 @@ function linkImplementations(db, workspaceId, generation) {
       implementationSource: implementationContext.operationId === operation.operationId ? "direct_or_concrete_override" : "inherited_from_base_operation",
       baseOperationId: operation.baseOperationId,
       implementationOperationId: implementationContext.operationId,
+      ambiguityReasons,
+      candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
     };
     if (accepted.length === 0) {
@@ -2536,7 +2550,7 @@ function linkImplementations(db, workspaceId, generation) {
       unresolvedCount += 1;
       continue;
     }
-    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", unique ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique ? "handler_method" : "handler_method_candidates", unique ? graphId(unique.methodId) : winners.map((row) => graphId(row.methodId)).join(","), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : "Ambiguous registered handler implementation candidates", generation);
+    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", unique ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique ? "handler_method" : "handler_method_candidates", unique ? graphId(unique.methodId) : selected.map((row) => graphId(row.methodId)).join(","), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : "Ambiguous registered handler implementation candidates", generation);
     edgeCount += 1;
     if (unique) resolvedCount += 1;
     else ambiguousCount += 1;
@@ -2580,6 +2594,18 @@ function uniqueRegistrations(rows2) {
     return true;
   });
 }
+function duplicatePackageFamilies(candidates) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const packageName = typeof candidate.handlerPackage === "string" ? candidate.handlerPackage : void 0;
+    if (!packageName) continue;
+    byPackage.set(packageName, [...byPackage.get(packageName) ?? [], candidate]);
+  }
+  return [...byPackage.entries()].filter(([, rows2]) => new Set(rows2.map((row) => Number(row.handlerRepoId))).size > 1).map(([packageName, rows2]) => ({ reason: "duplicate_package_name_candidates", packageName, count: rows2.length, repositories: rows2.map((row) => row.handlerRepo).sort() }));
+}
+function hasDirectOwnershipEvidence(candidate) {
+  return candidate.acceptedReasons.some((reason) => reason === "model package equals registration package" || reason === "model package equals handler package" || reason === "registration package contains exact local service path");
+}
 function implementationCandidates(db, workspaceId, operation) {
   const modelRepoGraphId = graphId(operation.modelRepoId);
   return db.prepare(`SELECT DISTINCT
@@ -2763,6 +2789,154 @@ function normalizedOperation(value) {
   return value.startsWith("/") ? value.slice(1) : value;
 }
 
+// src/trace/evidence.ts
+function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
+  const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
+  return {
+    ...evidence,
+    graphEdgeId: row.id,
+    persistedGraphEdgeId: row.id > 0 ? row.id : void 0,
+    outboundCallId: call.id,
+    callSite: { sourceFile: call.source_file, sourceLine: call.source_line },
+    sourceFile: call.source_file,
+    sourceLine: call.source_line,
+    file: call.source_file,
+    line: call.source_line,
+    persistedTarget: { kind: row.to_kind, id: row.to_id },
+    contextualResolutionParticipated: Boolean(contextualEvidence?.contextualServiceBindingAttempted),
+    persistedResolution: persistedResolution(row)
+  };
+}
+function runtimeResolution(db, row, evidence, vars, workspaceId) {
+  const substituted = evidenceWithRuntimeVariables(evidence, vars);
+  if (!isRemoteRuntimeCandidate(row, evidence, vars)) {
+    const withSections = withEffectiveResolution(substituted, row, row.unresolved_reason);
+    return { row, evidence: withSections, unresolvedReason: row.unresolved_reason };
+  }
+  const resolution = resolveRuntimeOperation(db, substituted, 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 };
+  }
+  const unresolvedReason = runtimeUnresolvedReason(resolution);
+  return { row, evidence: withEffectiveResolution(substituted, row, unresolvedReason, resolution), unresolvedReason };
+}
+function runtimeVariableDiagnostic(edges) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const substitutions = edge.evidence.runtimeSubstitutions;
+    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 missingVariables = [...missing].sort();
+  if (missingVariables.length === 0) return void 0;
+  return {
+    severity: "warning",
+    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>`)
+  };
+}
+function edgeTarget(row, evidence) {
+  const effective = parseObject(evidence.effectiveResolution);
+  const targetServicePath = stringValue2(effective.targetServicePath ?? evidence.targetServicePath);
+  const targetOperationPath = stringValue2(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 = stringValue2(evidence.servicePath);
+  const operationPath = stringValue2(evidence.operationPath);
+  const targetOperation = stringValue2(evidence.targetOperation);
+  const targetRepo = stringValue2(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 stringValue2(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
+  if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
+    const target = parseObject(evidence.externalTarget);
+    return stringValue2(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
+  }
+  if (servicePath && operationPath) return `${servicePath}${operationPath}`;
+  return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
+}
+function persistedResolution(row) {
+  return {
+    status: row.status,
+    targetKind: row.to_kind,
+    targetId: row.to_id,
+    edgeId: row.id > 0 ? row.id : void 0,
+    confidence: row.confidence,
+    unresolvedReason: row.unresolved_reason,
+    edgeType: row.edge_type
+  };
+}
+function effectiveResolution(row, evidence, unresolvedReason, resolution) {
+  const target = resolution?.target;
+  return {
+    status: target ? "resolved" : row.status,
+    targetKind: target ? "operation" : row.to_kind,
+    targetId: target ? String(target.operationId) : row.to_id,
+    targetRepo: target?.repoName ?? evidence.targetRepo,
+    targetServicePath: target?.servicePath ?? evidence.targetServicePath,
+    targetOperationPath: target?.operationPath ?? evidence.targetOperationPath,
+    targetOperation: target?.operationName ?? evidence.targetOperation,
+    confidence: target?.score ?? row.confidence,
+    reasons: resolution?.reasons ?? evidence.resolutionReasons,
+    unresolvedReason,
+    edgeType: target ? "REMOTE_CALL_RESOLVES_TO_OPERATION" : row.edge_type
+  };
+}
+function withEffectiveResolution(evidence, row, unresolvedReason, resolution) {
+  const current = effectiveResolution(row, evidence, unresolvedReason, resolution);
+  const rest = { ...evidence };
+  delete rest.runtimeResolvedCandidate;
+  return { ...rest, effectiveResolution: current, linker: { status: current.status, confidence: current.confidence, reason: unresolvedReason, edgeType: current.edgeType } };
+}
+function resolveRuntimeOperation(db, evidence, workspaceId) {
+  const servicePath = stringValue2(evidence.servicePath);
+  const operationPath = stringValue2(evidence.normalizedOperationPath ?? evidence.operationPath);
+  const alias = stringValue2(evidence.serviceAliasExpr ?? evidence.serviceAlias);
+  const destination = stringValue2(evidence.destination);
+  return resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceId);
+}
+function evidenceWithRuntimeVariables(evidence, vars) {
+  const substitutions = runtimeSubstitutions(evidence, vars ?? {});
+  const next = { ...evidence, runtimeSubstitutions: substitutions };
+  for (const [key, value] of Object.entries(substitutions)) if (value.effective) next[key] = value.effective;
+  const missing = Object.values(substitutions).flatMap((value) => value.missing);
+  if (missing.length > 0) next.missingRuntimeVariables = [...new Set(missing)].sort();
+  if (Object.keys(vars ?? {}).length > 0) next.runtimeVariablesApplied = true;
+  return next;
+}
+function runtimeSubstitutions(evidence, vars) {
+  const substitutions = {};
+  for (const key of ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"]) {
+    const substitution = substituteVariables(stringValue2(evidence[key]), vars);
+    if (substitution.placeholders.length > 0) substitutions[key] = substitution;
+  }
+  return substitutions;
+}
+function isRemoteRuntimeCandidate(row, evidence, vars) {
+  if (!vars || Object.keys(vars).length === 0) return false;
+  if (!["dynamic", "ambiguous", "unresolved"].includes(String(row.status ?? ""))) return false;
+  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 hasRuntimeVariable(value, vars) {
+  return typeof value === "string" && extractPlaceholders(value).some((key) => Object.hasOwn(vars, key));
+}
+function runtimeUnresolvedReason(resolution) {
+  if (resolution.status === "dynamic") return `Dynamic target is missing runtime variables: ${resolution.reasons.join(", ")}`;
+  if (resolution.status === "ambiguous") return "Ambiguous runtime operation candidates";
+  return "No runtime operation candidate matched substituted service and operation path";
+}
+function parseObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
 // src/trace/trace-engine.ts
 function normalizeOperation(value) {
   if (!value) return void 0;
@@ -2771,7 +2945,7 @@ function normalizeOperation(value) {
 function positiveDepth(value) {
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
 }
-function operationStartScope(db, repoId, start) {
+function operationStartScope(db, repoId, start, implementationRepo) {
   const requested = normalizeOperation(start.operationPath ?? start.operation);
   if (!requested) return void 0;
   const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,s.service_path servicePath,r.id repoId,r.name repoName
@@ -2787,7 +2961,15 @@ function operationStartScope(db, repoId, start) {
   const operationId = String(rows2[0]?.operationId);
   const impl = implementationScope(db, operationId);
   if (impl.edge?.status === "resolved" && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? /* @__PURE__ */ new Set([impl.symbolId]) : void 0, operationId, diagnostics: [] };
-  if (impl.edge) return { operationId, diagnostics: [{ severity: "warning", code: impl.edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved", message: `Indexed operation matched but implementation edge is ${String(impl.edge.status ?? "unresolved")}`, resolutionStage: "implementation", resolutionStatus: impl.edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation", implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, candidates: parseEvidence(impl.edge.evidence_json).candidates }] };
+  const hinted = implementationMethodIdFromHint(impl.edge, implementationRepo);
+  if (hinted.methodId) {
+    const hintedScope = handlerScope(db, hinted.methodId);
+    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? /* @__PURE__ */ new Set([hintedScope.symbolId]) : void 0, operationId, diagnostics: [] };
+  }
+  if (impl.edge) {
+    const evidence = parseEvidence(impl.edge.evidence_json);
+    return { operationId, diagnostics: [{ severity: "warning", code: impl.edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved", message: `Indexed operation matched but implementation edge is ${String(impl.edge.status ?? "unresolved")}`, resolutionStage: "implementation", resolutionStatus: impl.edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation", implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, implementationAmbiguityReasons: evidence.ambiguityReasons, candidates: evidence.candidates }] };
+  }
   return { operationId, diagnostics: [{ severity: "warning", code: "trace_start_implementation_unresolved", message: "Indexed operation matched but no implementation candidate exists", resolutionStage: "implementation", resolutionStatus: "operation_without_implementation" }] };
 }
 function sourceFilesForStart(db, repoId, start) {
@@ -2830,12 +3012,12 @@ function sourceFilesForStart(db, repoId, start) {
   }
   return void 0;
 }
-function startScope(db, start) {
+function startScope(db, start, implementationRepo) {
   const repo = start.repo ? db.prepare(
     "SELECT id,name FROM repositories WHERE name=? OR package_name=?"
   ).get(start.repo, start.repo) : void 0;
   if (start.repo && !repo) return { repo, selectorMatched: false };
-  const operationScope = operationStartScope(db, repo?.id, start);
+  const operationScope = operationStartScope(db, repo?.id, start, implementationRepo);
   const terminalOperationScope = operationScope && !operationScope.files && (operationScope.diagnostics ?? []).some((d) => d.resolutionStage === "operation" || d.resolutionStage === "implementation");
   const sourceScope = operationScope?.files || terminalOperationScope ? operationScope : sourceFilesForStart(db, repo?.id, start);
   const sourceFiles = sourceScope?.files;
@@ -2882,7 +3064,26 @@ function implementationScope(db, operationId) {
   const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.name=hm.method_name WHERE hm.id=?").get(edge.to_id);
   return { repoId: row?.repoId, files: new Set(row?.sourceFile ? [row.sourceFile] : []), symbolId: row?.symbolId, edge };
 }
-function contextImplementationMethodId(edge, callerRepoId, remoteEvidence = {}) {
+function implementationMethodIdFromHint(edge, implementationRepo) {
+  if (!edge || edge.status !== "ambiguous" || !implementationRepo) return { evidence: { status: "not_applicable" } };
+  const evidence = parseEvidence(edge.evidence_json);
+  const matches = (evidence.candidates ?? []).filter((item) => item.accepted && (item.handlerPackage?.name === implementationRepo || item.handlerPackage?.packageName === implementationRepo || item.sourceFile?.startsWith(implementationRepo)));
+  if (matches.length !== 1 || matches[0]?.methodId === void 0) return { evidence: { status: matches.length > 1 ? "tied" : "not_matched", strategy: "implementation_repo_hint", selectedRepo: implementationRepo, candidateCount: matches.length } };
+  return {
+    methodId: String(matches[0].methodId),
+    evidence: {
+      status: "selected",
+      guided: true,
+      strategy: "implementation_repo_hint",
+      selectedRepo: implementationRepo,
+      selectedMethodId: matches[0].methodId,
+      ambiguityReason: evidence.ambiguityReasons?.[0]
+    }
+  };
+}
+function contextImplementationMethodId(edge, callerRepoId, remoteEvidence = {}, implementationRepo) {
+  const hinted = implementationMethodIdFromHint(edge, implementationRepo);
+  if (hinted.methodId) return hinted;
   if (!edge || edge.status !== "ambiguous" || callerRepoId === void 0) return { evidence: { status: "not_applicable" } };
   const evidence = JSON.parse(String(edge.evidence_json || "{}"));
   const scores = (evidence.candidates ?? []).filter((item) => item.accepted).map((item) => {
@@ -2935,31 +3136,6 @@ function graphForCalls(db, callIds) {
   }
   return map;
 }
-function hasRuntimeVariable(value, vars) {
-  return typeof value === "string" && extractPlaceholders(value).some((key) => Object.hasOwn(vars, key));
-}
-function isRemoteRuntimeCandidate(row, evidence, vars) {
-  if (!vars || Object.keys(vars).length === 0) return false;
-  if (!["dynamic", "ambiguous", "unresolved"].includes(String(row.status ?? ""))) return false;
-  if (!["DYNAMIC_EDGE_CANDIDATE", "UNRESOLVED_EDGE", "REMOTE_CALL_RESOLVES_TO_OPERATION"].includes(row.edge_type)) return false;
-  if (row.status === "resolved") return false;
-  return ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"].some((key) => hasRuntimeVariable(evidence[key], vars));
-}
-function evidenceWithRuntimeVariables(evidence, vars) {
-  if (!vars || Object.keys(vars).length === 0) return evidence;
-  const substitutions = {};
-  for (const key of ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"]) {
-    const substitution = substituteVariables(typeof evidence[key] === "string" ? String(evidence[key]) : void 0, vars);
-    if (substitution.placeholders.length > 0) substitutions[key] = substitution;
-  }
-  const next = { ...evidence, runtimeVariablesApplied: true, runtimeSubstitutions: substitutions };
-  for (const [key, value] of Object.entries(substitutions)) {
-    if (value.effective) next[key] = value.effective;
-  }
-  const missing = Object.values(substitutions).flatMap((value) => value.missing);
-  if (missing.length > 0) next.missingRuntimeVariables = [...new Set(missing)];
-  return next;
-}
 function symbolNode(db, symbolId) {
   const row = db.prepare(`SELECT s.id symbolId,s.name symbolName,s.qualified_name qualifiedName,s.source_file sourceFile,s.start_line startLine,s.end_line endLine,r.name repoName,r.id repoId FROM symbols s JOIN repositories r ON r.id=s.repo_id WHERE s.id=?`).get(symbolId);
   if (!row) return void 0;
@@ -2974,24 +3150,6 @@ function operationNode(db, operationId) {
 function workspaceIdForCall(db, callId) {
   return db.prepare("SELECT r.workspace_id workspaceId FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE c.id=?").get(callId)?.workspaceId;
 }
-function runtimeResolution(db, row, evidence, vars) {
-  if (!isRemoteRuntimeCandidate(row, evidence, vars))
-    return { row, evidence, unresolvedReason: row.unresolved_reason };
-  const nextEvidence = evidenceWithRuntimeVariables(evidence, vars);
-  const servicePath = typeof nextEvidence.servicePath === "string" ? nextEvidence.servicePath : void 0;
-  const operationPath = typeof nextEvidence.normalizedOperationPath === "string" ? nextEvidence.normalizedOperationPath : typeof nextEvidence.operationPath === "string" ? nextEvidence.operationPath : void 0;
-  const alias = typeof nextEvidence.serviceAliasExpr === "string" ? nextEvidence.serviceAliasExpr : typeof nextEvidence.serviceAlias === "string" ? nextEvidence.serviceAlias : void 0;
-  const destination = typeof nextEvidence.destination === "string" ? nextEvidence.destination : void 0;
-  const resolution = resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceIdForCall(db, row.from_id));
-  nextEvidence.runtimeResolutionStatus = resolution.status;
-  nextEvidence.runtimeResolutionReasons = resolution.reasons;
-  if (resolution.target) {
-    nextEvidence.runtimeResolvedCandidate = resolution.target;
-    return { row: { ...row, to_kind: "operation", to_id: String(resolution.target.operationId), unresolved_reason: void 0, confidence: Math.max(0, Math.min(1, resolution.target.score)) }, evidence: nextEvidence, target: resolution.target };
-  }
-  const unresolvedReason = resolution.status === "dynamic" ? `Dynamic target is missing runtime variables: ${resolution.reasons.join(", ")}` : resolution.status === "ambiguous" ? "Ambiguous runtime operation candidates" : "No runtime operation candidate matched substituted service and operation path";
-  return { row, evidence: nextEvidence, unresolvedReason };
-}
 function parseEvidence(value) {
   try {
     const parsed = JSON.parse(String(value || "{}"));
@@ -3091,27 +3249,8 @@ function contextualRuntimeResolution(db, call, binding, workspaceId, persistedRo
   if (persistedResolved) return { row: void 0, evidence: { ...resolvedEvidence, contextualPreservedPersistedResolvedEdge: true }, unresolvedReason: void 0 };
   return { row: { id: -Number(call.id), edge_type: "REMOTE_CALL_RESOLVES_TO_OPERATION", from_id: String(call.id), to_kind: "operation", to_id: String(resolution.target.operationId), confidence: resolution.target.score, evidence_json: JSON.stringify(resolvedEvidence), status: "resolved" }, evidence: resolvedEvidence, unresolvedReason: void 0 };
 }
-function edgeTarget(row, evidence) {
-  const runtimeCandidate = evidence.runtimeResolvedCandidate;
-  if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
-    return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
-  const targetServicePath = typeof evidence.targetServicePath === "string" ? evidence.targetServicePath : void 0;
-  const targetOperationPath = typeof evidence.targetOperationPath === "string" ? evidence.targetOperationPath : void 0;
-  if (targetServicePath && targetOperationPath) return `${targetServicePath}${targetOperationPath}`;
-  const servicePath = typeof evidence.servicePath === "string" ? evidence.servicePath : void 0;
-  const operationPath = typeof evidence.operationPath === "string" ? evidence.operationPath : void 0;
-  const targetOperation = typeof evidence.targetOperation === "string" ? evidence.targetOperation : void 0;
-  const targetRepo = typeof evidence.targetRepo === "string" ? 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 typeof evidence.remoteQueryTarget === "string" ? evidence.remoteQueryTarget : `Remote query: ${row.to_id || "unknown"}`;
-  if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
-    const target = evidence.externalTarget;
-    return typeof target?.label === "string" ? target.label : `External endpoint: ${row.to_id || "unknown"}`;
-  }
-  return servicePath && operationPath ? `${servicePath}${operationPath}` : targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
-}
 function trace(db, start, options) {
-  const scope = startScope(db, start);
+  const scope = startScope(db, start, options.implementationRepo);
   const diagnostics = db.prepare(
     "SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics WHERE (? IS NULL OR repo_id=?)"
   ).all(scope.repo?.id, scope.repo?.id);
@@ -3134,12 +3273,14 @@ function trace(db, start, options) {
     const op = operationNode(db, scope.startOperationId);
     const impl = implementationScope(db, scope.startOperationId);
     if (op) nodes.set(String(op.id), op);
-    if (impl.edge && impl.edge.status === "resolved") {
-      const implEvidence = { ...parseEvidence(impl.edge.evidence_json), startResolution: { strategy: "indexed_operation_graph", matchedOperationId: scope.startOperationId, implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, selectedHandlerMethodId: impl.edge.status === "resolved" ? impl.edge.to_id : void 0 } };
-      const handlerNode = impl.edge.status === "resolved" ? handlerMethodNode(db, impl.edge.to_id) : void 0;
+    const startSelection = implementationMethodIdFromHint(impl.edge, options.implementationRepo);
+    if (impl.edge && (impl.edge.status === "resolved" || startSelection.methodId)) {
+      const selectedMethodId = impl.edge.status === "resolved" ? impl.edge.to_id : startSelection.methodId;
+      const implEvidence = { ...parseEvidence(impl.edge.evidence_json), startResolution: { strategy: "indexed_operation_graph", matchedOperationId: scope.startOperationId, implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, selectedHandlerMethodId: selectedMethodId }, implementationSelection: startSelection.methodId ? startSelection.evidence : void 0 };
+      const handlerNode = selectedMethodId ? handlerMethodNode(db, selectedMethodId) : void 0;
       if (handlerNode) nodes.set(String(handlerNode.id), handlerNode);
       seenEdges.add(Number(impl.edge.id));
-      edges.push({ step: 1, type: "operation_implemented_by_handler", from: op?.label ? String(op.label) : `operation:${scope.startOperationId}`, to: handlerNode?.label ? String(handlerNode.label) : `${impl.edge.to_kind}:${impl.edge.to_id}`, evidence: implEvidence, confidence: Number(impl.edge.confidence ?? 0), unresolvedReason: impl.edge.status === "resolved" ? void 0 : String(impl.edge.unresolved_reason ?? impl.edge.status) });
+      edges.push({ step: 1, type: "operation_implemented_by_handler", from: op?.label ? String(op.label) : `operation:${scope.startOperationId}`, to: handlerNode?.label ? String(handlerNode.label) : `${impl.edge.to_kind}:${impl.edge.to_id}`, evidence: implEvidence, confidence: Number(impl.edge.confidence ?? 0), unresolvedReason: impl.edge.status === "resolved" || startSelection.methodId ? void 0 : String(impl.edge.unresolved_reason ?? impl.edge.status) });
     }
   }
   const seenScopes = /* @__PURE__ */ new Set();
@@ -3196,8 +3337,8 @@ function trace(db, start, options) {
         const persistedEvidence = JSON.parse(
           String(row.evidence_json || "{}")
         );
-        const rawEvidence = { ...persistedEvidence, ...contextual.evidence ?? {}, graphEdgeId: row.id, persistedGraphEdgeId: row.id > 0 ? row.id : void 0, outboundCallId: call.id, callSite: { sourceFile: call.source_file, sourceLine: call.source_line }, sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, linker: { status: row.status, confidence: row.confidence, reason: row.unresolved_reason, edgeType: row.edge_type }, persistedTarget: { kind: row.to_kind, id: row.to_id }, contextualResolutionParticipated: Boolean(contextual.evidence?.contextualServiceBindingAttempted) };
-        const effective = runtimeResolution(db, row, rawEvidence, options.vars);
+        const rawEvidence = baseTraceEvidence(row, call, persistedEvidence, contextual.evidence);
+        const effective = runtimeResolution(db, row, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)));
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
@@ -3219,7 +3360,7 @@ function trace(db, start, options) {
         });
         if (effectiveRow.to_kind === "operation") {
           const implementation = implementationScope(db, effectiveRow.to_id);
-          const contextSelection = contextImplementationMethodId(implementation.edge, current.repoId, evidence);
+          const contextSelection = contextImplementationMethodId(implementation.edge, current.repoId, evidence, options.implementationRepo);
           const contextMethodId = contextSelection.methodId;
           const contextNode = contextMethodId ? handlerMethodNode(db, contextMethodId) : void 0;
           if (implementation.edge) {
@@ -3232,7 +3373,7 @@ function trace(db, start, options) {
               type: "operation_implemented_by_handler",
               from: to,
               to: implTo,
-              evidence: contextMethodId ? { ...implEvidence, contextualImplementationSelected: true, contextualImplementation: contextSelection.evidence } : { ...implEvidence, contextualImplementation: contextSelection.evidence },
+              evidence: contextMethodId ? { ...implEvidence, contextualImplementationSelected: contextSelection.evidence.strategy !== "implementation_repo_hint", contextualImplementation: contextSelection.evidence, implementationSelection: contextSelection.evidence } : { ...implEvidence, contextualImplementation: contextSelection.evidence },
               confidence: Number(implementation.edge.confidence ?? 0),
               unresolvedReason: implementation.edge.status === "resolved" || contextMethodId ? void 0 : String(implementation.edge.unresolved_reason ?? implementation.edge.status)
             });
@@ -3268,6 +3409,8 @@ function trace(db, start, options) {
       }
     }
   }
+  const runtimeDiagnostic = runtimeVariableDiagnostic(edges);
+  if (runtimeDiagnostic) diagnostics.unshift(runtimeDiagnostic);
   return { start, nodes: [...nodes.values()], edges, diagnostics };
 }
 
@@ -3292,4 +3435,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-RP3BJ64F.js.map
+//# sourceMappingURL=chunk-UKNPHTUS.js.map