@saptools/service-flow 0.1.58 → 0.1.59

package/dist/{chunk-CRSSXWQ2.js → chunk-GLZSDBRG.js}

@@ -2358,7 +2358,7 @@ function collectClassHelpers(sf) {
 // src/parsers/outbound-call-parser.ts
 import fs8 from "fs/promises";
 import path11 from "path";
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // src/linker/external-http-target.ts
 import { createHash } from "crypto";
@@ -3080,6 +3080,8 @@ var capQueryBuilderRoots = /* @__PURE__ */ new Set([
   "SELECT.from",
   "SELECT.one.from",
   "SELECT.one",
+  "SELECT.distinct.from",
+  "SELECT.distinct.one.from",
   "INSERT.into",
   "UPSERT.into",
   "UPDATE.entity",
@@ -3280,20 +3282,15 @@ 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;
-}
+// src/parsers/001-query-entity-resolution.ts
+import ts9 from "typescript";
+var maxAliasDepth2 = 5;
+var cdsModelSpecifier = /^#cds-models(?:\/|$)/;
+var modelNamespaceCache = /* @__PURE__ */ new WeakMap();
 function expressionName2(expr) {
   if (ts9.isIdentifier(expr)) return expr.text;
-  if (ts9.isPropertyAccessExpression(expr)) return `${expressionName2(expr.expression)}.${expr.name.text}`;
+  if (ts9.isPropertyAccessExpression(expr))
+    return `${expressionName2(expr.expression)}.${expr.name.text}`;
   return expr.getText();
 }
 function variableInitializers(source) {
@@ -3301,7 +3298,8 @@ function variableInitializers(source) {
   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);
+      if (ts9.isIdentifier(declaration.name) && declaration.initializer)
+        initializers.set(declaration.name.text, declaration.initializer);
     }
   }
   return initializers;
@@ -3311,18 +3309,349 @@ function unwrapQueryExpression2(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);
+function isFunctionLikeScope(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 isLoopInitializerScope(declaration, scope) {
+  const list = declaration.parent;
+  return ts9.isForStatement(scope) && scope.initializer === list || (ts9.isForInStatement(scope) || ts9.isForOfStatement(scope)) && scope.initializer === list;
+}
+function isLexicalScopeBoundary(node, declaration) {
+  return ts9.isBlock(node) || ts9.isSourceFile(node) || ts9.isModuleBlock(node) || ts9.isCaseBlock(node) || isLoopInitializerScope(declaration, node) || isFunctionLikeScope(node);
+}
+function declarationScope2(node) {
+  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 & (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 && !isLexicalScopeBoundary(current, node))
+    current = current.parent;
+  return current;
+}
+function catchBindingScope(declaration) {
+  if (ts9.isParameter(declaration)) return void 0;
+  return ts9.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : void 0;
+}
+function declarationIsInScope(declaration, use) {
+  const catchScope = catchBindingScope(declaration);
+  if (catchScope) return nodeContains(catchScope.block, use);
+  const scope = declarationScope2(declaration);
+  if (ts9.isForStatement(scope) || ts9.isForInStatement(scope) || ts9.isForOfStatement(scope)) return nodeContains(scope.statement, use);
+  return ts9.isSourceFile(scope) || nodeContains(scope, use);
+}
+function isAccessibleDeclaration(declaration, use) {
+  return declaration.name.getStart(use.getSourceFile()) < use.getStart() && declarationIsInScope(declaration, use);
+}
+function resolveBinding2(identifier, use) {
+  const source = use.getSourceFile();
+  let best;
+  const visit = (node) => {
+    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 = 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 directBindingElement(name, identifier) {
+  if (ts9.isIdentifier(name)) return void 0;
+  for (const element of name.elements) {
+    if (ts9.isOmittedExpression(element) || element.dotDotDotToken || element.initializer || !ts9.isIdentifier(element.name)) continue;
+    if (element.name.text === identifier.text) return element;
   }
   return void 0;
 }
+function bindingNameContains(name, target) {
+  if (ts9.isIdentifier(name)) return name.text === target;
+  return name.elements.some((element) => ts9.isBindingElement(element) && bindingNameContains(element.name, target));
+}
+function bindingScope(node) {
+  if (ts9.isVariableDeclaration(node) || ts9.isParameter(node))
+    return declarationScope2(node);
+  if (ts9.isFunctionExpression(node) || ts9.isClassExpression(node)) return node;
+  return node.parent;
+}
+function bindingIsCloser(candidate, current, use) {
+  const source = use.getSourceFile();
+  const candidateScope = bindingScope(candidate);
+  const currentScope = bindingScope(current);
+  const candidateSpan = candidateScope.getEnd() - candidateScope.getStart(source);
+  const currentSpan = currentScope.getEnd() - currentScope.getStart(source);
+  return candidateSpan < currentSpan || candidateSpan === currentSpan && candidate.getStart(source) > current.getStart(source);
+}
+function nearestScopedVariableDeclaration(identifier) {
+  let best;
+  const visit = (node) => {
+    if ((ts9.isVariableDeclaration(node) || ts9.isParameter(node)) && bindingNameContains(node.name, identifier.text) && declarationIsInScope(node, identifier) && (!best || bindingIsCloser(node, best, identifier))) best = node;
+    ts9.forEachChild(node, visit);
+  };
+  visit(identifier.getSourceFile());
+  return best;
+}
+function hasScopedVariableDeclaration(identifier) {
+  return Boolean(nearestScopedVariableDeclaration(identifier));
+}
+function namedValueDeclarationMatches(node, name) {
+  if (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node) || ts9.isEnumDeclaration(node)) return node.name?.text === name;
+  return ts9.isModuleDeclaration(node) && ts9.isIdentifier(node.name) && node.name.text === name;
+}
+function declarationContainerContains(node, use) {
+  const container = node.parent;
+  return ts9.isSourceFile(container) || (ts9.isBlock(container) || ts9.isModuleBlock(container)) && nodeContains(container, use);
+}
+function selfNamedValueDeclarationMatches(node, identifier) {
+  return (ts9.isFunctionExpression(node) || ts9.isClassExpression(node)) && node.name?.text === identifier.text && nodeContains(node, identifier);
+}
+function scopedNonVariableDeclarationMatches(node, identifier) {
+  return namedValueDeclarationMatches(node, identifier.text) && declarationContainerContains(node, identifier) || selfNamedValueDeclarationMatches(node, identifier);
+}
+function nearestScopedNonVariableDeclaration(identifier) {
+  let best;
+  const visit = (node) => {
+    if (scopedNonVariableDeclarationMatches(node, identifier) && (!best || bindingIsCloser(node, best, identifier))) best = node;
+    ts9.forEachChild(node, visit);
+  };
+  visit(identifier.getSourceFile());
+  return best;
+}
+function hasScopedNonVariableDeclaration(identifier) {
+  return Boolean(nearestScopedNonVariableDeclaration(identifier));
+}
+function nonVariableBindingWins(identifier, selected) {
+  const declaration = nearestScopedNonVariableDeclaration(identifier);
+  return Boolean(declaration && (!selected || bindingIsCloser(declaration, selected, identifier)));
+}
+function importClauseBinds(clause, name) {
+  if (!clause || clause.isTypeOnly) return false;
+  if (clause.name?.text === name) return true;
+  const bindings = clause.namedBindings;
+  if (!bindings) return false;
+  if (ts9.isNamespaceImport(bindings)) return bindings.name.text === name;
+  return bindings.elements.some((element) => !element.isTypeOnly && element.name.text === name);
+}
+function hasValueImportBinding(identifier) {
+  return identifier.getSourceFile().statements.some((statement) => {
+    if (ts9.isImportDeclaration(statement))
+      return importClauseBinds(statement.importClause, identifier.text);
+    return ts9.isImportEqualsDeclaration(statement) && !statement.isTypeOnly && statement.name.text === identifier.text;
+  });
+}
+function sourcePropertyName(element, localName) {
+  const property = element.propertyName;
+  if (!property) return localName;
+  if (ts9.isIdentifier(property) || ts9.isStringLiteral(property) || ts9.isNumericLiteral(property)) return property.text;
+  return void 0;
+}
+function resolveDestructuredBinding(identifier, use) {
+  const source = use.getSourceFile();
+  let best;
+  const visit = (node) => {
+    if ((ts9.isVariableDeclaration(node) || ts9.isParameter(node)) && isAccessibleDeclaration(node, use)) {
+      const element = directBindingElement(node.name, identifier);
+      const entityName = element ? sourcePropertyName(element, identifier.text) : void 0;
+      if (entityName && (!best || node.name.getStart(source) > best.declaration.name.getStart(source))) {
+        best = {
+          declaration: node,
+          initializer: node.initializer,
+          entityName
+        };
+      }
+    }
+    ts9.forEachChild(node, visit);
+  };
+  visit(source);
+  return best;
+}
+function isEntitiesBase(expr) {
+  const value = unwrapQueryExpression2(expr);
+  if (ts9.isPropertyAccessExpression(value)) return value.name.text === "entities";
+  return ts9.isCallExpression(value) && ts9.isPropertyAccessExpression(value.expression) && value.expression.name.text === "entities";
+}
+function hasLexicalValueShadow(identifier, includeImports) {
+  return hasScopedVariableDeclaration(identifier) || hasScopedNonVariableDeclaration(identifier) || includeImports && hasValueImportBinding(identifier);
+}
+function modelRequire(expr) {
+  const value = unwrapQueryExpression2(expr);
+  if (!ts9.isCallExpression(value) || !ts9.isIdentifier(value.expression) || value.expression.text !== "require" || value.arguments.length !== 1)
+    return false;
+  if (hasLexicalValueShadow(value.expression, true)) return false;
+  const specifier = value.arguments[0];
+  return Boolean(specifier && ts9.isStringLiteralLike(specifier) && cdsModelSpecifier.test(specifier.text));
+}
+function modelNamespaceImportName(statement) {
+  if (!ts9.isImportDeclaration(statement) || !ts9.isStringLiteralLike(statement.moduleSpecifier) || !cdsModelSpecifier.test(statement.moduleSpecifier.text) || statement.importClause?.isTypeOnly) return void 0;
+  const bindings = statement.importClause?.namedBindings;
+  return bindings && ts9.isNamespaceImport(bindings) ? bindings.name.text : void 0;
+}
+function modelImportEqualsName(statement) {
+  if (!ts9.isImportEqualsDeclaration(statement) || statement.isTypeOnly || !ts9.isExternalModuleReference(statement.moduleReference)) return void 0;
+  const specifier = statement.moduleReference.expression;
+  return specifier && ts9.isStringLiteralLike(specifier) && cdsModelSpecifier.test(specifier.text) ? statement.name.text : void 0;
+}
+function modelNamespaceNames(source) {
+  const cached = modelNamespaceCache.get(source);
+  if (cached) return cached;
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of source.statements) {
+    const name = modelNamespaceImportName(statement) ?? modelImportEqualsName(statement);
+    if (name) names.add(name);
+  }
+  modelNamespaceCache.set(source, names);
+  return names;
+}
+function destructuredEntitySource(initializer) {
+  if (!initializer) return false;
+  if (isEntitiesBase(initializer) || modelRequire(initializer)) return true;
+  const value = unwrapQueryExpression2(initializer);
+  return ts9.isIdentifier(value) && !hasLexicalValueShadow(value, false) && modelNamespaceNames(value.getSourceFile()).has(value.text);
+}
+function isAssignmentOperator(kind) {
+  return kind >= ts9.SyntaxKind.FirstAssignment && kind <= ts9.SyntaxKind.LastAssignment;
+}
+function identifierIsReadWithinTarget(identifier, parent) {
+  if (ts9.isPropertyAccessExpression(parent) && parent.name === identifier) return true;
+  if (ts9.isElementAccessExpression(parent) && parent.argumentExpression && nodeContains(parent.argumentExpression, identifier)) return true;
+  if (ts9.isPropertyAssignment(parent) && nodeContains(parent.name, identifier)) return true;
+  return ts9.isComputedPropertyName(parent) && nodeContains(parent.expression, identifier);
+}
+function identifierIsUnaryWrite(identifier) {
+  const direct = identifier.parent;
+  if (!((ts9.isPrefixUnaryExpression(direct) || ts9.isPostfixUnaryExpression(direct)) && direct.operand === identifier)) return false;
+  return direct.operator === ts9.SyntaxKind.PlusPlusToken || direct.operator === ts9.SyntaxKind.MinusMinusToken;
+}
+function identifierIsNestedWrite(identifier) {
+  let current = identifier;
+  while (current.parent) {
+    const parent = current.parent;
+    if (identifierIsReadWithinTarget(identifier, parent)) return false;
+    if (ts9.isBinaryExpression(parent))
+      return isAssignmentOperator(parent.operatorToken.kind) && nodeContains(parent.left, identifier);
+    if (ts9.isForInStatement(parent) || ts9.isForOfStatement(parent))
+      return nodeContains(parent.initializer, identifier);
+    current = parent;
+  }
+  return false;
+}
+function identifierIsWrite(identifier) {
+  return identifierIsUnaryWrite(identifier) || identifierIsNestedWrite(identifier);
+}
+function destructuredBindingWasWritten(binding, localName, use) {
+  if (ts9.isParameter(binding.declaration)) return true;
+  if ((binding.declaration.parent.flags & ts9.NodeFlags.Const) !== 0) return false;
+  let written = false;
+  const declarationEnd = binding.declaration.name.getEnd();
+  const useStart = use.getStart();
+  const visit = (node) => {
+    if (written) return;
+    if (ts9.isIdentifier(node) && node.text === localName && node.getStart() > declarationEnd && node.getStart() < useStart && identifierIsWrite(node) && resolveDestructuredBinding(node, node)?.declaration === binding.declaration)
+      written = true;
+    ts9.forEachChild(node, visit);
+  };
+  visit(use.getSourceFile());
+  return written;
+}
+function destructuredBindingWins(destructured, simple, use) {
+  return !simple.declaration || bindingIsCloser(destructured.declaration, simple.declaration, use);
+}
+function entityFromDestructuredBinding(binding, identifier) {
+  if (destructuredBindingWasWritten(binding, identifier.text, identifier))
+    return void 0;
+  return destructuredEntitySource(binding.initializer) ? binding.entityName : void 0;
+}
+function entityFromSimpleBinding(binding, depth, seen) {
+  if (!binding.declaration || !binding.immutable || !binding.initializer || seen.has(binding.declaration)) return void 0;
+  seen.add(binding.declaration);
+  return entityFromExpression(binding.initializer, depth + 1, seen);
+}
+function scopedBindingIsCurrent(identifier, declaration) {
+  return nearestScopedVariableDeclaration(identifier) === declaration && !nonVariableBindingWins(identifier, declaration);
+}
+function unboundEntityName(identifier) {
+  return hasScopedVariableDeclaration(identifier) || hasScopedNonVariableDeclaration(identifier) ? void 0 : identifier.text;
+}
+function entityFromIdentifier(expr, depth, seen) {
+  const binding = resolveBinding2(expr, expr);
+  const destructured = resolveDestructuredBinding(expr, expr);
+  if (destructured && destructuredBindingWins(destructured, binding, expr)) {
+    return scopedBindingIsCurrent(expr, destructured.declaration) ? entityFromDestructuredBinding(destructured, expr) : void 0;
+  }
+  if (!binding.declaration) return unboundEntityName(expr);
+  if (!scopedBindingIsCurrent(expr, binding.declaration)) return void 0;
+  return entityFromSimpleBinding(binding, depth, seen);
+}
+function literalEntity(expr) {
+  if (ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr))
+    return expr.text;
+  if (!ts9.isElementAccessExpression(expr) || !expr.argumentExpression)
+    return void 0;
+  return ts9.isStringLiteral(expr.argumentExpression) || ts9.isNoSubstitutionTemplateLiteral(expr.argumentExpression) ? expr.argumentExpression.text : void 0;
+}
+function propertyEntity(expr) {
+  if (!ts9.isPropertyAccessExpression(expr)) return void 0;
+  if (expr.expression.kind === ts9.SyntaxKind.ThisKeyword) return void 0;
+  return isEntitiesBase(expr.expression) ? expr.name.text : void 0;
+}
+function entityFromExpression(expr, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (!expr || depth >= maxAliasDepth2) return void 0;
+  const value = unwrapQueryExpression2(expr);
+  const literal2 = literalEntity(value);
+  if (literal2 !== void 0) return literal2;
+  if (ts9.isIdentifier(value)) return entityFromIdentifier(value, depth, seen);
+  return propertyEntity(value);
+}
+function queryAliasInitializer(identifier, initializers, seen) {
+  const initializer = initializers.get(identifier.text);
+  if (!initializer || seen.has(identifier.text)) return void 0;
+  const binding = resolveBinding2(identifier, identifier);
+  if (!binding.declaration || !binding.immutable || binding.initializer !== initializer || nearestScopedVariableDeclaration(identifier) !== binding.declaration || nonVariableBindingWins(identifier, binding.declaration)) return void 0;
+  seen.add(identifier.text);
+  return initializer;
+}
+function queryEntityFromCall(call, initializers, seenInitializers) {
+  const name = expressionName2(call.expression);
+  if (name === "cds.run")
+    return queryEntityFromAst(call.arguments[0], initializers, seenInitializers);
+  if (isCapQueryBuilderRootName(name))
+    return entityFromExpression(call.arguments[0]);
+  const receiver = ts9.isPropertyAccessExpression(call.expression) ? call.expression.expression : void 0;
+  return receiver ? queryEntityFromAst(receiver, initializers, seenInitializers) : void 0;
+}
+function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map(), seenInitializers = /* @__PURE__ */ new Set()) {
+  const unwrapped = unwrapQueryExpression2(expr);
+  if (ts9.isIdentifier(unwrapped)) {
+    const initializer = queryAliasInitializer(
+      unwrapped,
+      initializers,
+      seenInitializers
+    );
+    return initializer ? queryEntityFromAst(initializer, initializers, seenInitializers) : void 0;
+  }
+  return ts9.isCallExpression(unwrapped) ? queryEntityFromCall(unwrapped, initializers, seenInitializers) : void 0;
+}
+
+// src/parsers/outbound-call-parser.ts
+function lineOf4(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
 function queryBuilderEvidence(source, statement) {
   return {
     classifier: "cap_query_builder_direct",
@@ -3348,13 +3677,13 @@ function queryRunEvidence(source, argument) {
   };
 }
 function extractQueryEntity(expr) {
-  const source = ts9.createSourceFile("query.ts", `const __query = (${expr});`, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
+  const source = ts10.createSourceFile("query.ts", `const __query = (${expr});`, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TS);
   const initializers = variableInitializers(source);
   let found;
   const visit = (node) => {
     if (found) return;
-    if (ts9.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
-    ts9.forEachChild(node, visit);
+    if (ts10.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
+    ts10.forEachChild(node, visit);
   };
   visit(source);
   return found;
@@ -3368,7 +3697,7 @@ function parserEvidence(source, node, extra) {
   return { parser: "typescript_ast", startOffset: node.getStart(source), endOffset: node.getEnd(), ...extra };
 }
 function isStringLike(expr) {
-  return Boolean(expr && (ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr)));
+  return Boolean(expr && (ts10.isStringLiteral(expr) || ts10.isNoSubstitutionTemplateLiteral(expr)));
 }
 function literalText(expr) {
   if (isStringLike(expr)) return expr.text;
@@ -3376,86 +3705,35 @@ function literalText(expr) {
 }
 function objectPropertyText(object, key) {
   const prop = object.properties.find(
-    (property) => ts9.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts9.isShorthandPropertyAssignment(property) && property.name.text === key
+    (property) => ts10.isPropertyAssignment(property) && nameOfProperty(property.name) === key || ts10.isShorthandPropertyAssignment(property) && property.name.text === key
   );
   if (!prop) return void 0;
-  return ts9.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
+  return ts10.isShorthandPropertyAssignment(prop) ? prop.name.text : prop.initializer.getText();
 }
 function objectPropertyIsShorthand(object, key) {
-  return object.properties.some((property) => ts9.isShorthandPropertyAssignment(property) && property.name.text === key);
+  return object.properties.some((property) => ts10.isShorthandPropertyAssignment(property) && property.name.text === key);
 }
 function nameOfProperty(name) {
-  if (ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNumericLiteral(name)) return name.text;
+  if (ts10.isIdentifier(name) || ts10.isStringLiteral(name) || ts10.isNumericLiteral(name)) return name.text;
   return void 0;
 }
-var maxAliasDepth2 = 5;
 function safeRaw(expr) {
-  if (ts9.isStringLiteral(expr) || ts9.isNoSubstitutionTemplateLiteral(expr) || ts9.isIdentifier(expr) || ts9.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
+  if (ts10.isStringLiteral(expr) || ts10.isNoSubstitutionTemplateLiteral(expr) || ts10.isIdentifier(expr) || ts10.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 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 (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 & (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 && !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 ts9.isForStatement(scope) && scope.initializer === list || (ts9.isForInStatement(scope) || ts9.isForOfStatement(scope)) && scope.initializer === list;
-}
-function catchBindingScope(declaration) {
-  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();
-  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
-  const catchScope = catchBindingScope(declaration);
-  if (catchScope) return nodeContains(catchScope.block, use);
-  const scope = declarationScope2(declaration);
-  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 (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 = 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 (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)) {
+  if (ts10.isStringLiteral(expr)) return { status: "static", sourceKind: "string_literal", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["string_literal"] };
+  if (ts10.isNoSubstitutionTemplateLiteral(expr)) return { status: "static", sourceKind: "no_substitution_template", value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["no_substitution_template"] };
+  if (ts10.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 (ts9.isIdentifier(expr)) {
+  if (ts10.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 };
@@ -3464,12 +3742,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_${ts9.SyntaxKind[expr.kind] ?? "expression"}`] };
+  return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts10.SyntaxKind[expr.kind] ?? "expression"}`] };
 }
 function staticExpressionText(expr, initializers) {
   if (!expr) return void 0;
   if (isStringLike(expr)) return expr.text;
-  if (ts9.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
+  if (ts10.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
   return void 0;
 }
 function operationPathFromStatic(text) {
@@ -3477,17 +3755,17 @@ function operationPathFromStatic(text) {
 }
 function destinationExpressionShape(expr) {
   if (!expr) return void 0;
-  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";
+  if (ts10.isIdentifier(expr)) return "identifier";
+  if (ts10.isPropertyAccessExpression(expr) || ts10.isElementAccessExpression(expr)) return "property_read";
+  if (ts10.isCallExpression(expr)) return "function_call";
+  if (ts10.isConditionalExpression(expr)) return "conditional";
+  if (ts10.isBinaryExpression(expr)) return "binary_expression";
+  if (ts10.isTemplateExpression(expr)) return "template_expression";
+  return ts10.SyntaxKind[expr.kind] ?? "expression";
 }
 function staticConditionalCandidates(expr, initializers) {
-  const resolved3 = expr && ts9.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
-  if (!resolved3 || !ts9.isConditionalExpression(resolved3)) return void 0;
+  const resolved3 = expr && ts10.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
+  if (!resolved3 || !ts10.isConditionalExpression(resolved3)) return void 0;
   const left = staticExpressionText(resolved3.whenTrue, initializers);
   const right = staticExpressionText(resolved3.whenFalse, initializers);
   if (!left || !right) return void 0;
@@ -3495,8 +3773,8 @@ function staticConditionalCandidates(expr, initializers) {
 }
 function propertyInitializer(object, key) {
   for (const property of object.properties) {
-    if (ts9.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
-    if (ts9.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
+    if (ts10.isPropertyAssignment(property) && nameOfProperty(property.name) === key) return property.initializer;
+    if (ts10.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
   }
   return void 0;
 }
@@ -3557,7 +3835,7 @@ function externalHttpEvidence(node, source) {
   const exprText = expr.getText(source);
   if (exprText === "useOrFetchDestination") {
     const objectArg = node.arguments[0];
-    if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
+    if (objectArg && ts10.isObjectLiteralExpression(objectArg)) {
       const destination = destinationTargetFromExpression(propertyInitializer(objectArg, "destinationName"), node);
       return { externalTarget: destination ?? { kind: "unknown", dynamic: false }, classifier: "sap_destination_lookup", sourceCallShape: "useOrFetchDestination" };
     }
@@ -3565,13 +3843,13 @@ function externalHttpEvidence(node, source) {
   if (exprText === "executeHttpRequest") {
     const destination = destinationTargetFromExpression(node.arguments[0], node);
     const config = node.arguments[1];
-    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 };
+    const method = config && ts10.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : void 0;
+    const url = config && ts10.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 && ts9.isObjectLiteralExpression(config)) {
+    if (config && ts10.isObjectLiteralExpression(config)) {
       const method = httpMethodFromObject(config, node);
       return { method, externalTarget: urlTargetFromExpression(propertyInitializer(config, "url"), node), classifier: "axios_config_call", sourceCallShape: "axios(config)" };
     }
@@ -3579,10 +3857,10 @@ function externalHttpEvidence(node, source) {
   }
   if (exprText === "fetch") {
     const init = node.arguments[1];
-    const method = init && ts9.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
+    const method = init && ts10.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : void 0;
     return { method, externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: "fetch_call", sourceCallShape: "fetch" };
   }
-  if (ts9.isPropertyAccessExpression(expr) && ["get", "post", "put", "patch", "delete", "head"].includes(expr.name.text) && expr.expression.getText(source) === "axios") {
+  if (ts10.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;
@@ -3590,27 +3868,27 @@ function externalHttpEvidence(node, source) {
 function collectServiceVariables(source) {
   const vars = /* @__PURE__ */ new Set(["cds", "messaging", "messageClient", "eventClient"]);
   const visit = (node) => {
-    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.initializer) {
+    if (ts10.isVariableDeclaration(node) && ts10.isIdentifier(node.name) && node.initializer) {
       const text = node.initializer.getText(source);
       if (/cds\.connect\.(to|messaging)\s*\(/.test(text)) vars.add(node.name.text);
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(source);
   return vars;
 }
 function receiverName(expr) {
-  if (ts9.isIdentifier(expr)) return expr.text;
-  if (ts9.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
+  if (ts10.isIdentifier(expr)) return expr.text;
+  if (ts10.isPropertyAccessExpression(expr)) return expr.getText(sourceOf(expr));
   return void 0;
 }
 function sourceOf(node) {
   return node.getSourceFile();
 }
 function rootReceiverName(expr) {
-  if (ts9.isIdentifier(expr)) return expr.text;
-  if (ts9.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
-  if (ts9.isCallExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts10.isIdentifier(expr)) return expr.text;
+  if (ts10.isPropertyAccessExpression(expr)) return rootReceiverName(expr.expression);
+  if (ts10.isCallExpression(expr)) return rootReceiverName(expr.expression);
   return void 0;
 }
 function isSupportedEventReceiver(receiver, rootReceiver, serviceVariables) {
@@ -3627,38 +3905,38 @@ function collectWrapperSpecs(source) {
   const serviceVariables = collectServiceVariables(source);
   const calledNames = /* @__PURE__ */ new Set();
   const collectCalls = (node) => {
-    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression))
+    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression))
       calledNames.add(node.expression.text);
-    if (ts9.isCallExpression(node) && ts9.isCallExpression(node.expression) && ts9.isIdentifier(node.expression.expression))
+    if (ts10.isCallExpression(node) && ts10.isCallExpression(node.expression) && ts10.isIdentifier(node.expression.expression))
       calledNames.add(node.expression.expression.text);
-    ts9.forEachChild(node, collectCalls);
+    ts10.forEachChild(node, collectCalls);
   };
   collectCalls(source);
   const scanFunction = (name, fn) => {
     if (!calledNames.has(name) && !isExportedWrapper(fn)) return;
-    const params = fn.parameters.map((param) => ts9.isIdentifier(param.name) ? param.name.text : void 0);
+    const params = fn.parameters.map((param) => ts10.isIdentifier(param.name) ? param.name.text : void 0);
     const sends = [];
     const visit = (node) => {
-      if (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts9.isIdentifier(node.expression.expression)) {
+      if (ts10.isCallExpression(node) && ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "send" && ts10.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts10.isObjectLiteralExpression(objectArg)) {
           const pathProp = propertyInitializer(objectArg, "path");
           const methodProp = propertyInitializer(objectArg, "method");
-          const pathName = pathProp && ts9.isIdentifier(pathProp) ? pathProp.text : void 0;
-          const methodName2 = methodProp && ts9.isIdentifier(methodProp) ? methodProp.text : void 0;
+          const pathName = pathProp && ts10.isIdentifier(pathProp) ? pathProp.text : void 0;
+          const methodName2 = methodProp && ts10.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 (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+      if (ts10.isCallExpression(node) && ts10.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 && ts9.isIdentifier(pathArg) ? pathArg.text : void 0;
-        const clientName = clientArg && ts9.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        const pathName = pathArg && ts10.isIdentifier(pathArg) ? pathArg.text : void 0;
+        const clientName = clientArg && ts10.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() });
       }
-      ts9.forEachChild(node, visit);
+      ts10.forEachChild(node, visit);
     };
     visit(fn);
     if (sends.length !== 1) return;
@@ -3670,17 +3948,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 (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);
+    if (ts10.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
+    if (ts10.isVariableDeclaration(node) && ts10.isIdentifier(node.name) && node.initializer && (ts10.isArrowFunction(node.initializer) || ts10.isFunctionExpression(node.initializer))) scanFunction(node.name.text, node.initializer);
+    ts10.forEachChild(node, visitTop);
   };
   visitTop(source);
   return specs;
 }
 function isExportedWrapper(fn) {
-  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;
+  const declaration = ts10.isFunctionDeclaration(fn) ? fn : ts10.isVariableDeclaration(fn.parent) ? fn.parent.parent.parent : void 0;
+  if (!declaration || !ts10.canHaveModifiers(declaration)) return false;
+  return ts10.getModifiers(declaration)?.some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
 }
 function classifyOutboundCallsInSource(source, filePath) {
   const calls = [];
@@ -3693,7 +3971,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 (ts9.isCallExpression(node)) {
+    if (ts10.isCallExpression(node)) {
       if (wrapperInternalRanges.some((range) => node.getStart(source) >= range.start && node.getEnd() <= range.end)) {
         return;
       }
@@ -3709,9 +3987,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 (ts9.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts9.isIdentifier(expr.expression) || ts9.isPropertyAccessExpression(expr.expression))) {
+      } else if (ts10.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts10.isIdentifier(expr.expression) || ts10.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
-        if (objectArg && ts9.isObjectLiteralExpression(objectArg)) {
+        if (objectArg && ts10.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");
@@ -3744,14 +4022,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 (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;
+      } else if (ts10.isCallExpression(expr) && ts10.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts10.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
+        const wrapperName = ts10.isIdentifier(expr) ? expr.text : ts10.isCallExpression(expr) && ts10.isIdentifier(expr.expression) ? expr.expression.text : "";
+        const wrapperArgs = ts10.isIdentifier(expr) ? node.arguments : ts10.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 && ts9.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
+        const receiver = clientArg && ts10.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);
@@ -3762,7 +4040,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 (ts9.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
+      } else if (ts10.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
         const receiver = receiverName(expr.expression);
         const rootReceiver = rootReceiverName(expr.expression);
         if (isSupportedEventReceiver(receiver, rootReceiver, serviceVariables)) {
@@ -3778,7 +4056,7 @@ function classifyOutboundCallsInSource(source, filePath) {
         }
       }
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -3792,12 +4070,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() ?? ts9.createSourceFile(
+  const source = snapshot?.sourceFile() ?? ts10.createSourceFile(
     filePath,
     text,
-    ts9.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    filePath.endsWith(".ts") ? ts9.ScriptKind.TS : ts9.ScriptKind.JS
+    filePath.endsWith(".ts") ? ts10.ScriptKind.TS : ts10.ScriptKind.JS
   );
   const bindingNames = new Set((await parseServiceBindings(
     repoPath,
@@ -3813,21 +4091,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 = ts9.createSourceFile(
+function parseLocalServiceCalls(text, filePath, source = ts10.createSourceFile(
   filePath,
   text,
-  ts9.ScriptTarget.Latest,
+  ts10.ScriptTarget.Latest,
   true,
-  filePath.endsWith(".ts") ? ts9.ScriptKind.TS : ts9.ScriptKind.JS
+  filePath.endsWith(".ts") ? ts10.ScriptKind.TS : ts10.ScriptKind.JS
 )) {
   const aliases = /* @__PURE__ */ new Map();
   const calls = [];
   const visit = (node) => {
-    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.initializer) {
+    if (ts10.isVariableDeclaration(node) && ts10.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 (ts9.isCallExpression(node)) {
+    if (ts10.isCallExpression(node)) {
       const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== "entities") calls.push({
         callType: "local_service_call",
@@ -3850,20 +4128,20 @@ function parseLocalServiceCalls(text, filePath, source = ts9.createSourceFile(
         })
       });
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(source);
   return calls;
 }
 function serviceLookup(expr, aliases) {
-  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()] };
+  if (ts10.isIdentifier(expr)) return aliases.get(expr.text);
+  if (ts10.isPropertyAccessExpression(expr) && expr.expression.getText() === "cds.services") return { service: expr.name.text, lookup: expr.getText(), chain: [expr.getText()] };
+  if (ts10.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts10.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 (!ts9.isPropertyAccessExpression(expr)) return void 0;
+  if (!ts10.isPropertyAccessExpression(expr)) return void 0;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return void 0;
   if (expr.name.text === "send") {
@@ -8692,4 +8970,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-CRSSXWQ2.js.map
+//# sourceMappingURL=chunk-GLZSDBRG.js.map