@saptools/service-flow 0.1.15 → 0.1.17

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.17
+
+- Replaced remaining raw-text outbound call detection with TypeScript AST classification so comments and strings do not create outbound facts or graph edges.
+- Added AST parser/range evidence for outbound calls and conservative CAP/service event registration ownership.
+- Tightened synthetic callback and async subscription classification to avoid generic response `.send()` and non-CAP event listener noise.
+- Expanded strict doctor ownerless source categories and examples.
+
+## 0.1.16
+
+- Index class property arrow/function members as executable symbols so outbound calls inside handler helper properties receive precise source-symbol ownership.
+- Add conservative synthetic callback symbols for top-level CAP lifecycle, route, and event callbacks that contain supported outbound calls.
+- Harden proxy-member symbol-call resolution with richer evidence and avoid ambiguous repository-wide member-name fallback.
+- Split `service-flow link` operation-call output into remote resolved, local resolved, unresolved, ambiguous, dynamic, and terminal buckets.
+- Extend strict doctor ownership diagnostics with ownerless outbound-call details by call type and syntactic gap.
+- Keep `OutboundCallFact.sourceSymbolQualifiedName` aligned with persistence by preferring explicit qualified names before line-range fallback.
+
 ## 0.1.15
 
 - Fixed `symbol_calls.evidence_json` persistence so inserted rows store the parser evidence object instead of a numeric repository id, with explicit initial resolved/unresolved statuses.

package/README.md

@@ -18,9 +18,9 @@ Index independent Git repositories, persist CAP/CDS facts in SQLite, resolve cro
 
 ---
 
-## 0.1.15 quality update
+## 0.1.17 quality update
 
-`service-flow` 0.1.15 fixes symbol-call evidence persistence so fresh databases store object-shaped parser evidence, extends strict doctor checks for evidence and parser-quality ratios, and conservatively resolves exported static class-member and exported shorthand object-map helper flows through relative imports without restoring broad symbol-call fallback noise.
+`service-flow` 0.1.17 hardens outbound extraction after the 0.1.16 audit. Outbound calls are classified from the TypeScript AST, so comments and strings are ignored; CAP/service lifecycle registrations that remain indexed receive synthetic event-registration owners; generic event emitters and response `.send()` calls are not treated as CAP service-flow edges; and `doctor --strict` reports actionable ownerless categories. The previous 0.1.16 source ownership and proxy-evidence improvements remain in place. It indexes class property arrow/function members, creates conservative synthetic callback symbols only for top-level framework callbacks containing supported outbound calls, prefers explicit outbound source-symbol names when provided, hardens proxy-member resolution away from ambiguous global name-only matches, and splits link output into remote/local/unresolved/ambiguous/dynamic/terminal operation-call buckets.
 
 ## ✨ Features
 
@@ -135,7 +135,7 @@ service-flow index --workspace /path/to/workspace --repo identity-service --forc
 
 ### 🔗 `service-flow link`
 
-Resolve indexed outbound calls after repositories have been indexed. This rebuilds the `graph_edges` table for the workspace.
+Resolve indexed outbound calls after repositories have been indexed. This rebuilds the `graph_edges` table for the workspace. The summary separates remote operation calls resolved, local operation calls resolved, unresolved operation calls, ambiguous operation calls, dynamic operation calls, and terminal call edges so local CAP service resolutions are not labeled as remote.
 
 ```bash
 service-flow link --workspace /path/to/workspace
@@ -155,7 +155,7 @@ target handler up to `--depth` instead of showing only calls in the first file.
 
 ### Symbol-scoped helper traversal
 
-`service-flow trace` starts from the selected handler method symbol, renders outbound calls owned by that symbol, and follows conservative local helper-call facts. Supported helper edges include same-file functions, `this.method()` calls, and exactly mapped relative imports/exports that resolve to an indexed executable symbol. Calls from unrelated functions in the same source file are not included merely because the file path matches.
+`service-flow trace` starts from the selected handler method symbol, renders outbound calls owned by that symbol, and follows conservative local helper-call facts. Handler helper properties such as `helper = async () => { ... }` and `helper = function () { ... }` are indexed as `ClassName.helper`; top-level CAP lifecycle, route, and event callbacks receive synthetic `module:<file>#callback:<line>` owners only when their body contains a supported outbound call or event subscription. Supported helper edges include same-file functions, `this.method()` calls, and exactly mapped relative imports/exports that resolve to an indexed executable symbol. Proxy-member calls keep factory/import evidence and avoid resolving by repository-wide member name alone when the target is ambiguous. Calls from unrelated functions in the same source file are not included merely because the file path matches.
 
 Local CAP calls through `cds.services.<Service>.<operation>()`, bracket service lookups, and simple aliases are indexed as local operation calls. Linking first stays within the same repository and matches the target operation by exact qualified CDS service name, exact simple service name, exact service path, or an unambiguous service-path suffix. If no same-repository service exists, the linker can use implementation-context evidence to resolve model-package operations for helper packages: a resolved/ambiguous implementation candidate, registration package, or dependency/import edge must tie the caller repository to the model operation. Name-only global matches are preserved as unresolved candidate evidence rather than guessed links. Entity accessors such as `cds.services.db.entities(...)` are treated as entity metadata access, not operation calls.
 
