@saptools/service-flow 0.1.55 → 0.1.57

package/dist/{chunk-GXYVIHJ5.js → chunk-DCOFNDKS.js}

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// src/db/repositories.ts
+import { posix } from "path";
+
 // src/utils/000-bounded-projection.ts
 var DEFAULT_EVIDENCE_CANDIDATE_LIMIT = 5;
 function projectBounded(values, compare, limit = DEFAULT_EVIDENCE_CANDIDATE_LIMIT) {
@@ -387,34 +390,86 @@ function insertSymbolCalls(db, repoId, rows2) {
   for (const r of rows2) {
     const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName);
     const target = resolveSymbolCallTarget(db, repoId, r);
-    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount }), target.reason);
+    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount, resolvedModulePath: target.resolvedModulePath }), target.reason);
   }
 }
+var stripExt = (value) => value.replace(/\.(ts|tsx|js|jsx|cds)$/, "");
+function symbolTargetRows(rows2) {
+  return rows2.flatMap((row) => typeof row.id === "number" ? [{ id: row.id, kind: typeof row.kind === "string" ? row.kind : void 0, sourceFile: nullableString(row.sourceFile), evidenceJson: nullableString(row.evidenceJson) }] : []);
+}
+function relativeModuleTargets(callerSourceFile, importSource) {
+  const base = posix.dirname(callerSourceFile);
+  const joined = stripExt(posix.normalize(posix.join(base, importSource)));
+  return /* @__PURE__ */ new Set([joined, `${joined}/index`]);
+}
+function moduleRows(rows2, r) {
+  if (!r.importSource) return [];
+  const targets = relativeModuleTargets(r.sourceFile, r.importSource);
+  return rows2.filter((row) => typeof row.sourceFile === "string" && targets.has(stripExt(row.sourceFile)));
+}
+function resolvedSymbol(row, strategy, candidateCount, moduleScoped = false) {
+  return { id: row.id, status: "resolved", reason: null, strategy, candidateCount, resolvedModulePath: moduleScoped && row.sourceFile ? stripExt(row.sourceFile) : void 0 };
+}
+function exportedSymbolRows(db, repoId, r) {
+  return symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName));
+}
 function isRelativeImportedSymbolCall(r) {
   return Boolean(r.importSource?.startsWith("."));
 }
