@saptools/service-flow 0.1.72 → 0.1.73

package/src/parsers/event-environment-reference.ts

@@ -8,7 +8,10 @@ import {
   type SymbolImportBinding,
 } from './symbol-import-bindings.js';
 import type { RepositorySourceContext } from './ts-project.js';
-import { EVENT_ENVIRONMENT_KEY_ALLOWLIST } from
+import {
+  DEFAULT_EVENT_ENVIRONMENT_KEYS,
+  normalizeEventEnvironmentKeys,
+} from
   './environment-declarations.js';
 
 export type EventEnvironmentTransform = 'toUpperCase' | 'toLowerCase';
@@ -34,13 +37,10 @@ interface ResolutionContext {
   sourceFile: string;
   depth: number;
   seen: Set<string>;
+  allowedKeys: ReadonlySet<string>;
 }
 
 const maxEnvironmentReferenceDepth = 6;
-const allowedEnvironmentKeys = new Set<string>(
-  EVENT_ENVIRONMENT_KEY_ALLOWLIST,
-);
-
 function unwrapExpression(expression: ts.Expression): ts.Expression {
   if (ts.isParenthesizedExpression(expression)
     || ts.isAsExpression(expression)
@@ -173,6 +173,15 @@ function identifierReference(
   const local = resolveBinding(identifier, identifier);
   if (local.declaration && local.initializer && local.immutable)
     return resolveEnvironmentReference(local.initializer, context);
+  const binding = bindingFor(
+    identifier, collectSymbolImportBindings(context.source),
+  );
+  if (binding?.moduleKind === 'package') return {
+    status: 'refused',
+    sourceKey: identifier.getText(context.source),
+    transforms: [],
+    reason: 'event_environment_package_import_unsupported',
+  };
   const imported = importedIdentifier(identifier, context);
   if (!imported) return undefined;
   return resolveEnvironmentReference(imported.initializer, {
@@ -199,7 +208,7 @@ function resolveEnvironmentReference(
   const next = { ...context, depth: context.depth + 1, seen };
   const value = unwrapExpression(expression);
   const key = processEnvironmentKey(value);
-  if (key && allowedEnvironmentKeys.has(key)) return {
+  if (key && context.allowedKeys.has(key)) return {
     status: 'resolved', sourceKey, environmentKey: key, transforms: [],
     sourceFile: context.sourceFile,
     startOffset: value.getStart(context.source), endOffset: value.getEnd(),
@@ -215,9 +224,11 @@ export function createEventEnvironmentReferenceResolver(
   sources: RepositorySourceContext,
   source: ts.SourceFile,
   sourceFile: string,
+  configuredKeys: readonly string[] = DEFAULT_EVENT_ENVIRONMENT_KEYS,
 ): EventEnvironmentReferenceResolver {
+  const allowedKeys = new Set(normalizeEventEnvironmentKeys(configuredKeys));
   return (expression) => resolveEnvironmentReference(expression, {
-    sources, source, sourceFile, depth: 0, seen: new Set(),
+    sources, source, sourceFile, depth: 0, seen: new Set(), allowedKeys,
   });
 }
 

package/src/parsers/event-receiver-analysis.ts

@@ -23,7 +23,7 @@ export type EventReceiverUnresolvedReason =
 export interface EventReceiverEvidenceSite {
   startOffset: number;
   endOffset: number;
-  flow: BindingLexicalSite['flow'];
+  flow: BindingLexicalSite['flow'] | 'reference';
   connect: boolean;
 }
 
@@ -34,6 +34,7 @@ export interface EventReceiverProof {
   receiverClassification: 'cap_evidence' | 'name_fallback' | 'unproven';
   receiverProof: string;
   unresolvedReason?: EventReceiverUnresolvedReason;
+  fallbackRefusedReason?: string;
   consideredBindingSites: EventReceiverEvidenceSite[];
 }
 
@@ -41,7 +42,6 @@ export interface EventReceiverIndex {
   source: ts.SourceFile;
   lexical: BindingLexicalIndex;
   imports: SymbolImportBinding[];
-  compatibilityNames: Set<string>;
 }
 
 const eventReceiverNames = new Set([
@@ -218,17 +218,6 @@ function sameExecutionScope(
   return sameScope(left, right);
 }
 
-function unsupportedBranch(node: ts.Node): boolean {
-  let current: ts.Node | undefined = node.parent;
-  while (current && !ts.isSourceFile(current) && !ts.isFunctionLike(current)) {
-    if (ts.isIfStatement(current) || ts.isConditionalExpression(current)
-      || ts.isSwitchStatement(current)
-      || ts.isIterationStatement(current, false)) return true;
-    current = current.parent;
-  }
-  return false;
-}
-
 function reachingSites(
   index: EventReceiverIndex,
   declaration: BindingLexicalSite,
@@ -275,11 +264,6 @@ function lexicalProof(
     return value ? [value] : [];
   });
   const considered = evidenceSites(sites, identifier.text, index.imports);
-  if (sites.some((site) => unsupportedBranch(site.node)))
-    return unproven(
-      'event_receiver_unproven_binding', 'branch_dependent_assignment',
-      considered,
-    );
   if (expressions.length > 0
     && expressions.every((value) => isCapConnect(value, index.imports)))
     return {
@@ -313,15 +297,24 @@ function unproven(
 }
 
 function compatibilityFallback(
-  name: string,
-  index: EventReceiverIndex,
+  identifier: ts.Identifier,
+  refusedReason: string,
+  consideredBindingSites: EventReceiverEvidenceSite[],
 ): Omit<EventReceiverProof, 'effectiveReceiver' | 'receiver'
   | 'rootReceiver'> | undefined {
-  return eventReceiverNames.has(name) || index.compatibilityNames.has(name)
+  return eventReceiverNames.has(identifier.text)
     ? {
         receiverClassification: 'name_fallback',
         receiverProof: 'compatibility_name_fallback',
-        consideredBindingSites: [],
+        fallbackRefusedReason: refusedReason,
+        consideredBindingSites: consideredBindingSites.length > 0
+          ? consideredBindingSites
+          : [{
+              startOffset: identifier.getStart(identifier.getSourceFile()),
+              endOffset: identifier.getEnd(),
+              flow: 'reference',
+              connect: false,
+            }],
       }
     : undefined;
 }
@@ -344,9 +337,8 @@ function identifierProof(
     consideredBindingSites: [],
   };
   const proven = lexicalProof(identifier, use, index);
-  if (proven?.receiverClassification === 'cap_evidence') return proven;
-  return compatibilityFallback(identifier.text, index)
-    ?? proven
+  return proven
+    ?? compatibilityFallback(identifier, 'binding_not_found', [])
     ?? unproven('event_receiver_unproven_binding', 'binding_not_found');
 }
 
@@ -364,13 +356,11 @@ function rootIdentifier(
 
 export function createEventReceiverIndex(
   source: ts.SourceFile,
-  compatibilityNames: Set<string>,
 ): EventReceiverIndex {
   return {
     source,
     lexical: createBindingLexicalIndex(source),
     imports: collectSymbolImportBindings(source),
-    compatibilityNames,
   };
 }
 

package/src/parsers/outbound-call-classifier.ts

@@ -566,7 +566,7 @@ export function classifyOutboundCallsInSource(
   const initializers = variableInitializers(source);
   const serviceVariables = collectServiceVariables(source);
   const eventAnalysis = createEventCallAnalysisContext(
-    source, serviceVariables, options.importedEventNameResolver,
+    source, options.importedEventNameResolver,
     options.eventEnvironmentReferenceResolver,
   );
   const wrapperSpecs = collectWrapperSpecs(source);

package/src/parsers/stable-local-value.ts

@@ -205,6 +205,16 @@ function inertUnaryUse(node: ts.Node): boolean {
     || ts.isTypeOfExpression(parent)) && parent.expression === node));
 }
 
+function typePositionUse(node: ts.Node): boolean {
+  let current: ts.Node | undefined = node.parent;
+  while (current && !ts.isStatement(current)
+    && !ts.isSourceFile(current)) {
+    if (ts.isTypeNode(current)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
 function safeReferenceUse(
   node: ts.Identifier,
   declaration: ts.Identifier,
@@ -213,7 +223,8 @@ function safeReferenceUse(
   return memberReceiverUse(use, declaration)
     || commonJsExportUse(use)
     || esmExportUse(use)
-    || inertUnaryUse(use);
+    || inertUnaryUse(use)
+    || typePositionUse(use);
 }
 
 export function stableLocalValueReference(

package/src/parsers/string-constant-lookups.ts

@@ -33,7 +33,9 @@ export interface StaticStringRefusal {
   exported: boolean;
   stable: boolean;
   reason: 'event_name_constant_member_not_string'
-    | 'event_name_constant_container_mutable';
+    | 'event_name_constant_container_mutable'
+    | 'event_name_constant_container_unsafe_reference'
+    | 'event_name_constant_container_unsupported_shape';
 }
 
 export interface StringConstantLookups {
@@ -144,7 +146,7 @@ function collectEnum(
       source, key, member, {
         kind: 'enum_member', containerName: statement.name.text,
         memberName, exported, stable,
-        reason: 'event_name_constant_container_mutable',
+        reason: 'event_name_constant_container_unsafe_reference',
       },
     ));
     else if (!value) lookups.refusedMembers.set(key, refusalFact(
@@ -173,6 +175,44 @@ function objectLiteral(
   return ts.isObjectLiteralExpression(value) ? value : undefined;
 }
 
+function objectMemberName(
+  property: ts.ObjectLiteralElementLike,
+): string | undefined {
+  if (ts.isSpreadAssignment(property)) return undefined;
+  return property.name ? propertyName(property.name) : undefined;
+}
+
+function supportedObjectShape(object: ts.ObjectLiteralExpression): boolean {
+  return object.properties.every((property) =>
+    ts.isPropertyAssignment(property)
+    && propertyName(property.name) !== undefined);
+}
+
+function refuseObjectShape(
+  source: ts.SourceFile,
+  object: ts.ObjectLiteralExpression,
+  declaration: ts.VariableDeclaration,
+  exported: boolean,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name)) return;
+  for (const property of object.properties) {
+    const memberName = objectMemberName(property);
+    if (!memberName) continue;
+    const key = `${declaration.name.text}.${memberName}`;
+    lookups.refusedMembers.set(key, refusalFact(
+      source, key, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text,
+        memberName,
+        exported,
+        stable: false,
+        reason: 'event_name_constant_container_unsupported_shape',
+      },
+    ));
+  }
+}
+
 function collectObject(
   source: ts.SourceFile,
   statement: ts.VariableStatement,
@@ -186,38 +226,48 @@ function collectObject(
   const stable = stableLocalValueReference(source, declaration.name);
   const exported = hasExportModifier(statement)
     || exports.has(declaration.name.text);
+  if (!supportedObjectShape(object)) {
+    refuseObjectShape(source, object, declaration, exported, lookups);
+    return;
+  }
   for (const property of object.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const memberName = propertyName(property.name);
-    if (!memberName) continue;
-    const key = `${declaration.name.text}.${memberName}`;
-    const value = stringValue(property.initializer);
-    if (!stable) lookups.refusedMembers.set(key, refusalFact(
-      source, key, property, {
-        kind: 'const_object_property',
-        containerName: declaration.name.text, memberName,
-        exported, stable,
-        reason: 'event_name_constant_container_mutable',
-      },
-    ));
-    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+    if (ts.isPropertyAssignment(property))
+      collectObjectProperty(
+        source, property, declaration.name.text, exported, stable, lookups,
+      );
+  }
+}
+
+function collectObjectProperty(
+  source: ts.SourceFile,
+  property: ts.PropertyAssignment,
+  containerName: string,
+  exported: boolean,
+  stable: boolean,
+  lookups: StringConstantLookups,
+): void {
+  const memberName = propertyName(property.name);
+  if (!memberName) return;
+  const key = `${containerName}.${memberName}`;
+  const value = stringValue(property.initializer);
+  if (!stable || !value) {
+    lookups.refusedMembers.set(key, refusalFact(
       source, key, property, {
-        kind: 'const_object_property',
-        containerName: declaration.name.text, memberName,
+        kind: 'const_object_property', containerName, memberName,
         exported, stable,
-        reason: 'event_name_constant_member_not_string',
-      },
-    ));
-    else lookups.objectProperties.set(key, staticFact(
-      source, key, value, property, {
-        kind: 'const_object_property',
-        containerName: declaration.name.text,
-        memberName,
-        exported,
-        stable,
+        reason: stable
+          ? 'event_name_constant_member_not_string'
+          : 'event_name_constant_container_unsafe_reference',
       },
     ));
+    return;
   }
+  lookups.objectProperties.set(key, staticFact(
+    source, key, value, property, {
+      kind: 'const_object_property', containerName, memberName,
+      exported, stable,
+    },
+  ));
 }
 
 function collectIdentifier(

package/src/trace/edge-target.ts

@@ -0,0 +1,65 @@
+import type { TraceGraphRow } from './evidence.js';
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : {};
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function effectiveTarget(
+  evidence: Record<string, unknown>,
+): string | undefined {
+  const effective = record(evidence.effectiveResolution);
+  const service = text(
+    effective.targetServicePath ?? evidence.targetServicePath,
+  );
+  const operation = text(
+    effective.targetOperationPath ?? evidence.targetOperationPath,
+  );
+  return service && operation ? `${service}${operation}` : undefined;
+}
+
+function runtimeCandidateTarget(
+  evidence: Record<string, unknown>,
+): string | undefined {
+  const candidate = record(evidence.runtimeResolvedCandidate);
+  const service = text(candidate.servicePath);
+  const operation = text(candidate.operationPath);
+  return service && operation ? `${service}${operation}` : undefined;
+}
+
+function semanticEdgeTarget(
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+): string | undefined {
+  if (row.edge_type === 'HANDLER_RUNS_DB_QUERY')
+    return `Entity: ${row.to_id || 'unknown'}`;
+  if (row.edge_type === 'HANDLER_RUNS_REMOTE_QUERY')
+    return text(evidence.remoteQueryTarget)
+      ?? `Remote query: ${row.to_id || 'unknown'}`;
+  if (row.edge_type === 'HANDLER_CALLS_EXTERNAL_HTTP') {
+    const target = record(evidence.externalTarget);
+    return text(target.label) ?? `External endpoint: ${row.to_id || 'unknown'}`;
+  }
+  return row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
+    ? text(evidence.eventShapeCandidateTargetLabel) : undefined;
+}
+
+export function edgeTarget(
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+): string {
+  const exact = effectiveTarget(evidence) ?? runtimeCandidateTarget(evidence);
+  if (exact) return exact;
+  const semantic = semanticEdgeTarget(row, evidence);
+  if (semantic) return semantic;
+  const service = text(evidence.servicePath);
+  const operation = text(evidence.operationPath);
+  if (service && operation) return `${service}${operation}`;
+  const targetOperation = text(evidence.targetOperation);
+  const targetRepo = text(evidence.targetRepo) ?? '';
+  return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
+}

package/src/trace/event-subscriber-traversal.ts

@@ -64,9 +64,23 @@ export interface EventSubscriberTransition {
   omittedSymbolCallUnresolvedReasonCharacterCount?: number;
   matchStrategy?: string;
   dispatchCertainty?: string;
+  subscriptionConsumerRepoId?: number;
+  subscriptionConsumerRepoName?: string;
+  dispatchProvenances?: EventDispatchProvenance[];
+  dispatchProvenanceCount?: number;
+  shownDispatchProvenanceCount?: number;
+  omittedDispatchProvenanceCount?: number;
   handler?: EventSubscriberSymbolTarget;
 }
 
+export interface EventDispatchProvenance {
+  graphEdgeId: number;
+  matchStrategy: string;
+  dispatchCertainty: string;
+  consumerRepoId?: number;
+  consumerRepoName?: string;
+}
+
 export interface EventSubscriberTransitionQuery {
   workspaceId: number;
   graphGeneration: number;
@@ -171,6 +185,10 @@ export function eventTransitionEvidence(
     eventName: transition.eventName,
     matchStrategy: transition.matchStrategy ?? 'workspace_exact_event_name',
     dispatchCertainty: transition.dispatchCertainty ?? 'static_name_only',
+    dispatchProvenances: transition.dispatchProvenances,
+    dispatchProvenanceCount: transition.dispatchProvenanceCount,
+    shownDispatchProvenanceCount: transition.shownDispatchProvenanceCount,
+    omittedDispatchProvenanceCount: transition.omittedDispatchProvenanceCount,
     associationBasis: transition.associationBasis,
     dispatchScope: transition.dispatchScope,
     roleSiteMatchCount: transition.roleSiteMatchCount,
@@ -239,11 +257,57 @@ export function loadEventSubscriberTransitions(
       subscribe.call_site_start_offset,subscribe.call_site_end_offset,ge.id`).all(
     query.workspaceId, query.graphGeneration,
   );
-  return rows.flatMap((raw) => {
+  const transitions = rows.flatMap((raw) => {
     const row = eventRowForQuery(raw, query);
     const transition = row ? transitionFromRow(row) : undefined;
     return transition ? [transition] : [];
   });
+  return deduplicateDispatchProvenance(transitions);
+}
+
+const dispatchProvenanceLimit = 5;
+
+function transitionIdentity(value: EventSubscriberTransition): string {
+  const subscription = value.subscribeCallId ?? `edge:${value.graphEdgeId}`;
+  return `${value.eventName}\0${subscription}\0${value.targetKind}\0${
+    value.targetId}\0${value.status}`;
+}
+
+function dispatchProvenance(
+  value: EventSubscriberTransition,
+): EventDispatchProvenance {
+  return {
+    graphEdgeId: value.graphEdgeId,
+    matchStrategy: value.matchStrategy ?? 'workspace_exact_event_name',
+    dispatchCertainty: value.dispatchCertainty ?? 'static_name_only',
+    consumerRepoId: value.subscriptionConsumerRepoId,
+    consumerRepoName: value.subscriptionConsumerRepoName,
+  };
+}
+
+function deduplicateDispatchProvenance(
+  values: EventSubscriberTransition[],
+): EventSubscriberTransition[] {
+  const groups = new Map<string, EventSubscriberTransition[]>();
+  for (const value of values) {
+    const key = transitionIdentity(value);
+    groups.set(key, [...(groups.get(key) ?? []), value]);
+  }
+  return [...groups.values()].map((group) => {
+    const first = group[0];
+    if (!first || group.length === 1) return first;
+    const provenances = group.map(dispatchProvenance).slice(
+      0, dispatchProvenanceLimit,
+    );
+    return {
+      ...first,
+      dispatchProvenances: provenances,
+      dispatchProvenanceCount: group.length,
+      shownDispatchProvenanceCount: provenances.length,
+      omittedDispatchProvenanceCount: group.length - provenances.length,
+    };
+  }).filter((value): value is EventSubscriberTransition =>
+    value !== undefined);
 }
 
 function eventRowForQuery(
@@ -394,6 +458,12 @@ function associationEvidence(
       : undefined,
     matchStrategy: stringValue(evidence.matchStrategy),
     dispatchCertainty: stringValue(evidence.dispatchCertainty),
+    subscriptionConsumerRepoId: numberValue(
+      evidence.subscriptionConsumerRepositoryId,
+    ),
+    subscriptionConsumerRepoName: stringValue(
+      evidence.subscriptionConsumerRepositoryName,
+    ),
   };
 }
 

package/src/trace/evidence.ts

@@ -23,13 +23,6 @@ export interface TraceGraphRow extends Record<string, unknown> {
   status?: string;
 }
 
-interface Candidate {
-  servicePath?: string;
-  operationPath?: string;
-  repoName?: string;
-  operationName?: string;
-  score?: number;
-}
 interface RuntimeDiagnosticTotals {
   missing: Set<string>;
   candidateCount: number;
@@ -342,27 +335,6 @@ export function runtimeNoCandidateDiagnostics(
   });
 }
 
-export function edgeTarget(row: TraceGraphRow, evidence: Record<string, unknown>): string {
-  const effective = parseObject(evidence.effectiveResolution);
-  const targetServicePath = stringValue(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue(effective.targetOperationPath ?? evidence.targetOperationPath);
-  if (targetServicePath && targetOperationPath) return `${targetServicePath}${targetOperationPath}`;
-  const runtimeCandidate = evidence.runtimeResolvedCandidate as Candidate | undefined;
-  if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath) return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
-  const servicePath = stringValue(evidence.servicePath);
-  const operationPath = stringValue(evidence.operationPath);
-  const targetOperation = stringValue(evidence.targetOperation);
-  const targetRepo = stringValue(evidence.targetRepo) ?? '';
-  if (row.edge_type === 'HANDLER_RUNS_DB_QUERY') return `Entity: ${row.to_id || 'unknown'}`;
-  if (row.edge_type === 'HANDLER_RUNS_REMOTE_QUERY') return stringValue(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || 'unknown'}`;
-  if (row.edge_type === 'HANDLER_CALLS_EXTERNAL_HTTP') {
-    const target = parseObject(evidence.externalTarget);
-    return stringValue(target.label) ?? `External endpoint: ${row.to_id || 'unknown'}`;
-  }
-  if (servicePath && operationPath) return `${servicePath}${operationPath}`;
-  return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
-}
-
 function persistedResolution(row: TraceGraphRow): Record<string, unknown> {
   return {
     status: row.status,

package/src/trace/trace-scope-execution.ts

@@ -2,10 +2,10 @@ import type { Db } from '../db/connection.js';
 import type { TraceEdge, TraceOptions } from '../types.js';
 import {
   baseTraceEvidence,
-  edgeTarget,
   runtimeResolution,
   type TraceGraphRow,
 } from './evidence.js';
+import { edgeTarget } from './edge-target.js';
 import { dynamicCandidateBranches } from './dynamic-branches.js';
 import {
   contextualRuntimeResolution,

package/src/types.ts

@@ -286,7 +286,9 @@ export interface GeneratedConstantFact {
   stable: boolean;
   resolutionStatus: 'resolved' | 'refused';
   unresolvedReason?: 'event_name_constant_member_not_string'
-    | 'event_name_constant_container_mutable';
+    | 'event_name_constant_container_mutable'
+    | 'event_name_constant_container_unsafe_reference'
+    | 'event_name_constant_container_unsupported_shape';
   declarationStartOffset: number;
   declarationEndOffset: number;
   valueStartOffset: number;

package/src/version.ts

@@ -1,4 +1,4 @@
 import packageJson from '../package.json' with { type: 'json' };
 
 export const VERSION = packageJson.version;
-export const ANALYZER_VERSION = '0.1.71-facts.1';
+export const ANALYZER_VERSION = '0.1.73-facts.1';