@@ -473,3 +473,8 @@ Handler registrations persist parsed class names and import sources. Linking res
 ### Graph variables
 
 The `graph` command accepts repeatable `--var key=value` options, matching `trace`, for runtime substitution previews in JSON or Mermaid output.
+
+
+### 0.1.17 parser ownership policy
+
+Outbound call extraction is AST-based and ignores comments, block comments, and string literals. CAP/service `.on(...)` registrations are indexed only when the receiver has CAP/service evidence, and top-level registrations receive `module:<relative-file>#event:<event-name>:<line>` synthetic owners. Generic event emitters such as desktop or window events are ignored by default rather than guessed as CAP async edges. Unsupported source shapes are surfaced through diagnostics and strict doctor ownerless categories instead of guessed graph edges.

package/TECHNICAL-NOTE.md

@@ -6,6 +6,14 @@
 - Trace cycle safety: trace queues carry repository IDs, visited scope keys are independent of depth, graph edge IDs are emitted once, and revisiting an already-seen downstream operation scope creates a cycle marker instead of recursive expansion.
 - SQLite reliability: the package uses a persistent SQLite connection per opened database, bound parameters, transactions, WAL, busy timeouts, read-only openings for query commands, and connection-local foreign-key enforcement. Native driver loading failures produce an actionable startup error before output rendering.
 
+## 0.1.16 audit follow-up notes
+
+- Executable symbol parsing now treats class property arrow functions and function-expression initializers as method-like symbols with `ClassName.memberName` qualified names. Their body ranges are persisted so outbound-call ownership can use the existing shortest enclosing range lookup.
+- Synthetic callback symbols are intentionally narrow: only top-level CAP lifecycle, route, and event-registration callbacks whose bodies contain supported outbound calls/subscriptions are indexed as `module:<relative-file>#callback:<line>`. Ordinary anonymous callbacks remain out of scope to avoid broad call-graph noise.
+- Proxy-member calls record proxy variable, factory expression, factory import source, and candidate strategy. Resolution prefers explicit object-map evidence and treats ambiguous repository-wide member-name matches as ambiguous instead of picking the first symbol row. Full whole-program TypeScript data-flow remains a non-goal.
+- `link` summaries now distinguish remote and local operation-call resolutions, while retaining the aggregate `resolvedCount` in the programmatic result for compatibility.
+- Strict doctor source-ownership diagnostics include ownerless groupings by call type and syntactic gap so remaining ownerless calls can be audited without weakening the threshold.
+
 ## 0.1.15 audit follow-up notes
 
 - Symbol-call rows now require object-shaped parser evidence in strict doctor; this catches numeric JSON regressions that `json_valid()` alone would miss.
@@ -60,3 +68,8 @@
 - Fingerprints hash normalized package facts and package bytes in addition to source file paths/content and analyzer version.
 - The CLI version imports package metadata, so package metadata, `service-flow --version`, changelog, and analyzer/fingerprint version share one release source.
 - Supported runtime is Node.js 24+ with `node:sqlite` validation; older runtimes should fail with a compatibility message instead of a late `DatabaseSync` error.
+
+
+### 0.1.17 parser ownership policy
+
+Outbound call extraction is AST-based and ignores comments, block comments, and string literals. CAP/service `.on(...)` registrations are indexed only when the receiver has CAP/service evidence, and top-level registrations receive `module:<relative-file>#event:<event-name>:<line>` synthetic owners. Generic event emitters such as desktop or window events are ignored by default rather than guessed as CAP async edges. Unsupported source shapes are surfaced through diagnostics and strict doctor ownerless categories instead of guessed graph edges.