+function sameFileResolution(db, repoId, r, relation) {
+  const bareImport = relation === "relative_import" && isRelativeImportedSymbolCall(r) && !String(r.calleeLocalName).includes(".");
+  if (bareImport || relation === "relative_import_namespace_member" || relation === "package_import") return void 0;
+  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName));
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "same_file_exact", 1);
+  return rows2.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple same-file symbol targets matched exactly", strategy: "same_file_exact", candidateCount: rows2.length } : void 0;
+}
+function classInstanceResolution(db, repoId, r, relation) {
+  if (relation !== "class_instance_method" || !isRelativeImportedSymbolCall(r)) return void 0;
+  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "relative_import_class_instance_method", 1);
+  return rows2.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple relative class instance method targets matched exactly", strategy: "relative_import_class_instance_method", candidateCount: rows2.length } : void 0;
+}
+function namespaceResolution(db, repoId, r, relation) {
+  if (relation !== "relative_import_namespace_member" || !isRelativeImportedSymbolCall(r)) return void 0;
+  const rows2 = moduleRows(exportedSymbolRows(db, repoId, r), r);
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "relative_import_namespace_member", 1, true);
+  if (rows2.length > 1) return { id: null, status: "ambiguous", reason: "Multiple namespace member targets matched the imported module", strategy: "relative_import_namespace_member", candidateCount: rows2.length };
+  return { id: null, status: "unresolved", reason: "No namespace member target matched the imported module", strategy: "relative_import_namespace_member", candidateCount: 0 };
+}
+function proxyResolution(rows2, r, relation) {
+  if (relation !== "relative_import_proxy_member" || rows2.length <= 1) return void 0;
+  const mapped = rows2.filter((row) => String(row.evidenceJson ?? "").includes("exported_object_shorthand") || String(row.evidenceJson ?? "").includes("exported_object_literal"));
+  if (mapped.length > 0) {
+    const concrete = rows2.find((row) => row.kind !== "object_alias") ?? mapped[0];
+    return { id: concrete?.id ?? null, status: "resolved", reason: null, strategy: "proxy_member_exported_object_map", candidateCount: rows2.length };
+  }
+  const scoped = moduleRows(rows2, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
+  return { id: null, status: "ambiguous", reason: "Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous", strategy: "proxy_member_no_global_name_fallback", candidateCount: rows2.length };
+}
+function exportedResolution(rows2, r, relation) {
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], relation === "relative_import_proxy_member" ? "proxy_member_unique_exported_candidate" : "relative_import_exported_exact", 1, moduleRows(rows2, r).length === 1);
+  if (rows2.length <= 1) return void 0;
+  const scoped = isRelativeImportedSymbolCall(r) ? moduleRows(rows2, r) : [];
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
+  return { id: null, status: "ambiguous", reason: "Multiple exported symbol targets matched exactly", strategy: "exported_exact", candidateCount: rows2.length };
+}
+function accessorResolution(db, repoId, r, relation) {
+  if (relation !== "relative_import" || !isRelativeImportedSymbolCall(r) || !/^[^.]+\.[^.]+$/.test(String(r.calleeLocalName))) return void 0;
+  const methodRows = symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile FROM symbols WHERE repo_id=? AND source_file<>? AND kind='method' AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  const scoped = moduleRows(methodRows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_static_accessor_instance_method", 1, true);
+  return scoped.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple static-accessor instance method targets matched the imported module", strategy: "relative_import_static_accessor_instance_method", candidateCount: scoped.length } : void 0;
+}
 function resolveSymbolCallTarget(db, repoId, r) {
-  const evidence = r.evidence;
-  const localRows = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName);
-  if (localRows.length === 1) return { id: localRows[0]?.id ?? null, status: "resolved", reason: null, strategy: "same_file_exact", candidateCount: 1 };
-  if (localRows.length > 1) return { id: null, status: "ambiguous", reason: "Multiple same-file symbol targets matched exactly", strategy: "same_file_exact", candidateCount: localRows.length };
-  if (evidence.relation === "class_instance_method" && isRelativeImportedSymbolCall(r)) {
-    const classRows = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName);
-    if (classRows.length === 1) return { id: classRows[0]?.id ?? null, status: "resolved", reason: null, strategy: "relative_import_class_instance_method", candidateCount: 1 };
-    if (classRows.length > 1) return { id: null, status: "ambiguous", reason: "Multiple relative class instance method targets matched exactly", strategy: "relative_import_class_instance_method", candidateCount: classRows.length };
-  }
-  const rows2 = db.prepare("SELECT id,kind,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName);
-  if (evidence.relation === "relative_import_proxy_member" && rows2.length > 1) {
-    const objectMapRows = rows2.filter((row) => String(row.evidenceJson ?? "").includes("exported_object_shorthand") || String(row.evidenceJson ?? "").includes("exported_object_literal"));
-    if (objectMapRows.length > 0) {
-      const concrete = rows2.find((row) => row.kind !== "object_alias") ?? objectMapRows[0];
-      return { id: concrete?.id ?? null, status: "resolved", reason: null, strategy: "proxy_member_exported_object_map", candidateCount: rows2.length };
-    }
-    return { id: null, status: "ambiguous", reason: "Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous", strategy: "proxy_member_no_global_name_fallback", candidateCount: rows2.length };
-  }
-  if (rows2.length === 1) return { id: rows2[0]?.id ?? null, status: "resolved", reason: null, strategy: evidence.relation === "relative_import_proxy_member" ? "proxy_member_unique_exported_candidate" : "relative_import_exported_exact", candidateCount: 1 };
-  if (rows2.length > 1) return { id: null, status: "ambiguous", reason: "Multiple exported symbol targets matched exactly", strategy: "exported_exact", candidateCount: rows2.length };
-  return { id: null, status: "unresolved", reason: "No local symbol target matched exactly", strategy: evidence.relation === "relative_import_proxy_member" ? "proxy_member_no_global_name_fallback" : "exact_symbol_match", candidateCount: 0 };
+  const relation = r.evidence.relation;
+  const early = sameFileResolution(db, repoId, r, relation) ?? classInstanceResolution(db, repoId, r, relation) ?? namespaceResolution(db, repoId, r, relation);
+  if (early) return early;
+  const rows2 = relation === "package_import" ? [] : exportedSymbolRows(db, repoId, r);
+  const matched = proxyResolution(rows2, r, relation) ?? exportedResolution(rows2, r, relation) ?? accessorResolution(db, repoId, r, relation);
+  if (matched) return matched;
+  if (relation === "package_import") return { id: null, status: "unresolved", reason: "Package import target resolution requires a post-publication workspace pass", strategy: "package_import_unresolved", candidateCount: 0 };
+  return { id: null, status: "unresolved", reason: "No local symbol target matched exactly", strategy: relation === "relative_import_proxy_member" ? "proxy_member_no_global_name_fallback" : "exact_symbol_match", candidateCount: 0 };
 }
 function insertCalls(db, repoId, rows2) {
   const stmt = db.prepare(
@@ -2303,7 +2358,7 @@ function collectClassHelpers(sf) {
 // src/parsers/outbound-call-parser.ts
 import fs8 from "fs/promises";
 import path11 from "path";
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // src/linker/external-http-target.ts
 import { createHash } from "crypto";
@@ -3019,49 +3074,8 @@ function literal(expr) {
   return expr && (ts7.isStringLiteralLike(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) ? expr.text : void 0;
 }
 
-// src/parsers/outbound-call-parser.ts
-function lineOf4(text, idx) {
-  return text.slice(0, idx).split("\n").length;
-}
-function entityFromExpression(expr) {
-  if (!expr) return void 0;
-  if (ts8.isIdentifier(expr) || ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
-  if (ts8.isPropertyAccessExpression(expr) && expr.expression.kind === ts8.SyntaxKind.ThisKeyword) return expr.name.text;
-  if (ts8.isElementAccessExpression(expr) && expr.argumentExpression && (ts8.isStringLiteral(expr.argumentExpression) || ts8.isNoSubstitutionTemplateLiteral(expr.argumentExpression))) return expr.argumentExpression.text;
-  return void 0;
-}
-function expressionName(expr) {
-  if (ts8.isIdentifier(expr)) return expr.text;
-  if (ts8.isPropertyAccessExpression(expr)) return `${expressionName(expr.expression)}.${expr.name.text}`;
-  return expr.getText();
-}
-function variableInitializers(source) {
-  const initializers = /* @__PURE__ */ new Map();
-  for (const statement of source.statements) {
-    if (!ts8.isVariableStatement(statement) || (statement.declarationList.flags & ts8.NodeFlags.Const) === 0) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (ts8.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
-    }
-  }
-  return initializers;
-}
-function unwrapQueryExpression(expr) {
-  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr) || ts8.isAsExpression(expr) || ts8.isTypeAssertionExpression(expr) || ts8.isNonNullExpression(expr) || ts8.isSatisfiesExpression(expr))
-    return unwrapQueryExpression(expr.expression);
-  return expr;
-}
-function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map()) {
-  const unwrapped = unwrapQueryExpression(expr);
-  if (ts8.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text), initializers);
-  if (ts8.isCallExpression(unwrapped)) {
-    const name = expressionName(unwrapped.expression);
-    if (name === "cds.run") return queryEntityFromAst(unwrapped.arguments[0], initializers);
-    if (capQueryBuilderRoots.has(name)) return entityFromExpression(unwrapped.arguments[0]);
-    const receiver = ts8.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : void 0;
-    if (receiver) return queryEntityFromAst(receiver, initializers);
-  }
-  return void 0;
-}
+// src/parsers/000-direct-query-execution.ts
+import ts8 from "typescript";
 var capQueryBuilderRoots = /* @__PURE__ */ new Set([
   "SELECT.from",
   "SELECT.one.from",
@@ -3072,6 +3086,44 @@ var capQueryBuilderRoots = /* @__PURE__ */ new Set([
   "UPDATE",
   "DELETE.from"
 ]);
+var promiseValueShadowCache = /* @__PURE__ */ new WeakMap();
+function isCapQueryBuilderRootName(name) {
+  return capQueryBuilderRoots.has(name);
+}
+function queryBuilderRoot(expression) {
+  const unwrapped = unwrapQueryExpression(expression);
+  if (!ts8.isCallExpression(unwrapped)) return void 0;
+  if (isCapQueryBuilderRootName(expressionName(unwrapped.expression)))
+    return unwrapped;
+  return ts8.isPropertyAccessExpression(unwrapped.expression) ? queryBuilderRoot(unwrapped.expression.expression) : void 0;
+}
+function directQueryBuilderStatement(node) {
+  const root = queryBuilderRoot(node);
+  if (!root) return void 0;
+  const logicalCall = outerFluentQueryCall(root);
+  if (logicalCall !== node) return void 0;
+  const expression = outerTransparentExpression(logicalCall);
+  const awaitExpression = directAwaitExpression(expression);
+  if (awaitExpression)
+    return { root, logicalCall, statement: awaitExpression, executionContext: "await" };
+  const returnContext = returnExecutionContext(expression);
+  if (returnContext)
+    return { root, logicalCall, statement: expression, executionContext: returnContext };
+  if (isAwaitedPromiseAllElement(expression))
+    return { root, logicalCall, statement: expression, executionContext: "promise_aggregate" };
+  return void 0;
+}
+function expressionName(expression) {
+  if (ts8.isIdentifier(expression)) return expression.text;
+  if (ts8.isPropertyAccessExpression(expression))
+    return `${expressionName(expression.expression)}.${expression.name.text}`;
+  return expression.getText();
+}
+function unwrapQueryExpression(expression) {
+  if (ts8.isParenthesizedExpression(expression) || ts8.isAwaitExpression(expression) || ts8.isAsExpression(expression) || ts8.isTypeAssertionExpression(expression) || ts8.isNonNullExpression(expression) || ts8.isSatisfiesExpression(expression))
+    return unwrapQueryExpression(expression.expression);
+  return expression;
+}
 function wrapperParent(node) {
   const parent = node.parent;
   if ((ts8.isParenthesizedExpression(parent) || ts8.isAsExpression(parent) || ts8.isTypeAssertionExpression(parent) || ts8.isNonNullExpression(parent) || ts8.isSatisfiesExpression(parent)) && parent.expression === node)
@@ -3080,16 +3132,11 @@ function wrapperParent(node) {
 }
 function fluentCallParent(node) {
   const property = node.parent;
-  if (!ts8.isPropertyAccessExpression(property) || property.expression !== node) return void 0;
+  if (!ts8.isPropertyAccessExpression(property) || property.expression !== node)
+    return void 0;
   const call = property.parent;
   return ts8.isCallExpression(call) && call.expression === property ? call : void 0;
 }
-function queryBuilderRoot(expr) {
-  const unwrapped = unwrapQueryExpression(expr);
-  if (!ts8.isCallExpression(unwrapped)) return void 0;
-  if (capQueryBuilderRoots.has(expressionName(unwrapped.expression))) return unwrapped;
-  return ts8.isPropertyAccessExpression(unwrapped.expression) ? queryBuilderRoot(unwrapped.expression.expression) : void 0;
-}
 function outerFluentQueryCall(root) {
   let current = root;
   let outer = root;
@@ -3105,31 +3152,187 @@ function outerFluentQueryCall(root) {
     current = next;
   }
 }
-function directQueryBuilderStatement(node) {
-  const root = queryBuilderRoot(node);
-  if (!root) return void 0;
-  const logicalCall = outerFluentQueryCall(root);
-  if (logicalCall !== node) return void 0;
-  let current = logicalCall;
+function outerTransparentExpression(expression) {
+  let current = expression;
   while (true) {
     const wrapper = wrapperParent(current);
-    if (wrapper) {
-      current = wrapper;
-      continue;
+    if (!wrapper) return current;
+    current = wrapper;
+  }
+}
+function directAwaitExpression(expression) {
+  const parent = expression.parent;
+  return ts8.isAwaitExpression(parent) && parent.expression === expression ? parent : void 0;
+}
+function returnExecutionContext(expression) {
+  const callable = returnedExpressionCallable(expression);
+  if (!callable) return void 0;
+  if (hasAsyncModifier(callable)) return "async_return";
+  return hasGuaranteedPromiseReturn(callable) ? "promise_return" : void 0;
+}
+function returnedExpressionCallable(expression) {
+  const parent = expression.parent;
+  if (ts8.isArrowFunction(parent) && parent.body === expression) return parent;
+  if (!ts8.isReturnStatement(parent) || parent.expression !== expression)
+    return void 0;
+  return nearestCallable(parent);
+}
+function nearestCallable(node) {
+  let current = node.parent;
+  while (current) {
+    if (isRuntimeCallable(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function isRuntimeCallable(node) {
+  return ts8.isFunctionDeclaration(node) || ts8.isFunctionExpression(node) || ts8.isArrowFunction(node) || ts8.isMethodDeclaration(node) || ts8.isConstructorDeclaration(node) || ts8.isGetAccessorDeclaration(node) || ts8.isSetAccessorDeclaration(node);
+}
+function hasAsyncModifier(node) {
+  return !isGeneratorCallable(node) && ts8.canHaveModifiers(node) && (ts8.getModifiers(node)?.some(
+    (modifier) => modifier.kind === ts8.SyntaxKind.AsyncKeyword
+  ) ?? false);
+}
+function isGeneratorCallable(node) {
+  return (ts8.isFunctionDeclaration(node) || ts8.isFunctionExpression(node) || ts8.isMethodDeclaration(node)) && Boolean(node.asteriskToken);
+}
+function hasGuaranteedPromiseReturn(callable) {
+  const returnType = declaredReturnType(callable);
+  return Boolean(returnType && isGuaranteedPromiseType(returnType));
+}
+function declaredReturnType(callable) {
+  if (ts8.isFunctionDeclaration(callable) || ts8.isFunctionExpression(callable) || ts8.isArrowFunction(callable) || ts8.isMethodDeclaration(callable))
+    return callable.type;
+  return void 0;
+}
+function isGuaranteedPromiseType(type) {
+  if (ts8.isParenthesizedTypeNode(type))
+    return isGuaranteedPromiseType(type.type);
+  if (ts8.isTypeReferenceNode(type))
+    return isStandardPromiseTypeName(type.typeName);
+  if (ts8.isUnionTypeNode(type))
+    return type.types.length > 0 && type.types.every(isGuaranteedPromiseType);
+  if (ts8.isIntersectionTypeNode(type))
+    return type.types.some(isGuaranteedPromiseType);
+  return false;
+}
+function isStandardPromiseTypeName(name) {
+  if (ts8.isIdentifier(name))
+    return name.text === "Promise" || name.text === "PromiseLike";
+  return ts8.isIdentifier(name.left) && (name.left.text === "globalThis" || name.left.text === "global") && (name.right.text === "Promise" || name.right.text === "PromiseLike");
+}
+function isAwaitedPromiseAllElement(expression) {
+  const array = directArrayParent(expression);
+  if (!array) return false;
+  const aggregate = aggregateCallForArray(array);
+  return Boolean(aggregate && isBuiltInPromiseAll(aggregate) && directAwaitExpression(outerTransparentExpression(aggregate)));
+}
+function directArrayParent(expression) {
+  const parent = expression.parent;
+  return ts8.isArrayLiteralExpression(parent) && parent.elements.some(
+    (element) => element === expression
+  ) ? parent : void 0;
+}
+function aggregateCallForArray(array) {
+  const argument = outerTransparentExpression(array);
+  const parent = argument.parent;
+  return ts8.isCallExpression(parent) && parent.arguments.length === 1 && parent.arguments[0] === argument ? parent : void 0;
+}
+function isBuiltInPromiseAll(call) {
+  return ts8.isPropertyAccessExpression(call.expression) && ts8.isIdentifier(call.expression.expression) && call.expression.expression.text === "Promise" && call.expression.name.text === "all" && !hasPromiseValueShadow(call.getSourceFile());
+}
+function hasPromiseValueShadow(source) {
+  const cached = promiseValueShadowCache.get(source);
+  if (cached !== void 0) return cached;
+  let shadowed = false;
+  const visit = (node) => {
+    if (shadowed) return;
+    if (declaresPromiseValue(node)) {
+      shadowed = true;
+      return;
+    }
+    ts8.forEachChild(node, visit);
+  };
+  visit(source);
+  promiseValueShadowCache.set(source, shadowed);
+  return shadowed;
+}
+function declaresPromiseValue(node) {
+  if (ts8.isVariableDeclaration(node) || ts8.isParameter(node))
+    return bindingNameIsPromise(node.name);
+  if (ts8.isImportClause(node))
+    return !node.isTypeOnly && nodeIsPromise(node.name);
+  if (ts8.isImportSpecifier(node))
+    return !node.isTypeOnly && nodeIsPromise(node.name);
+  if (ts8.isNamespaceImport(node) || ts8.isImportEqualsDeclaration(node))
+    return nodeIsPromise(node.name);
+  if (ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node) || ts8.isEnumDeclaration(node) || ts8.isModuleDeclaration(node))
+    return nodeIsPromise(node.name);
+  return false;
+}
+function bindingNameIsPromise(name) {
+  if (ts8.isIdentifier(name)) return name.text === "Promise";
+  if (ts8.isObjectBindingPattern(name))
+    return name.elements.some((element) => bindingNameIsPromise(element.name));
+  return name.elements.some((element) => ts8.isBindingElement(element) && bindingNameIsPromise(element.name));
+}
+function nodeIsPromise(name) {
+  return Boolean(name && ts8.isIdentifier(name) && name.text === "Promise");
+}
+
+// src/parsers/outbound-call-parser.ts
+function lineOf4(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+function entityFromExpression(expr) {
+  if (!expr) return void 0;
+  if (ts9.isIdentifier(expr) || ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
+  if (ts9.isPropertyAccessExpression(expr) && expr.expression.kind === ts9.SyntaxKind.ThisKeyword) return expr.name.text;
+  if (ts9.isElementAccessExpression(expr) && expr.argumentExpression && (ts9.isStringLiteral(expr.argumentExpression) || ts9.isNoSubstitutionTemplateLiteral(expr.argumentExpression))) return expr.argumentExpression.text;
+  return void 0;
+}
+function expressionName2(expr) {
+  if (ts9.isIdentifier(expr)) return expr.text;
+  if (ts9.isPropertyAccessExpression(expr)) return `${expressionName2(expr.expression)}.${expr.name.text}`;
+  return expr.getText();
+}
+function variableInitializers(source) {
+  const initializers = /* @__PURE__ */ new Map();
+  for (const statement of source.statements) {
+    if (!ts9.isVariableStatement(statement) || (statement.declarationList.flags & ts9.NodeFlags.Const) === 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts9.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
     }
-    const parent = current.parent;
-    return ts8.isAwaitExpression(parent) && parent.expression === current ? { root, logicalCall, awaitExpression: parent } : void 0;
   }
+  return initializers;
+}
+function unwrapQueryExpression2(expr) {
+  if (ts9.isParenthesizedExpression(expr) || ts9.isAwaitExpression(expr) || ts9.isAsExpression(expr) || ts9.isTypeAssertionExpression(expr) || ts9.isNonNullExpression(expr) || ts9.isSatisfiesExpression(expr))
+    return unwrapQueryExpression2(expr.expression);
+  return expr;
+}
+function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map()) {
+  const unwrapped = unwrapQueryExpression2(expr);
+  if (ts9.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text), initializers);
+  if (ts9.isCallExpression(unwrapped)) {
+    const name = expressionName2(unwrapped.expression);
+    if (name === "cds.run") return queryEntityFromAst(unwrapped.arguments[0], initializers);
+    if (isCapQueryBuilderRootName(name)) return entityFromExpression(unwrapped.arguments[0]);
+    const receiver = ts9.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : void 0;
+    if (receiver) return queryEntityFromAst(receiver, initializers);
+  }
+  return void 0;
 }
 function queryBuilderEvidence(source, statement) {
   return {
     classifier: "cap_query_builder_direct",
     queryDispatch: "direct_query_builder",
-    queryRoot: expressionName(statement.root.expression),
+    queryRoot: expressionName2(statement.root.expression),
     queryRootStartOffset: statement.root.getStart(source),
     queryRootEndOffset: statement.root.getEnd(),
-    queryStatementStartOffset: statement.awaitExpression.getStart(source),
-    queryStatementEndOffset: statement.awaitExpression.getEnd()
+    queryStatementStartOffset: statement.statement.getStart(source),
+    queryStatementEndOffset: statement.statement.getEnd(),
+    queryExecutionContext: statement.executionContext
   };
 }
 function queryRunEvidence(source, argument) {
@@ -3138,20 +3341,20 @@ function queryRunEvidence(source, argument) {
     classifier: "cap_query_run_wrapper",
     queryDispatch: "cds_run_wrapper",
     ...root ? {
-      queryRoot: expressionName(root.expression),
+      queryRoot: expressionName2(root.expression),
       queryRootStartOffset: root.getStart(source),
       queryRootEndOffset: root.getEnd()
     } : {}
   };
 }
 function extractQueryEntity(expr) {
-  const source = ts8.createSourceFile("query.ts", `const __query = (${expr});`, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
+  const source = ts9.createSourceFile("query.ts", `const __query = (${expr});`, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
   const initializers = variableInitializers(source);
   let found;
   const visit = (node) => {
     if (found) return;
-    if (ts8.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
-    ts8.forEachChild(node, visit);
+    if (ts9.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return found;
@@ -3165,7 +3368,7 @@ function parserEvidence(source, node, extra) {
   return { parser: "typescript_ast", startOffset: node.getStart(source), endOffset: node.getEnd(), ...extra };
 }
 function isStringLike(expr) {
-  return Boolean(expr && (ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr)));
+  return Boolean(expr && (ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr)));
 }
 function literalText(expr) {
   if (isStringLike(expr)) return expr.text;
@@ -3173,53 +3376,53 @@ function literalText(expr) {
 }
 function objectPropertyText(object, key) {
   const prop = object.properties.find(
-    (property) => ts8.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts8.isShorthandPropertyAssignment(property) && property.name.text === key
+    (property) => ts9.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts9.isShorthandPropertyAssignment(property) && property.name.text === key
   );
   if (!prop) return void 0;
-  return ts8.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
+  return ts9.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
 }
 function objectPropertyIsShorthand(object, key) {
-  return object.properties.some((property) => ts8.isShorthandPropertyAssignment(property) && property.name.text === key);
+  return object.properties.some((property) => ts9.isShorthandPropertyAssignment(property) && property.name.text === key);
 }
 function nameOfProperty(name) {
-  if (ts8.isIdentifier(name) || ts8.isStringLiteral(name) || ts8.isNumericLiteral(name)) return name.text;
+  if (ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNumericLiteral(name)) return name.text;
   return void 0;
 }
 var maxAliasDepth2 = 5;
 function safeRaw(expr) {
-  if (ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr) || ts8.isIdentifier(expr) || ts8.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
+  if (ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr) || ts9.isIdentifier(expr) || ts9.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
   return void 0;
 }
 function placeholders2(expr) {
   return expr.templateSpans.map((span) => span.expression.getText(expr.getSourceFile()));
 }
 function isFunctionLikeScope(node) {
-  return ts8.isFunctionLike(node) || ts8.isSourceFile(node);
+  return ts9.isFunctionLike(node) || ts9.isSourceFile(node);
 }
 function nodeContains(parent, child) {
   const source = child.getSourceFile();
   return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
 }
 function declarationScope2(node) {
-  if (ts8.isParameter(node)) return node.parent;
-  if (ts8.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
+  if (ts9.isParameter(node)) return node.parent;
+  if (ts9.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
   const list = node.parent;
-  const blockScoped = (list.flags & (ts8.NodeFlags.Const | ts8.NodeFlags.Let)) !== 0;
+  const blockScoped = (list.flags & (ts9.NodeFlags.Const | ts9.NodeFlags.Let)) !== 0;
   let current = list.parent;
   if (!blockScoped) {
     while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
     return current;
   }
-  while (current.parent && !ts8.isBlock(current) && !ts8.isSourceFile(current) && !ts8.isModuleBlock(current) && !ts8.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
+  while (current.parent && !ts9.isBlock(current) && !ts9.isSourceFile(current) && !ts9.isModuleBlock(current) && !ts9.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
   return current;
 }
 function isLoopInitializerScope(declaration, scope) {
   const list = declaration.parent;
-  return ts8.isForStatement(scope) && scope.initializer === list || (ts8.isForInStatement(scope) || ts8.isForOfStatement(scope)) && scope.initializer === list;
+  return ts9.isForStatement(scope) && scope.initializer === list || (ts9.isForInStatement(scope) || ts9.isForOfStatement(scope)) && scope.initializer === list;
 }
 function catchBindingScope(declaration) {
-  if (ts8.isParameter(declaration)) return void 0;
-  return ts8.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
+  if (ts9.isParameter(declaration)) return void 0;
+  return ts9.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
 }
 function isAccessibleDeclaration(declaration, use) {
   const source = use.getSourceFile();
@@ -3227,32 +3430,32 @@ function isAccessibleDeclaration(declaration, use) {
   const catchScope = catchBindingScope(declaration);
   if (catchScope) return nodeContains(catchScope.block, use);
   const scope = declarationScope2(declaration);
-  if (ts8.isForStatement(scope) || ts8.isForInStatement(scope) || ts8.isForOfStatement(scope)) return nodeContains(scope.statement, use);
-  return ts8.isSourceFile(scope) || nodeContains(scope, use);
+  if (ts9.isForStatement(scope) || ts9.isForInStatement(scope) || ts9.isForOfStatement(scope)) return nodeContains(scope.statement, use);
+  return ts9.isSourceFile(scope) || nodeContains(scope, use);
 }
 function resolveBinding2(identifier, use) {
   const source = use.getSourceFile();
   let best;
   const visit = (node) => {
-    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
-    if (ts8.isParameter(node) && ts8.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
-    ts8.forEachChild(node, visit);
+    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    if (ts9.isParameter(node) && ts9.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   if (!best) return { immutable: false, evidence: ["binding_not_found"] };
-  const immutable = ts8.isVariableDeclaration(best) && (best.parent.flags & ts8.NodeFlags.Const) !== 0;
-  return { declaration: best, initializer: ts8.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "lexical_const_binding_before_use" : "lexical_mutable_or_parameter_binding"] };
+  const immutable = ts9.isVariableDeclaration(best) && (best.parent.flags & ts9.NodeFlags.Const) !== 0;
+  return { declaration: best, initializer: ts9.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "lexical_const_binding_before_use" : "lexical_mutable_or_parameter_binding"] };
 }
 function resolveExpression(expr, use, policy, depth = 0, seen = /* @__PURE__ */ new Set()) {
   if (!expr) return { status: "unknown", sourceKind: "dynamic_expression", placeholderKeys: [], evidence: ["expression_missing"] };
-  if (ts8.isStringLiteral(expr)) return { status: "static", sourceKind: "string_literal", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["string_literal"] };
-  if (ts8.isNoSubstitutionTemplateLiteral(expr)) return { status: "static", sourceKind: "no_substitution_template", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["no_substitution_template"] };
-  if (ts8.isTemplateExpression(expr)) {
+  if (ts9.isStringLiteral(expr)) return { status: "static", sourceKind: "string_literal", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["string_literal"] };
+  if (ts9.isNoSubstitutionTemplateLiteral(expr)) return { status: "static", sourceKind: "no_substitution_template", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["no_substitution_template"] };
+  if (ts9.isTemplateExpression(expr)) {
     const keys = placeholders2(expr);
     if (policy === "operation_path") return { status: "dynamic", sourceKind: "template_with_substitutions", value: stripQuotes(expr.getText(expr.getSourceFile())), rawExpression: safeRaw(expr), placeholderKeys: keys, evidence: ["operation_path_template_placeholders_retained"] };
     return { status: "dynamic", sourceKind: "template_with_substitutions", placeholderKeys: keys, evidence: ["template_substitutions_not_static_external_target"] };
   }
-  if (ts8.isIdentifier(expr)) {
+  if (ts9.isIdentifier(expr)) {
     if (depth >= maxAliasDepth2) return { status: "unknown", sourceKind: "const_alias", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["alias_depth_exceeded"], constName: expr.text };
     const binding = resolveBinding2(expr, use);
     if (!binding.declaration || !binding.initializer || !binding.immutable) return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: binding.evidence, constName: expr.text };
@@ -3261,12 +3464,12 @@ function resolveExpression(expr, use, policy, depth = 0, seen = /* @__PURE__ */
     const resolved3 = resolveExpression(binding.initializer, binding.declaration, policy, depth + 1, seen);
     return { ...resolved3, sourceKind: "const_alias", rawExpression: safeRaw(expr), constName: expr.text, evidence: [...binding.evidence, ...resolved3.evidence] };
   }
-  return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts8.SyntaxKind[expr.kind] ?? "expression"}`] };
+  return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts9.SyntaxKind[expr.kind] ?? "expression"}`] };
 }
 function staticExpressionText(expr, initializers) {
   if (!expr) return void 0;
   if (isStringLike(expr)) return expr.text;
-  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
+  if (ts9.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
   return void 0;
 }
 function operationPathFromStatic(text) {
@@ -3274,17 +3477,17 @@ function operationPathFromStatic(text) {
 }
 function destinationExpressionShape(expr) {
   if (!expr) return void 0;
-  if (ts8.isIdentifier(expr)) return "identifier";
-  if (ts8.isPropertyAccessExpression(expr) || ts8.isElementAccessExpression(expr)) return "property_read";
-  if (ts8.isCallExpression(expr)) return "function_call";
-  if (ts8.isConditionalExpression(expr)) return "conditional";
-  if (ts8.isBinaryExpression(expr)) return "binary_expression";
-  if (ts8.isTemplateExpression(expr)) return "template_expression";
-  return ts8.SyntaxKind[expr.kind] ?? "expression";
+  if (ts9.isIdentifier(expr)) return "identifier";
+  if (ts9.isPropertyAccessExpression(expr) || ts9.isElementAccessExpression(expr)) return "property_read";
+  if (ts9.isCallExpression(expr)) return "function_call";
+  if (ts9.isConditionalExpression(expr)) return "conditional";
+  if (ts9.isBinaryExpression(expr)) return "binary_expression";
+  if (ts9.isTemplateExpression(expr)) return "template_expression";
+  return ts9.SyntaxKind[expr.kind] ?? "expression";
 }
 function staticConditionalCandidates(expr, initializers) {
-  const resolved3 = expr && ts8.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
-  if (!resolved3 || !ts8.isConditionalExpression(resolved3)) return void 0;
+  const resolved3 = expr && ts9.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
+  if (!resolved3 || !ts9.isConditionalExpression(resolved3)) return void 0;
   const left = staticExpressionText(resolved3.whenTrue, initializers);
   const right = staticExpressionText(resolved3.whenFalse, initializers);
   if (!left || !right) return void 0;
@@ -3292,8 +3495,8 @@ function staticConditionalCandidates(expr, initializers) {
 }
 function propertyInitializer(object, key) {
   for (const property of object.properties) {
-    if (ts8.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
-    if (ts8.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
+    if (ts9.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
+    if (ts9.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
   }
   return void 0;
 }
@@ -3354,7 +3557,7 @@ function externalHttpEvidence(node, source) {
   const exprText = expr.getText(source);
   if (exprText === "useOrFetchDestination") {
     const objectArg = node.arguments[0];
-    if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
+    if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
       const destination = destinationTargetFromExpression(propertyInitializer(objectArg, "destinationName"), node);
       return { externalTarget: destination ?? { kind: "unknown", dynamic: false }, classifier: "sap_destination_lookup", sourceCallShape: "useOrFetchDestination" };
     }
@@ -3362,13 +3565,13 @@ function externalHttpEvidence(node, source) {
   if (exprText === "executeHttpRequest") {
     const destination = destinationTargetFromExpression(node.arguments[0], node);
     const config = node.arguments[1];
-    const method = config && ts8.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : void 0;
-    const url = config && ts8.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, "url"), node) : { kind: "unknown", dynamic: false };
+    const method = config && ts9.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : void 0;
+    const url = config && ts9.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, "url"), node) : { kind: "unknown", dynamic: false };
     return { method, externalTarget: destination ? { ...url, destination } : url, classifier: "sap_execute_http_request", sourceCallShape: "executeHttpRequest" };
   }
   if (exprText === "axios") {
     const config = node.arguments[0];
-    if (config && ts8.isObjectLiteralExpression(config)) {
+    if (config && ts9.isObjectLiteralExpression(config)) {
       const method = httpMethodFromObject(config, node);
       return { method, externalTarget: urlTargetFromExpression(propertyInitializer(config, "url"), node), classifier: "axios_config_call", sourceCallShape: "axios(config)" };
     }
@@ -3376,10 +3579,10 @@ function externalHttpEvidence(node, source) {
   }
   if (exprText === "fetch") {
     const init = node.arguments[1];
-    const method = init && ts8.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
+    const method = init && ts9.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
     return { method, externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: "fetch_call", sourceCallShape: "fetch" };
   }
-  if (ts8.isPropertyAccessExpression(expr) && ["get", "post", "put", "patch", "delete", "head"].includes(expr.name.text) && expr.expression.getText(source) === "axios") {
+  if (ts9.isPropertyAccessExpression(expr) && ["get", "post", "put", "patch", "delete", "head"].includes(expr.name.text) && expr.expression.getText(source) === "axios") {
     return { method: expr.name.text.toUpperCase(), externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: "axios_member_call", sourceCallShape: `axios.${expr.name.text}` };
   }
   return void 0;
@@ -3387,27 +3590,27 @@ function externalHttpEvidence(node, source) {
 function collectServiceVariables(source) {
   const vars = /* @__PURE__ */ new Set(["cds", "messaging", "messageClient", "eventClient"]);
   const visit = (node) => {
-    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer) {
+    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.initializer) {
       const text = node.initializer.getText(source);
       if (/cds\.connect\.(to|messaging)\s*\(/.test(text)) vars.add(node.name.text);
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return vars;
 }
 function receiverName(expr) {
-  if (ts8.isIdentifier(expr)) return expr.text;
-  if (ts8.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
+  if (ts9.isIdentifier(expr)) return expr.text;
+  if (ts9.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
   return void 0;
 }
 function sourceOf(node) {
   return node.getSourceFile();
 }
 function rootReceiverName(expr) {
-  if (ts8.isIdentifier(expr)) return expr.text;
-  if (ts8.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
-  if (ts8.isCallExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts9.isIdentifier(expr)) return expr.text;
+  if (ts9.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts9.isCallExpression(expr)) return rootReceiverName(expr.expression);
   return void 0;
 }
 function isSupportedEventReceiver(receiver, rootReceiver, serviceVariables) {
@@ -3424,38 +3627,38 @@ function collectWrapperSpecs(source) {
   const serviceVariables = collectServiceVariables(source);
   const calledNames = /* @__PURE__ */ new Set();
   const collectCalls = (node) => {
-    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression))
+    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression))
       calledNames.add(node.expression.text);
-    if (ts8.isCallExpression(node) && ts8.isCallExpression(node.expression) && ts8.isIdentifier(node.expression.expression))
+    if (ts9.isCallExpression(node) && ts9.isCallExpression(node.expression) && ts9.isIdentifier(node.expression.expression))
       calledNames.add(node.expression.expression.text);
-    ts8.forEachChild(node, collectCalls);
+    ts9.forEachChild(node, collectCalls);
   };
   collectCalls(source);
   const scanFunction = (name, fn) => {
     if (!calledNames.has(name) && !isExportedWrapper(fn)) return;
-    const params = fn.parameters.map((param) => ts8.isIdentifier(param.name) ? param.name.text : void 0);
+    const params = fn.parameters.map((param) => ts9.isIdentifier(param.name) ? param.name.text : void 0);
     const sends = [];
     const visit = (node) => {
-      if (ts8.isCallExpression(node) && ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts8.isIdentifier(node.expression.expression)) {
+      if (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts9.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
           const pathProp = propertyInitializer(objectArg, "path");
           const methodProp = propertyInitializer(objectArg, "method");
-          const pathName = pathProp && ts8.isIdentifier(pathProp) ? pathProp.text : void 0;
-          const methodName2 = methodProp && ts8.isIdentifier(methodProp) ? methodProp.text : void 0;
+          const pathName = pathProp && ts9.isIdentifier(pathProp) ? pathProp.text : void 0;
+          const methodName2 = methodProp && ts9.isIdentifier(methodProp) ? methodProp.text : void 0;
           const methodLiteral = resolveExpression(methodProp, node, "literal").value;
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName2, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
-      if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+      if (ts9.isCallExpression(node) && ts9.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 && ts8.isIdentifier(pathArg) ? pathArg.text : void 0;
-        const clientName = clientArg && ts8.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        const pathName = pathArg && ts9.isIdentifier(pathArg) ? pathArg.text : void 0;
+        const clientName = clientArg && ts9.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() });
       }
-      ts8.forEachChild(node, visit);
+      ts9.forEachChild(node, visit);
     };
     visit(fn);
     if (sends.length !== 1) return;
@@ -3467,17 +3670,17 @@ function collectWrapperSpecs(source) {
     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: lineOf4(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node) => {
-    if (ts8.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
-    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer && (ts8.isArrowFunction(node.initializer) || ts8.isFunctionExpression(node.initializer))) scanFunction(node.name.text, node.initializer);
-    ts8.forEachChild(node, visitTop);
+    if (ts9.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
+    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.initializer && (ts9.isArrowFunction(node.initializer) || ts9.isFunctionExpression(node.initializer))) scanFunction(node.name.text, node.initializer);
+    ts9.forEachChild(node, visitTop);
   };
   visitTop(source);
   return specs;
 }
 function isExportedWrapper(fn) {
-  const declaration = ts8.isFunctionDeclaration(fn) ? fn : ts8.isVariableDeclaration(fn.parent) ? fn.parent.parent.parent : void 0;
-  if (!declaration || !ts8.canHaveModifiers(declaration)) return false;
-  return ts8.getModifiers(declaration)?.some((modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword) ?? false;
+  const declaration = ts9.isFunctionDeclaration(fn) ? fn : ts9.isVariableDeclaration(fn.parent) ? fn.parent.parent.parent : void 0;
+  if (!declaration || !ts9.canHaveModifiers(declaration)) return false;
+  return ts9.getModifiers(declaration)?.some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword) ?? false;
 }
 function classifyOutboundCallsInSource(source, filePath) {
   const calls = [];
@@ -3490,7 +3693,7 @@ function classifyOutboundCallsInSource(source, filePath) {
     calls.push({ node, fact: { ...fact, sourceFile, sourceLine: lineOf4(source.text, node.getStart(source)), confidence: fact.confidence ?? 0.8, evidence: parserEvidence(source, node, extra) } });
   };
   const visit = (node) => {
-    if (ts8.isCallExpression(node)) {
+    if (ts9.isCallExpression(node)) {
       if (wrapperInternalRanges.some((range) => node.getStart(source) >= range.start && node.getEnd() <= range.end)) {
         return;
       }
@@ -3506,9 +3709,9 @@ function classifyOutboundCallsInSource(source, filePath) {
         const entity = queryEntityFromAst(directQuery.logicalCall, initializers);
         const payload = directQuery.logicalCall.getText(source);
         add(directQuery.logicalCall, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) }, queryBuilderEvidence(source, directQuery));
-      } else if (ts8.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts8.isIdentifier(expr.expression) || ts8.isPropertyAccessExpression(expr.expression))) {
+      } else if (ts9.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts9.isIdentifier(expr.expression) || ts9.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
           const receiver = receiverName(expr.expression);
           const query = objectPropertyText(objectArg, "query");
           const method = stripQuotes(resolveExpression(propertyInitializer(objectArg, "method"), node, "literal").value ?? objectPropertyText(objectArg, "method") ?? "POST");
@@ -3541,14 +3744,14 @@ function classifyOutboundCallsInSource(source, filePath) {
             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 (ts8.isCallExpression(expr) && ts8.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts8.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
-        const wrapperName = ts8.isIdentifier(expr) ? expr.text : ts8.isCallExpression(expr) && ts8.isIdentifier(expr.expression) ? expr.expression.text : "";
-        const wrapperArgs = ts8.isIdentifier(expr) ? node.arguments : ts8.isCallExpression(expr) ? expr.arguments : node.arguments;
+      } else if (ts9.isCallExpression(expr) && ts9.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts9.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
+        const wrapperName = ts9.isIdentifier(expr) ? expr.text : ts9.isCallExpression(expr) && ts9.isIdentifier(expr.expression) ? expr.expression.text : "";
+        const wrapperArgs = ts9.isIdentifier(expr) ? node.arguments : ts9.isCallExpression(expr) ? expr.arguments : node.arguments;
         const spec = wrapperSpecs.get(wrapperName);
         const clientArg = spec?.clientIndex === void 0 ? void 0 : wrapperArgs[spec.clientIndex];
         const pathArg = spec ? wrapperArgs[spec.pathIndex] : void 0;
         const methodArg = spec?.methodIndex === void 0 ? void 0 : wrapperArgs[spec.methodIndex];
-        const receiver = clientArg && ts8.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
+        const receiver = clientArg && ts9.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
         const method = stripQuotes(resolveExpression(methodArg, node, "literal").value ?? spec?.methodLiteral ?? "POST");
         const pathAnalysis = analyzeOperationPath(pathArg, node, method);
         const operationPathExpr = operationPathExpression(pathAnalysis);
@@ -3559,7 +3762,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         } else if (spec && receiver) {
           add(node, { callType: "remote_action", serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason }, { receiver, classifier: pathAnalysis.status === "ambiguous" ? "higher_order_wrapper_ambiguous_path" : "higher_order_wrapper_dynamic_path", wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf4(source.text, node.getStart(source)), wrapperPathSourceKind: wrapperSourceKind(pathAnalysis.sourceKind), rawPathExpression: pathAnalysis.rawExpression, pathAnalysis, parserWarning: unresolvedReason });
         }
-      } else if (ts8.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
+      } else if (ts9.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
         const receiver = receiverName(expr.expression);
         const rootReceiver = rootReceiverName(expr.expression);
         if (isSupportedEventReceiver(receiver, rootReceiver, serviceVariables)) {
@@ -3575,7 +3778,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         }
       }
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -3589,12 +3792,12 @@ function containsSupportedOutboundCall(node) {
 async function parseOutboundCalls(repoPath, filePath, context) {
   const snapshot = context?.get(filePath);
   const text = snapshot?.text ?? await fs8.readFile(path11.join(repoPath, filePath), "utf8");
-  const source = snapshot?.sourceFile() ?? ts8.createSourceFile(
+  const source = snapshot?.sourceFile() ?? ts9.createSourceFile(
     filePath,
     text,
-    ts8.ScriptTarget.Latest,
+    ts9.ScriptTarget.Latest,
     true,
-    filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+    filePath.endsWith(".ts") ? ts9.ScriptKind.TS : ts9.ScriptKind.JS
   );
   const bindingNames = new Set((await parseServiceBindings(
     repoPath,
@@ -3610,21 +3813,21 @@ async function parseOutboundCalls(repoPath, filePath, context) {
   );
   return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath, source)];
 }
-function parseLocalServiceCalls(text, filePath, source = ts8.createSourceFile(
+function parseLocalServiceCalls(text, filePath, source = ts9.createSourceFile(
   filePath,
   text,
-  ts8.ScriptTarget.Latest,
+  ts9.ScriptTarget.Latest,
   true,
-  filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+  filePath.endsWith(".ts") ? ts9.ScriptKind.TS : ts9.ScriptKind.JS
 )) {
   const aliases = /* @__PURE__ */ new Map();
   const calls = [];
   const visit = (node) => {
-    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.initializer) {
+    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.initializer) {
       const origin = serviceLookup(node.initializer, aliases);
       if (origin) aliases.set(node.name.text, { ...origin, chain: [...origin.chain, node.name.text] });
     }
-    if (ts8.isCallExpression(node)) {
+    if (ts9.isCallExpression(node)) {
       const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== "entities") calls.push({
         callType: "local_service_call",
@@ -3647,20 +3850,20 @@ function parseLocalServiceCalls(text, filePath, source = ts8.createSourceFile(
         })
       });
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return calls;
 }
 function serviceLookup(expr, aliases) {
-  if (ts8.isIdentifier(expr)) return aliases.get(expr.text);
-  if (ts8.isPropertyAccessExpression(expr) && expr.expression.getText() === "cds.services") return { service: expr.name.text, lookup: expr.getText(), chain: [expr.getText()] };
-  if (ts8.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts8.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
+  if (ts9.isIdentifier(expr)) return aliases.get(expr.text);
+  if (ts9.isPropertyAccessExpression(expr) && expr.expression.getText() === "cds.services") return { service: expr.name.text, lookup: expr.getText(), chain: [expr.getText()] };
+  if (ts9.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts9.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
   return void 0;
 }
 function serviceOperationCall(node, aliases) {
   const expr = node.expression;
-  if (!ts8.isPropertyAccessExpression(expr)) return void 0;
+  if (!ts9.isPropertyAccessExpression(expr)) return void 0;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return void 0;
   if (expr.name.text === "send") {
@@ -8341,4 +8544,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-GXYVIHJ5.js.map
+//# sourceMappingURL=chunk-DCOFNDKS.js.map