@saptools/service-flow 0.1.67 → 0.1.68

package/src/trace/002-trace-diagnostics.ts

@@ -7,7 +7,7 @@ export function loadTraceDiagnostics(
   workspaceId?: number,
 ): Array<Record<string, unknown>> {
   if (repoId === undefined && !includeWorkspaceDiagnostics) return [];
-  return db.prepare(`SELECT d.repo_id repoId,d.severity,d.code,d.message,
+  const diagnostics = db.prepare(`SELECT d.repo_id repoId,d.severity,d.code,d.message,
       d.source_file sourceFile,d.source_line sourceLine
     FROM diagnostics d LEFT JOIN repositories r ON r.id=d.repo_id
     WHERE (? IS NULL OR d.repo_id=?)
@@ -18,6 +18,41 @@ export function loadTraceDiagnostics(
       ) as Array<
         Record<string, unknown>
       >;
+  const pending = packagePendingCount(
+    db, repoId, includeWorkspaceDiagnostics, workspaceId,
+  );
+  if (pending > 0) diagnostics.unshift(packagePendingDiagnostic(pending));
+  return diagnostics;
+}
+
+function packagePendingCount(
+  db: Db,
+  repoId: number | undefined,
+  includeWorkspace: boolean,
+  workspaceId: number | undefined,
+): number {
+  const row = db.prepare(`SELECT COUNT(*) count FROM symbol_calls sc
+    JOIN repositories r ON r.id=sc.repo_id
+    WHERE sc.status='unresolved' AND sc.callee_symbol_id IS NULL
+      AND sc.unresolved_reason='package_resolution_pending'
+      AND (?=1 OR sc.repo_id=?)
+      AND (? IS NULL OR r.workspace_id=?)`).get(
+        includeWorkspace ? 1 : 0, repoId, workspaceId, workspaceId,
+      );
+  return Number(row?.count ?? 0);
+}
+
+function packagePendingDiagnostic(count: number): Record<string, unknown> {
+  return {
+    severity: 'warning',
+    code: 'package_import_resolution_pending',
+    message: 'Package-import facts await workspace linking.',
+    packageResolutionState: 'pre_link_pending',
+    pendingPackageImportCount: count,
+    graphState: 'stale',
+    requiredAction: 'relink',
+    remediation: 'Run service-flow link --force for this workspace.',
+  };
 }
 
 export function prependTraceDiagnostic(

package/src/trace/016-compact-projector.ts

@@ -20,10 +20,13 @@ import {
 } from './014-compact-contract.js';
 import {
   compactCompleteness, compactSafeCode, compactStatusCounts, compactStatusTotal,
-  projectCompactDecision, projectCompactDecisionTarget, projectCompactDiagnostics,
+  projectCompactDecisionTarget, projectCompactDiagnostics,
   projectCompactQuery, projectCompactStart,
-  removeEquivalentCompactPersistedDecision,
 } from './020-compact-field-projection.js';
+import {
+  projectObservationDecision,
+  type CompactDecisionNode,
+} from './024-compact-observation-decision.js';
 
 const REFERENCE_LIMIT = 5;
 
@@ -92,29 +95,25 @@ function observationDecision(
   input: CompactEdgeObservation,
   target: ResolvedNode,
 ): CompactDecisionV1 {
-  const decision = projectCompactDecision(input.decision);
-  if (decision.effectiveResolutionStatus && target.decisionTarget)
-    decision.effectiveTarget = target.decisionTarget;
-  if (decision.persistedResolutionStatus && input.decision?.persistedTarget) {
-    const persisted = persistedDecisionTarget(db, input.decision.persistedTarget);
-    if (persisted) decision.persistedTarget = persisted;
-  }
-  removeEquivalentCompactPersistedDecision(decision);
-  return decision;
+  return projectObservationDecision(
+    input, target, (value) => decisionInputNode(db, value),
+  );
 }
 
-function persistedDecisionTarget(
+function decisionInputNode(
   db: Db,
   target: CompactDecisionTargetInput,
-): string | undefined {
+): CompactDecisionNode {
   const numeric = numericId(target.id);
   if (target.kind === 'operation' && numeric !== undefined)
-    return operationNode(db, numeric)?.decisionTarget;
+    return operationNode(db, numeric) ?? {};
   if (target.kind === 'symbol' && numeric !== undefined)
-    return symbolNode(db, numeric)?.decisionTarget;
+    return symbolNode(db, numeric) ?? {};
   if (target.kind === 'handler_method' && numeric !== undefined)
-    return handlerNode(db, numeric)?.decisionTarget;
-  return projectCompactDecisionTarget(target.kind, target.id);
+    return handlerNode(db, numeric) ?? {};
+  return {
+    decisionTarget: projectCompactDecisionTarget(target.kind, target.id),
+  };
 }
 
 function resolveEndpoint(

package/src/trace/020-compact-field-projection.ts

@@ -17,8 +17,12 @@ import type {
   CompactStartV1,
   CompactStatusCountsV1,
 } from './014-compact-contract.js';
+import {
+  compactMissingRemediation,
+  projectCompactMissingNames,
+  type CompactMissingNameProjection,
+} from './021-compact-decision-normalization.js';
 
-const compactNameLimit = 8;
 const compactDiagnosticMessages: Readonly<Record<string, string>> = {
   schema_upgrade_required: 'The database schema must be upgraded before tracing.',
   reindex_required: 'Current analyzer facts are required before tracing.',
@@ -56,14 +60,10 @@ function resolutionDecision(input: CompactDecisionInput): CompactDecisionV1 {
 }
 
 function addNameDecision(out: CompactDecisionV1, input: CompactDecisionInput): void {
-  const allNames = safeVariableNames(input.missingVariableNames);
-  const names = allNames.slice(0, compactNameLimit);
-  const total = Math.max(compactCount(input.missingVariableCount), allNames.length);
-  if (names.length > 0) out.missingVariableNames = names;
-  if (total === 0) return;
-  out.missingVariableCount = total;
-  out.shownMissingVariableCount = names.length;
-  out.omittedMissingVariableCount = Math.max(0, total - names.length);
+  const projection = projectCompactMissingNames(
+    input.missingVariableNames, input.missingVariableCount,
+  );
+  applyMissingProjection(out, projection);
 }
 
 function addDynamicDecision(out: CompactDecisionV1, input: CompactDecisionInput): void {
@@ -117,14 +117,24 @@ function addRemediationDecision(
   out: CompactDecisionV1,
   input: CompactDecisionInput,
 ): void {
-  const hint = input.remediationCode
-    ? compactRemediationHint(input.remediationCode) : undefined;
+  const hint = decisionRemediation(input);
   if (!hint) return;
   out.remediationHint = hint;
   const total = Math.max(1, compactCount(input.remediationHintCount));
   out.omittedRemediationHintCount = Math.max(0, total - 1);
 }
 
+function decisionRemediation(input: CompactDecisionInput): string | undefined {
+  if (input.remediationCode === 'provide_runtime_variables') {
+    const projection = projectCompactMissingNames(
+      input.missingVariableNames, input.missingVariableCount,
+    );
+    return compactMissingRemediation(projection, 'detailed trace edge');
+  }
+  return input.remediationCode
+    ? compactRemediationHint(input.remediationCode) : undefined;
+}
+
 export function projectCompactDiagnostics(
   values: Array<Record<string, unknown>>,
 ): CompactProjectedDiagnostic[] {
@@ -200,15 +210,6 @@ export function compactStatusTotal(counts: CompactStatusCountsV1): number {
     + counts.ambiguous + counts.unresolved + counts.cycle;
 }
 
-export function removeEquivalentCompactPersistedDecision(
-  decision: CompactDecisionV1,
-): void {
-  if (decision.persistedResolutionStatus !== decision.effectiveResolutionStatus) return;
-  if (!decision.persistedTarget || decision.persistedTarget !== decision.effectiveTarget) return;
-  delete decision.persistedResolutionStatus;
-  delete decision.persistedTarget;
-}
-
 function compactBlockingDiagnostic(item: CompactDiagnosticRowV1): boolean {
   if (item[1] === 'error') return true;
   return item[2] === 'schema_upgrade_required'
@@ -242,9 +243,9 @@ function compactDiagnosticDetails(
   const out: CompactDiagnosticDetailsV1 = {};
   const reasonCode = compactSafeCode(value.reasonCode);
   if (reasonCode) out.reasonCode = reasonCode;
-  addDiagnosticNames(out, value);
+  if (code === 'trace_runtime_variables_missing') addDiagnosticNames(out, value);
   addDiagnosticCounts(out, value);
-  const hint = compactDiagnosticRemediation(code);
+  const hint = compactDiagnosticRemediation(code, out);
   if (hint) {
     out.remediationHint = hint;
     out.omittedHintCount = Math.max(
@@ -258,14 +259,21 @@ function addDiagnosticNames(
   out: CompactDiagnosticDetailsV1,
   value: Record<string, unknown>,
 ): void {
-  const allNames = safeVariableNames(compactStringArray(value.missingVariables));
-  const names = allNames.slice(0, compactNameLimit);
-  const total = Math.max(allNames.length, compactCount(value.missingVariableCount));
-  if (names.length > 0) out.missingVariableNames = names;
-  if (total === 0) return;
-  out.missingVariableCount = total;
-  out.shownMissingVariableCount = names.length;
-  out.omittedMissingVariableCount = Math.max(0, total - names.length);
+  const projection = projectCompactMissingNames(
+    compactStringArray(value.missingVariables), value.missingVariableCount,
+  );
+  applyMissingProjection(out, projection);
+}
+
+function applyMissingProjection(
+  out: CompactDecisionV1 | CompactDiagnosticDetailsV1,
+  projection: CompactMissingNameProjection,
+): void {
+  if (projection.names.length > 0) out.missingVariableNames = projection.names;
+  if (projection.total === 0) return;
+  out.missingVariableCount = projection.total;
+  out.shownMissingVariableCount = projection.shown;
+  out.omittedMissingVariableCount = projection.omitted;
 }
 
 function addDiagnosticCounts(
@@ -303,11 +311,19 @@ function compactDiagnosticSeverity(value: unknown): 'error' | 'warning' | 'info'
   return value === 'error' || value === 'warning' ? value : 'info';
 }
 
-function compactDiagnosticRemediation(code: string): string | undefined {
+function compactDiagnosticRemediation(
+  code: string,
+  details: CompactDiagnosticDetailsV1,
+): string | undefined {
   if (code === 'schema_upgrade_required' || code === 'reindex_required')
     return compactRemediationHint('reindex_and_link');
   if (code === 'trace_runtime_variables_missing')
-    return compactRemediationHint('provide_runtime_variables');
+    return compactMissingRemediation({
+      names: details.missingVariableNames ?? [],
+      total: details.missingVariableCount ?? 0,
+      shown: details.shownMissingVariableCount ?? 0,
+      omitted: details.omittedMissingVariableCount ?? 0,
+    }, 'detailed diagnostic');
   if (code === 'implementation_hint_mismatch')
     return compactRemediationHint('select_implementation');
   return undefined;
@@ -358,11 +374,6 @@ function compactSafeSourceFile(value: unknown): string | undefined {
     && !/^[a-z]+:\/\//i.test(value) && !/[\r\n]/.test(value) ? value : undefined;
 }
 
-function safeVariableNames(values: string[] | undefined): string[] {
-  return compactSortedUnique((values ?? [])
-    .filter((value) => /^[A-Za-z_$][\w$]*$/.test(value)));
-}
-
 function compactCount(value: unknown): number {
   return typeof value === 'number' && Number.isFinite(value)
     ? Math.max(0, Math.floor(value)) : 0;

package/src/trace/021-compact-decision-normalization.ts

@@ -0,0 +1,105 @@
+import { compareBinary } from './010-traversal-scope.js';
+import type {
+  CompactDecisionV1,
+  CompactStatus,
+} from './014-compact-contract.js';
+
+export const COMPACT_MISSING_NAME_LIMIT = 8;
+export const COMPACT_MISSING_NAME_MAX_LENGTH = 160;
+
+export interface CompactMissingNameProjection {
+  readonly names: string[];
+  readonly total: number;
+  readonly shown: number;
+  readonly omitted: number;
+}
+
+const identifier = '[A-Za-z_$][A-Za-z0-9_$]*';
+const member = `(?:(?:\\.|\\?\\.)${identifier}|(?:\\[|\\?\\.\\[)(?:0|[1-9][0-9]*)\\])`;
+const transform = '(?:(?:\\.|\\?\\.)(?:toLowerCase|toUpperCase|trim)\\(\\))?';
+const safeMissingName = new RegExp(`^${identifier}(?:${member})*${transform}$`);
+
+export function projectCompactMissingNames(
+  values: readonly string[] | undefined,
+  authoritativeCount: unknown,
+): CompactMissingNameProjection {
+  const raw = [...new Set((values ?? [])
+    .map((value) => value.trim())
+    .filter(Boolean))]
+    .sort(compareBinary);
+  const safe = raw.filter(isSafeCompactMissingName);
+  const names = safe.slice(0, COMPACT_MISSING_NAME_LIMIT);
+  const total = Math.max(compactCount(authoritativeCount), raw.length);
+  return {
+    names, total, shown: names.length,
+    omitted: Math.max(0, total - names.length),
+  };
+}
+
+export function isSafeCompactMissingName(value: string): boolean {
+  const normalized = value.trim();
+  return normalized.length > 0
+    && normalized.length <= COMPACT_MISSING_NAME_MAX_LENGTH
+    && !hasControlCharacter(normalized)
+    && safeMissingName.test(normalized);
+}
+
+export function normalizeCompactDecisionEquivalence(
+  decision: CompactDecisionV1,
+  status: CompactStatus,
+  canonicalTarget: string | undefined,
+  targetIdentityEqual = false,
+  persistedIdentityEqual = false,
+): void {
+  removeEquivalentPersistedDecision(
+    decision, status, canonicalTarget, persistedIdentityEqual,
+  );
+  if (decision.effectiveResolutionStatus === status)
+    delete decision.effectiveResolutionStatus;
+  if (targetIdentityEqual && canonicalTarget !== undefined
+    && decision.effectiveTarget === canonicalTarget)
+    delete decision.effectiveTarget;
+}
+
+export function compactMissingRemediation(
+  projection: CompactMissingNameProjection,
+  artifact: 'detailed diagnostic' | 'detailed trace edge',
+): string {
+  if (projection.total > 0 && projection.shown === projection.total)
+    return 'Provide the missing variable names listed in details.';
+  if (projection.shown > 0)
+    return `Provide the listed names; inspect the correlated ${artifact} for omitted names.`;
+  return `Inspect the correlated ${artifact} for missing variable names.`;
+}
+
+function removeEquivalentPersistedDecision(
+  decision: CompactDecisionV1,
+  status: CompactStatus,
+  canonicalTarget: string | undefined,
+  identityEqual: boolean,
+): void {
+  if (!identityEqual
+    || decision.persistedResolutionStatus !== status
+    || (decision.effectiveResolutionStatus !== undefined
+      && decision.persistedResolutionStatus
+        !== decision.effectiveResolutionStatus))
+    return;
+  if (!decision.persistedTarget || canonicalTarget === undefined
+    || decision.persistedTarget !== canonicalTarget)
+    return;
+  delete decision.persistedResolutionStatus;
+  delete decision.persistedTarget;
+}
+
+function compactCount(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.max(0, Math.floor(value)) : 0;
+}
+
+function hasControlCharacter(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}

package/src/trace/022-trace-fact-preflight.ts

@@ -0,0 +1,21 @@
+import type { Db } from '../db/connection.js';
+import { currentFactLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
+import { resolveTraversalWorkspaceId } from './010-traversal-scope.js';
+
+function workspaceScopeIsAmbiguous(db: Db): boolean {
+  const rows = db.prepare(`SELECT DISTINCT workspace_id workspaceId
+    FROM repositories ORDER BY workspace_id LIMIT 2`).all();
+  return rows.length > 1;
+}
+
+export function shouldDeferTraceStartSelection(
+  db: Db,
+  requestedWorkspaceId: number | undefined,
+  repoId: number | undefined,
+): boolean {
+  const workspaceId = resolveTraversalWorkspaceId(
+    db, requestedWorkspaceId, repoId,
+  );
+  if (workspaceId === undefined) return workspaceScopeIsAmbiguous(db);
+  return currentFactLifecycleDiagnostic(db, workspaceId) !== undefined;
+}

package/src/trace/023-nested-event-scopes.ts

@@ -0,0 +1,23 @@
+import type { Db } from '../db/connection.js';
+
+export function outboundScopeSymbolIds(
+  db: Db,
+  symbolIds: ReadonlySet<number> | undefined,
+  includeAsync: boolean,
+): ReadonlySet<number> | undefined {
+  if (!includeAsync || !symbolIds || symbolIds.size === 0) return symbolIds;
+  const ids = [...symbolIds];
+  const rows = db.prepare(`SELECT DISTINCT child.id FROM symbols parent
+    JOIN symbols child ON child.repo_id=parent.repo_id
+      AND child.source_file=parent.source_file
+      AND child.kind='event_registration'
+      AND parent.start_offset<=child.start_offset
+      AND parent.end_offset>=child.end_offset
+    WHERE parent.id IN (${ids.map(() => '?').join(',')})
+    ORDER BY child.id`).all(...ids);
+  return new Set([
+    ...ids,
+    ...rows.flatMap((row) =>
+      typeof row.id === 'number' ? [row.id] : []),
+  ]);
+}

package/src/trace/024-compact-observation-decision.ts

@@ -0,0 +1,76 @@
+import type {
+  CompactDecisionTargetInput,
+  CompactDecisionV1,
+  CompactEdgeObservation,
+} from './014-compact-contract.js';
+import { projectCompactDecision } from './020-compact-field-projection.js';
+import { normalizeCompactDecisionEquivalence } from
+  './021-compact-decision-normalization.js';
+
+export interface CompactDecisionNode {
+  key?: string;
+  decisionTarget?: string;
+}
+
+function resolvedNode(
+  value: CompactDecisionTargetInput | undefined,
+  resolve: (input: CompactDecisionTargetInput) => CompactDecisionNode,
+): CompactDecisionNode | undefined {
+  return value ? resolve(value) : undefined;
+}
+
+function applyEffectiveTarget(
+  decision: CompactDecisionV1,
+  effective: CompactDecisionNode | undefined,
+): void {
+  if (effective?.decisionTarget)
+    decision.effectiveTarget = effective.decisionTarget;
+}
+
+function applyPersistedTarget(
+  decision: CompactDecisionV1,
+  persisted: CompactDecisionNode | undefined,
+  status: string | undefined,
+): void {
+  if (persisted?.decisionTarget && status)
+    decision.persistedTarget = persisted.decisionTarget;
+}
+
+function sameCanonicalNode(
+  left: CompactDecisionNode | undefined,
+  right: CompactDecisionNode,
+): boolean {
+  return left?.key !== undefined && left.key === right.key;
+}
+
+function persistedCanonical(
+  persisted: CompactDecisionNode | undefined,
+  effective: CompactDecisionNode | undefined,
+  target: CompactDecisionNode,
+): boolean {
+  if (!sameCanonicalNode(persisted, target)) return false;
+  return effective?.key === undefined || effective.key === target.key;
+}
+
+export function projectObservationDecision(
+  input: CompactEdgeObservation,
+  target: CompactDecisionNode,
+  resolve: (value: CompactDecisionTargetInput) => CompactDecisionNode,
+): CompactDecisionV1 {
+  const decision = projectCompactDecision(input.decision);
+  const source = input.decision;
+  const effective = resolvedNode(source?.effectiveTarget, resolve);
+  const persisted = resolvedNode(source?.persistedTarget, resolve);
+  applyEffectiveTarget(decision, effective);
+  applyPersistedTarget(
+    decision, persisted, source?.persistedResolutionStatus,
+  );
+  normalizeCompactDecisionEquivalence(
+    decision,
+    input.status,
+    target.decisionTarget,
+    sameCanonicalNode(effective, target),
+    persistedCanonical(persisted, effective, target),
+  );
+  return decision;
+}

package/src/trace/025-trace-implementation-scope.ts

@@ -0,0 +1,123 @@
+import type { Db } from '../db/connection.js';
+import type { ImplementationHint } from '../types.js';
+import type { TraceGraphEdgeRow } from './012-trace-graph-lookups.js';
+
+export interface ImplementationHintOptions {
+  implementationRepo?: string;
+  implementationHints?: ImplementationHint[];
+}
+
+export interface ImplementationScope {
+  repoId?: number;
+  files: Set<string>;
+  symbolId?: number;
+  edge?: TraceGraphEdgeRow;
+}
+
+interface HandlerScopeRow {
+  repoId?: number;
+  sourceFile?: string;
+  symbolId?: number;
+}
+
+function normalizeOperation(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  return value.startsWith('/') ? value.slice(1) : value;
+}
+
+function implementationEdge(
+  db: Db,
+  operationId: string,
+): TraceGraphEdgeRow | undefined {
+  return db.prepare(`SELECT * FROM graph_edges
+    WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER'
+      AND from_kind='operation' AND from_id=?
+    ORDER BY CASE status WHEN 'resolved' THEN 0
+      WHEN 'ambiguous' THEN 1 ELSE 2 END,id LIMIT 1`)
+    .get(operationId) as TraceGraphEdgeRow | undefined;
+}
+
+function handlerScopeRow(db: Db, methodId: string): HandlerScopeRow | undefined {
+  return db.prepare(`SELECT hc.repo_id repoId,hc.source_file sourceFile,
+      s.id symbolId
+    FROM handler_methods hm
+    JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    LEFT JOIN symbols s ON s.repo_id=hc.repo_id
+      AND s.source_file=hc.source_file
+      AND s.qualified_name=hc.class_name || '.' || hm.method_name
+      AND s.start_line=hm.source_line
+    WHERE hm.id=?`).get(methodId) as HandlerScopeRow | undefined;
+}
+
+export function implementationScope(
+  db: Db,
+  operationId: string,
+): ImplementationScope {
+  const edge = implementationEdge(db, operationId);
+  if (!edge || edge.status !== 'resolved') return { files: new Set(), edge };
+  const row = handlerScopeRow(db, edge.to_id);
+  if (!row || typeof row.symbolId !== 'number')
+    return { repoId: row?.repoId, files: new Set(), edge };
+  return {
+    repoId: row.repoId,
+    files: new Set(row.sourceFile ? [row.sourceFile] : []),
+    symbolId: row.symbolId,
+    edge,
+  };
+}
+
+export function handlerScope(
+  db: Db,
+  methodId: string,
+): Omit<ImplementationScope, 'edge'> | undefined {
+  const row = handlerScopeRow(db, methodId);
+  if (!row || typeof row.symbolId !== 'number') return undefined;
+  return {
+    repoId: row.repoId,
+    files: new Set(row.sourceFile ? [row.sourceFile] : []),
+    symbolId: row.symbolId,
+  };
+}
+
+export function handlerFilesForOperation(
+  db: Db,
+  operationId: string,
+): Set<string> {
+  const op = db.prepare(`SELECT o.operation_name operationName,
+      o.operation_path operationPath,s.repo_id repoId
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+    WHERE o.id=?`).get(operationId) as {
+    operationName?: string;
+    operationPath?: string;
+    repoId?: number;
+  } | undefined;
+  if (!op) return new Set();
+  const operation = normalizeOperation(op.operationPath ?? op.operationName);
+  const rows = handlerFileRows(db, op.repoId, operation, op.operationName);
+  return new Set(rows.flatMap((row) =>
+    typeof row.sourceFile === 'string' ? [row.sourceFile] : []));
+}
+
+function handlerFileRows(
+  db: Db,
+  repoId: number | undefined,
+  operation: string | undefined,
+  operationName: string | undefined,
+): Array<{ sourceFile?: string }> {
+  return db.prepare(`SELECT DISTINCT hc.source_file sourceFile
+    FROM handler_classes hc
+    JOIN handler_methods hm ON hm.handler_class_id=hc.id
+    WHERE hc.repo_id=?
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
+      AND (hm.decorator_value=? OR hm.method_name=?
+        OR hm.decorator_value=?)`)
+    .all(repoId, operation, operation, operationName) as Array<{
+      sourceFile?: string;
+    }>;
+}