package/dist/{chunk-ZSUL2X77.js → chunk-HBR27SPD.js}

@@ -528,33 +528,6 @@ import ts4 from "typescript";
 function lineOf3(text, idx) {
   return text.slice(0, idx).split("\n").length;
 }
-function firstArg2(body, key) {
-  return new RegExp(`${key}\\s*:\\s*([^,}\\n]+)`).exec(body)?.[1]?.trim();
-}
-function matchingParen(text, open) {
-  let depth = 0;
-  let quote;
-  let escaped = false;
-  for (let i = open; i < text.length; i += 1) {
-    const ch = text[i] ?? "";
-    if (quote) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === quote) quote = void 0;
-      continue;
-    }
-    if (ch === '"' || ch === "'" || ch === "`") {
-      quote = ch;
-      continue;
-    }
-    if (ch === "(") depth += 1;
-    if (ch === ")") {
-      depth -= 1;
-      if (depth === 0) return i;
-    }
-  }
-  return -1;
-}
 function entityFromExpression(expr) {
   if (!expr) return void 0;
   if (ts4.isIdentifier(expr) || ts4.isStringLiteral(expr) || ts4.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
@@ -606,64 +579,98 @@ function queryWarning(expr) {
   if (/^\s*\w+\s*$/.test(expr)) return "query_variable_without_static_initializer";
   return "dynamic_entity_expression";
 }
+function parserEvidence(source, node, extra) {
+  return { parser: "typescript_ast", startOffset: node.getStart(source), endOffset: node.getEnd(), ...extra };
+}
+function isStringLike(expr) {
+  return Boolean(expr && (ts4.isStringLiteral(expr) || ts4.isNoSubstitutionTemplateLiteral(expr)));
+}
+function literalText(expr) {
+  if (isStringLike(expr)) return expr.text;
+  return void 0;
+}
+function objectPropertyText(object, key) {
+  const prop = object.properties.find((property) => ts4.isPropertyAssignment(property) && nameOfProperty(property.name) === key);
+  return prop ? prop.initializer.getText() : void 0;
+}
+function nameOfProperty(name) {
+  if (ts4.isIdentifier(name) || ts4.isStringLiteral(name) || ts4.isNumericLiteral(name)) return name.text;
+  return void 0;
+}
+function collectServiceVariables(source) {
+  const vars = /* @__PURE__ */ new Set(["cds", "messaging", "messageClient", "eventClient"]);
+  const visit = (node) => {
+    if (ts4.isVariableDeclaration(node) && ts4.isIdentifier(node.name) && node.initializer) {
+      const text = node.initializer.getText(source);
+      if (/cds\.connect\.(to|messaging)\s*\(/.test(text) || /create.*(Client|Remote|Service|Messaging)/.test(text)) vars.add(node.name.text);
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(source);
+  return vars;
+}
+function receiverName(expr) {
+  if (ts4.isIdentifier(expr)) return expr.text;
+  if (ts4.isPropertyAccessExpression(expr)) return expr.getText();
+  return void 0;
+}
+function isSupportedEventReceiver(receiver, serviceVariables) {
+  if (!receiver) return false;
+  if (receiver === "cds") return true;
+  if (serviceVariables.has(receiver)) return true;
+  if (/^(srv|service|serviceClient|messaging|messageClient|eventClient|.*Client)$/.test(receiver)) return true;
+  return false;
+}
+function classifyOutboundCallsInSource(source, filePath) {
+  const calls = [];
+  const sourceFile = normalizePath(filePath);
+  const initializers = variableInitializers(source);
+  const serviceVariables = collectServiceVariables(source);
+  const add = (node, fact, extra) => {
+    calls.push({ node, fact: { ...fact, sourceFile, sourceLine: lineOf3(source.text, node.getStart(source)), confidence: fact.confidence ?? 0.8, evidence: parserEvidence(source, node, extra) } });
+  };
+  const visit = (node) => {
+    if (ts4.isCallExpression(node)) {
+      const expr = node.expression;
+      const exprText = expr.getText(source);
+      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 (ts4.isPropertyAccessExpression(expr) && expr.name.text === "send" && ts4.isIdentifier(expr.expression)) {
+        const objectArg = node.arguments[0];
+        if (objectArg && ts4.isObjectLiteralExpression(objectArg)) {
+          const receiver = expr.expression.text;
+          const query = objectPropertyText(objectArg, "query");
+          const op = objectPropertyText(objectArg, "path") ?? objectPropertyText(objectArg, "event");
+          add(node, { callType: query ? "remote_query" : "remote_action", serviceVariableName: receiver, method: stripQuotes(objectPropertyText(objectArg, "method") ?? "POST"), operationPathExpr: op ? `/${stripQuotes(op).replace(/^\//, "")}` : void 0, queryEntity: query ? extractQueryEntity(query) : void 0, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4 }, { receiver, classifier: "service_client_send_object" });
+        }
+      } else if (ts4.isPropertyAccessExpression(expr) && ["emit", "publish", "on"].includes(expr.name.text)) {
+        const receiver = receiverName(expr.expression);
+        if (expr.name.text !== "on" || isSupportedEventReceiver(receiver, serviceVariables)) {
+          const eventName = literalText(node.arguments[0]);
+          if (eventName) add(node, { callType: expr.name.text === "on" ? "async_subscribe" : "async_emit", serviceVariableName: receiver, eventNameExpr: eventName }, { receiver, classifier: expr.name.text === "on" ? "cap_service_event_subscription" : "cap_service_event_emit" });
+        }
+      } else if (exprText === "axios" || exprText === "executeHttpRequest" || exprText === "useOrFetchDestination") {
+        add(node, { callType: "external_http", payloadSummary: summarizeExpression(node.arguments.map((arg) => arg.getText(source)).join(", ")), confidence: 0.7, unresolvedReason: "External HTTP destination is outside indexed CAP services" });
+      }
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(source);
+  return calls;
+}
+function containsSupportedOutboundCall(node) {
+  const source = node.getSourceFile();
+  const start = node.getFullStart();
+  const end = node.getEnd();
+  return classifyOutboundCallsInSource(source, source.fileName).some((call) => call.node.getStart(source) >= start && call.node.getEnd() <= end);
+}
 async function parseOutboundCalls(repoPath, filePath) {
   const text = await fs6.readFile(path7.join(repoPath, filePath), "utf8");
-  const out = [];
-  for (const m of text.matchAll(/(\w+)\.send\s*\(\s*\{([\s\S]*?)\}\s*\)/g)) {
-    const body = m[2] ?? "";
-    const query = firstArg2(body, "query");
-    const op = firstArg2(body, "path") ?? firstArg2(body, "event");
-    out.push({
-      callType: query ? "remote_query" : "remote_action",
-      serviceVariableName: m[1],
-      method: stripQuotes(firstArg2(body, "method") ?? "POST"),
-      operationPathExpr: op ? `/${stripQuotes(op).replace(/^\//, "")}` : void 0,
-      queryEntity: extractQueryEntity(query ?? ""),
-      payloadSummary: summarizeExpression(body),
-      sourceFile: normalizePath(filePath),
-      sourceLine: lineOf3(text, m.index ?? 0),
-      confidence: op || query ? 0.8 : 0.4
-    });
-  }
-  for (const m of text.matchAll(/cds\.run\s*\(/g)) {
-    const open = (m.index ?? 0) + m[0].lastIndexOf("(");
-    const close = matchingParen(text, open);
-    const expr = close > open ? text.slice(open + 1, close) : "";
-    const entity = extractQueryEntity(expr);
-    out.push({
-      callType: "local_db_query",
-      queryEntity: entity,
-      payloadSummary: summarizeExpression(expr),
-      sourceFile: normalizePath(filePath),
-      sourceLine: lineOf3(text, m.index ?? 0),
-      confidence: entity ? 0.9 : 0.55,
-      unresolvedReason: entity ? void 0 : queryWarning(expr)
-    });
-  }
-  for (const m of text.matchAll(
-    /(\w+)\.(emit|publish|on)\s*\(\s*(['"`])([^'"`]+)\3/g
-  ))
-    out.push({
-      callType: m[2] === "on" ? "async_subscribe" : "async_emit",
-      serviceVariableName: m[1],
-      eventNameExpr: m[4],
-      sourceFile: normalizePath(filePath),
-      sourceLine: lineOf3(text, m.index ?? 0),
-      confidence: 0.8
-    });
-  for (const m of text.matchAll(
-    /(?:axios\s*\(|executeHttpRequest\s*\(|useOrFetchDestination\s*\()([\s\S]*?)\)/g
-  ))
-    out.push({
-      callType: "external_http",
-      payloadSummary: summarizeExpression(m[1] ?? ""),
-      sourceFile: normalizePath(filePath),
-      sourceLine: lineOf3(text, m.index ?? 0),
-      confidence: 0.7,
-      unresolvedReason: "External HTTP destination is outside indexed CAP services"
-    });
-  out.push(...parseLocalServiceCalls(text, filePath));
-  return out;
+  const source = ts4.createSourceFile(filePath, text, ts4.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts4.ScriptKind.TS : ts4.ScriptKind.JS);
+  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...parseLocalServiceCalls(text, filePath)];
 }
 function parseLocalServiceCalls(text, filePath) {
   const source = ts4.createSourceFile(filePath, text, ts4.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts4.ScriptKind.TS : ts4.ScriptKind.JS);
@@ -1318,6 +1325,8 @@ function linkCalls(db, workspaceId, vars, generation) {
   let edgeCount = 0;
   let unresolvedCount = 0;
   let resolvedCount = 0;
+  let remoteResolvedCount = 0;
+  let localResolvedCount = 0;
   let ambiguousCount = 0;
   let dynamicCount = 0;
   let terminalCount = 0;
@@ -1326,12 +1335,14 @@ function linkCalls(db, workspaceId, vars, generation) {
     const result = insertCallEdge(db, workspaceId, call, vars, generation);
     edgeCount += 1;
     resolvedCount += result.status === "resolved" ? 1 : 0;
+    remoteResolvedCount += result.status === "resolved" && result.callType !== "local_service_call" ? 1 : 0;
+    localResolvedCount += result.status === "resolved" && result.callType === "local_service_call" ? 1 : 0;
     unresolvedCount += result.status === "unresolved" ? 1 : 0;
     ambiguousCount += result.status === "ambiguous" ? 1 : 0;
     dynamicCount += result.status === "dynamic" ? 1 : 0;
     terminalCount += result.status === "terminal" ? 1 : 0;
   }
-  return { edgeCount, unresolvedCount, resolvedCount, ambiguousCount, dynamicCount, terminalCount };
+  return { edgeCount, unresolvedCount, resolvedCount, remoteResolvedCount, localResolvedCount, ambiguousCount, dynamicCount, terminalCount };
 }
 function insertCallEdge(db, workspaceId, call, vars, generation) {
   const callType = String(call.call_type);
@@ -1344,11 +1355,11 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
   const evidence = callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0);
   if (callType === "local_service_call" && call.unresolved_reason === "transport_client_method" && !resolution.target && resolution.candidates.length === 0) {
     db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "HANDLER_CALLS_EXTERNAL_HTTP", "terminal", "call", String(call.id), "external", String(op || "transport_client_method"), Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, classification: "transport_client_method" }), 0, generation);
-    return { status: "terminal" };
+    return { status: "terminal", callType };
   }
   if (resolution.target) {
     db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, callType === "local_service_call" ? "LOCAL_CALL_RESOLVES_TO_OPERATION" : "REMOTE_CALL_RESOLVES_TO_OPERATION", "resolved", "call", String(call.id), "operation", String(resolution.target.operationId), resolution.target.score, JSON.stringify(evidence), isDynamic ? 1 : 0, generation);
-    return { status: "resolved" };
+    return { status: "resolved", callType };
   }
   const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
   const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
@@ -1356,7 +1367,7 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
   const targetKind = callType === "local_db_query" ? "db_entity" : callType.startsWith("async_") ? "event" : "external";
   const targetId = callType === "local_db_query" ? String(call.query_entity ?? "unknown") : String(call.event_name_expr ?? op ?? call.id);
   db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, edgeType, status, "call", String(call.id), targetKind, targetId, Number(call.confidence ?? 0.2), JSON.stringify(evidence), isDynamic || resolution.status === "dynamic" ? 1 : 0, unresolvedReason, generation);
-  return { status };
+  return { status, callType };
 }
 function callEvidence(call, resolution, servicePath, op, destination) {
   return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: call.alias_chain_json ? JSON.parse(String(call.alias_chain_json)) : void 0, transport: call.call_type === "local_service_call" ? "local" : void 0, targetRepo: resolution.target?.repoName, targetOperation: resolution.target?.operationName, helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0, candidates: resolution.candidates, candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
@@ -1983,6 +1994,7 @@ export {
   parseHandlerRegistrations,
   redactText,
   redactValue,
+  containsSupportedOutboundCall,
   parseOutboundCalls,
   parseServiceBindings,
   applyVariables,
@@ -1991,4 +2003,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-ZSUL2X77.js.map
+//# sourceMappingURL=chunk-HBR27SPD.js.map