@saptools/service-flow 0.1.54 → 0.1.56

package/dist/{chunk-ERIZHM5C.js → chunk-Y7H7ZU5B.js}

@@ -2303,7 +2303,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,53 +3019,287 @@ function literal(expr) {
   return expr && (ts7.isStringLiteralLike(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) ? expr.text : void 0;
 }
 
+// src/parsers/000-direct-query-execution.ts
+import ts8 from "typescript";
+var capQueryBuilderRoots = /* @__PURE__ */ new Set([
+  "SELECT.from",
+  "SELECT.one.from",
+  "SELECT.one",
+  "INSERT.into",
+  "UPSERT.into",
+  "UPDATE.entity",
+  "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)
+    return parent;
+  return void 0;
+}
+function fluentCallParent(node) {
+  const property = node.parent;
+  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 outerFluentQueryCall(root) {
+  let current = root;
+  let outer = root;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const next = fluentCallParent(current);
+    if (!next) return outer;
+    outer = next;
+    current = next;
+  }
+}
+function outerTransparentExpression(expression) {
+  let current = expression;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    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 (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;
+  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 expressionName(expr) {
-  if (ts8.isIdentifier(expr)) return expr.text;
-  if (ts8.isPropertyAccessExpression(expr)) return `${expressionName(expr.expression)}.${expr.name.text}`;
+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 (!ts8.isVariableStatement(statement) || (statement.declarationList.flags & ts8.NodeFlags.Const) === 0) continue;
+    if (!ts9.isVariableStatement(statement) || (statement.declarationList.flags & ts9.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);
+      if (ts9.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
     }
   }
   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()) {
-  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text), initializers);
-  if (ts8.isCallExpression(expr)) {
-    const name = expressionName(expr.expression);
-    if (name === "cds.run") return queryEntityFromAst(expr.arguments[0], initializers);
-    if (["SELECT.one.from", "SELECT.from", "SELECT.one", "INSERT.into", "UPSERT.into", "DELETE.from", "UPDATE.entity"].includes(name)) return entityFromExpression(expr.arguments[0]);
-    if (name === "UPDATE") return entityFromExpression(expr.arguments[0]);
-    const receiver = ts8.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : void 0;
+  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: expressionName2(statement.root.expression),
+    queryRootStartOffset: statement.root.getStart(source),
+    queryRootEndOffset: statement.root.getEnd(),
+    queryStatementStartOffset: statement.statement.getStart(source),
+    queryStatementEndOffset: statement.statement.getEnd(),
+    queryExecutionContext: statement.executionContext
+  };
+}
+function queryRunEvidence(source, argument) {
+  const root = argument ? queryBuilderRoot(argument) : void 0;
+  return {
+    classifier: "cap_query_run_wrapper",
+    queryDispatch: "cds_run_wrapper",
+    ...root ? {
+      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;
@@ -3079,7 +3313,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;
@@ -3087,53 +3321,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();
@@ -3141,32 +3375,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 };
@@ -3175,12 +3409,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) {
@@ -3188,17 +3422,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;
@@ -3206,8 +3440,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;
 }
@@ -3268,7 +3502,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" };
     }
@@ -3276,13 +3510,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)" };
     }
@@ -3290,10 +3524,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;
@@ -3301,27 +3535,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) {
@@ -3338,38 +3572,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;
@@ -3381,17 +3615,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 = [];
@@ -3404,20 +3638,25 @@ 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;
       }
       const expr = node.expression;
       const exprText = expr.getText(source);
+      const directQuery = directQueryBuilderStatement(node);
       if (exprText === "cds.run") {
         const arg = node.arguments[0];
         const entity = arg ? queryEntityFromAst(arg, initializers) : void 0;
         const payload = arg?.getText(source) ?? "";
-        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) });
-      } else if (ts8.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts8.isIdentifier(expr.expression) || ts8.isPropertyAccessExpression(expr.expression))) {
+        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) }, queryRunEvidence(source, arg));
+      } else if (directQuery) {
+        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 (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");
@@ -3450,14 +3689,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);
@@ -3468,7 +3707,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)) {
@@ -3484,7 +3723,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         }
       }
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -3498,12 +3737,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,
@@ -3519,21 +3758,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",
@@ -3556,20 +3795,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") {
@@ -8250,4 +8489,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-ERIZHM5C.js.map
+//# sourceMappingURL=chunk-Y7H7ZU5B.js.map