@saptools/service-flow 0.1.72 → 0.1.73

package/src/linker/package-event-constant-resolver.ts

@@ -20,7 +20,6 @@ interface EventConstantCall {
   id: number;
   binding: SymbolImportReference;
   evidence: Record<string, unknown>;
-  unresolvedReason?: string | null;
 }
 
 interface PackageRepository {
@@ -56,8 +55,7 @@ function jsonRecord(value: unknown): Record<string, unknown> | undefined {
 }
 
 function callRows(db: Db, workspaceId: number): EventConstantCall[] {
-  const rows = db.prepare(`SELECT c.id,c.evidence_json evidenceJson,
-    c.unresolved_reason unresolvedReason
+  const rows = db.prepare(`SELECT c.id,c.evidence_json evidenceJson
     FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
     WHERE r.workspace_id=?
       AND c.call_type IN ('async_emit','async_subscribe')
@@ -69,11 +67,8 @@ function callRows(db: Db, workspaceId: number): EventConstantCall[] {
     const binding = parsePackageImportReference(
       evidence?.eventNameConstantImportBinding,
     );
-    return typeof row.id === 'number' && evidence && binding ? [{
-      id: row.id, evidence, binding,
-      unresolvedReason: typeof row.unresolvedReason === 'string'
-        ? row.unresolvedReason : null,
-    }] : [];
+    return typeof row.id === 'number' && evidence && binding
+      ? [{ id: row.id, evidence, binding }] : [];
   });
 }
 
@@ -179,15 +174,16 @@ function resolveRows(
     'event_name_constant_container_not_exported', fields,
   );
   if (Number(row.stable) !== 1) return failure(
-    'event_name_constant_container_mutable', fields,
+    constantRefusalReason(row), fields,
   );
   if (row.resolutionStatus !== 'resolved'
     || typeof row.value !== 'string') return failure(
-    String(row.unresolvedReason) === 'event_name_constant_container_mutable'
-      ? 'event_name_constant_container_mutable'
-      : 'event_name_constant_member_not_string',
+    constantRefusalReason(row),
     fields,
   );
+  if (row.value.length === 0) return failure(
+    'event_name_constant_value_empty', fields,
+  );
   return {
     ...fields,
     status: 'resolved',
@@ -198,6 +194,19 @@ function resolveRows(
   };
 }
 
+function constantRefusalReason(row: Record<string, unknown>): string {
+  const reason = String(row.unresolvedReason ?? '');
+  if ([
+    'event_name_constant_container_mutable',
+    'event_name_constant_container_unsafe_reference',
+    'event_name_constant_container_unsupported_shape',
+    'event_name_constant_member_not_string',
+  ].includes(reason)) return reason;
+  return Number(row.stable) === 1
+    ? 'event_name_constant_member_not_string'
+    : 'event_name_constant_container_unsafe_reference';
+}
+
 function resolveCall(
   db: Db,
   workspaceId: number,
@@ -234,11 +243,6 @@ export function expectedPackageEventConstantResolution(
   });
 }
 
-function receiverReason(call: EventConstantCall): string | null {
-  return call.evidence.receiverClassification === 'unproven'
-    ? call.unresolvedReason ?? 'event_receiver_unproven_binding' : null;
-}
-
 function resolutionEvidence(
   call: EventConstantCall,
   resolution: PackageEventConstantResolution,
@@ -284,7 +288,7 @@ export function linkPackageEventConstants(
     unresolved_reason=?,evidence_json=? WHERE id=?`);
   for (const call of callRows(db, workspaceId)) {
     const resolution = resolveCall(db, workspaceId, call);
-    const reason = receiverReason(call) ?? resolution.reason ?? null;
+    const reason = resolution.reason ?? null;
     const sourceExpression = call.evidence.eventNameConstantSourceExpression;
     update.run(
       resolution.value ?? String(sourceExpression ?? ''),

package/src/output/repository-inspection.ts

@@ -0,0 +1,11 @@
+import type { RepoRow } from '../db/repositories.js';
+
+export function projectRepositoryInspection(
+  repository: RepoRow,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(repository).filter(
+      ([key]) => key !== 'environment_declarations_json',
+    ),
+  );
+}

package/src/parsers/environment-declarations.ts

@@ -3,10 +3,12 @@ import type { RepositorySourceContext } from './ts-project.js';
 export const ENVIRONMENT_DECLARATIONS_SCHEMA =
   'service-flow/environment-declarations@1';
 export const ENVIRONMENT_DECLARATION_RECORD_CAP = 32;
-export const EVENT_ENVIRONMENT_KEY_ALLOWLIST = ['SHARD_CODE'] as const;
+export const EVENT_ENVIRONMENT_KEY_CAP = 16;
+export const DEFAULT_EVENT_ENVIRONMENT_KEYS = ['SHARD_CODE'] as const;
+export const EVENT_ENVIRONMENT_KEY_ALLOWLIST =
+  DEFAULT_EVENT_ENVIRONMENT_KEYS;
 
-export type EventEnvironmentKey =
-  typeof EVENT_ENVIRONMENT_KEY_ALLOWLIST[number];
+export type EventEnvironmentKey = string;
 export type EnvironmentDeclarationProvenance =
   | 'env_declaration_manifest'
   | 'env_declaration_mta'
@@ -24,6 +26,7 @@ export interface EnvironmentDeclaration {
 
 export interface EnvironmentDeclarationsFact {
   schema: typeof ENVIRONMENT_DECLARATIONS_SCHEMA;
+  allowedKeys: string[];
   status: 'complete' | 'ambiguous' | 'not_applicable' | 'incomplete';
   reason: string | null;
   recordCap: typeof ENVIRONMENT_DECLARATION_RECORD_CAP;
@@ -33,7 +36,6 @@ export interface EnvironmentDeclarationsFact {
   declarations: EnvironmentDeclaration[];
 }
 
-const allowedKeys = new Set<string>(EVENT_ENVIRONMENT_KEY_ALLOWLIST);
 const allowedProvenance = new Set<EnvironmentDeclarationProvenance>([
   'env_declaration_manifest',
   'env_declaration_mta',
@@ -42,6 +44,22 @@ const allowedProvenance = new Set<EnvironmentDeclarationProvenance>([
 ]);
 const environmentValueLimit = 512;
 const dynamicEnvironmentValue = /\$\{|\$\(|~\{|\(\(/;
+const environmentKeyGrammar = /^[A-Z_][A-Z0-9_]{0,63}$/;
+
+export function validEventEnvironmentKey(value: string): boolean {
+  return environmentKeyGrammar.test(value);
+}
+
+export function normalizeEventEnvironmentKeys(
+  values: readonly string[] = DEFAULT_EVENT_ENVIRONMENT_KEYS,
+): string[] {
+  const unique = [...new Set(values)].sort((left, right) =>
+    left < right ? -1 : left > right ? 1 : 0);
+  if (unique.length === 0 || unique.length > EVENT_ENVIRONMENT_KEY_CAP
+    || !unique.every(validEventEnvironmentKey))
+    throw new Error('invalid_event_environment_keys');
+  return unique;
+}
 
 function hasControlCharacter(value: string): boolean {
   for (const character of value) {
@@ -80,6 +98,7 @@ function declaration(
   provenance: EnvironmentDeclarationProvenance,
   sourceFile: string,
   startOffset: number,
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration[] {
   if (!allowedKeys.has(key) || typeof value !== 'string'
     || !value || value.length > environmentValueLimit
@@ -107,6 +126,8 @@ function valueOffset(
 function jsonDeclarations(
   filePath: string,
   text: string,
+  keys: readonly string[],
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration[] {
   let parsed: unknown;
   try {
@@ -118,13 +139,14 @@ function jsonDeclarations(
     return [];
   const env = (parsed as Record<string, unknown>).env;
   if (!env || typeof env !== 'object' || Array.isArray(env)) return [];
-  return EVENT_ENVIRONMENT_KEY_ALLOWLIST.flatMap((key) => {
+  return keys.flatMap((key) => {
     const value = (env as Record<string, unknown>)[key];
     const keyOffset = text.indexOf(`"${key}"`);
     const offset = typeof value === 'string'
       ? valueOffset(text, value, keyOffset + key.length + 2) : keyOffset;
     return declaration(
       key, value, 'env_declaration_dev', filePath, Math.max(0, offset),
+      allowedKeys,
     );
   });
 }
@@ -132,6 +154,7 @@ function jsonDeclarations(
 function dotenvDeclarations(
   filePath: string,
   text: string,
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration[] {
   const values: EnvironmentDeclaration[] = [];
   let offset = 0;
@@ -144,6 +167,7 @@ function dotenvDeclarations(
       values.push(...declaration(
         match[1], value, 'env_declaration_dotenv', filePath,
         offset + valueOffset(line, value, line.indexOf('=') + 1),
+        allowedKeys,
       ));
     offset += line.length + 1;
   }
@@ -158,6 +182,7 @@ function yamlDeclarations(
   filePath: string,
   text: string,
   provenance: EnvironmentDeclarationProvenance,
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration[] {
   const values: EnvironmentDeclaration[] = [];
   let envIndent: number | undefined;
@@ -177,6 +202,7 @@ function yamlDeclarations(
           values.push(...declaration(
             match[1], value, provenance, filePath,
             offset + valueOffset(line, value, line.indexOf(':') + 1),
+            allowedKeys,
           ));
       }
     }
@@ -188,14 +214,20 @@ function yamlDeclarations(
 function snapshotDeclarations(
   filePath: string,
   text: string,
+  keys: readonly string[],
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration[] {
   const name = filePath.split('/').at(-1);
-  if (name === 'nodemon.json') return jsonDeclarations(filePath, text);
-  if (name === '.env') return dotenvDeclarations(filePath, text);
+  if (name === 'nodemon.json')
+    return jsonDeclarations(filePath, text, keys, allowedKeys);
+  if (name === '.env')
+    return dotenvDeclarations(filePath, text, allowedKeys);
   if (name === 'manifest.yml')
-    return yamlDeclarations(filePath, text, 'env_declaration_manifest');
+    return yamlDeclarations(
+      filePath, text, 'env_declaration_manifest', allowedKeys,
+    );
   return name === 'mta.yaml'
-    ? yamlDeclarations(filePath, text, 'env_declaration_mta') : [];
+    ? yamlDeclarations(filePath, text, 'env_declaration_mta', allowedKeys) : [];
 }
 
 function compareDeclaration(
@@ -207,24 +239,43 @@ function compareDeclaration(
   return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
 }
 
+function declarationIdentityValid(
+  item: Record<string, unknown>,
+  allowedKeys: ReadonlySet<string>,
+): boolean {
+  return typeof item.key === 'string'
+    && allowedKeys.has(item.key)
+    && typeof item.provenance === 'string'
+    && allowedProvenance.has(
+      item.provenance as EnvironmentDeclarationProvenance,
+    );
+}
+
+function declarationValueValid(item: Record<string, unknown>): boolean {
+  return typeof item.value === 'string'
+    && item.value.length > 0
+    && item.value.length <= environmentValueLimit
+    && !hasControlCharacter(item.value)
+    && !dynamicEnvironmentValue.test(item.value);
+}
+
+function declarationLocationValid(item: Record<string, unknown>): boolean {
+  return typeof item.sourceFile === 'string'
+    && item.sourceFile.length > 0
+    && Number.isInteger(item.startOffset)
+    && Number(item.startOffset) >= 0
+    && Number.isInteger(item.endOffset)
+    && Number(item.endOffset) > Number(item.startOffset);
+}
+
 function parsedDeclaration(
   value: unknown,
+  allowedKeys: ReadonlySet<string>,
 ): EnvironmentDeclaration | undefined {
   const item = record(value);
-  if (!item || typeof item.key !== 'string'
-    || !allowedKeys.has(item.key)
-    || typeof item.value !== 'string' || item.value.length === 0
-    || item.value.length > environmentValueLimit
-    || hasControlCharacter(item.value)
-    || dynamicEnvironmentValue.test(item.value)
-    || typeof item.provenance !== 'string'
-    || !allowedProvenance.has(
-      item.provenance as EnvironmentDeclarationProvenance,
-    )
-    || typeof item.sourceFile !== 'string' || item.sourceFile.length === 0
-    || !Number.isInteger(item.startOffset) || Number(item.startOffset) < 0
-    || !Number.isInteger(item.endOffset)
-    || Number(item.endOffset) <= Number(item.startOffset)) return undefined;
+  if (!item || !declarationIdentityValid(item, allowedKeys)
+    || !declarationValueValid(item)
+    || !declarationLocationValid(item)) return undefined;
   return item as unknown as EnvironmentDeclaration;
 }
 
@@ -265,14 +316,31 @@ function statusValid(
     && Number(item.omitted) > 0;
 }
 
+function parsedAllowedKeys(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)
+    || !value.every((item): item is string => typeof item === 'string'))
+    return undefined;
+  try {
+    const normalized = normalizeEventEnvironmentKeys(value);
+    return normalized.length === value.length
+      && normalized.every((item, index) => item === value[index])
+      ? normalized : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export function parseEnvironmentDeclarationsFact(
   value: unknown,
 ): EnvironmentDeclarationsFact | undefined {
   const item = record(parseJson(value));
   if (!item || item.schema !== ENVIRONMENT_DECLARATIONS_SCHEMA
     || !Array.isArray(item.declarations)) return undefined;
+  const keys = parsedAllowedKeys(item.allowedKeys);
+  if (!keys) return undefined;
+  const allowedKeys = new Set(keys);
   const declarations = item.declarations.flatMap((entry) => {
-    const parsed = parsedDeclaration(entry);
+    const parsed = parsedDeclaration(entry, allowedKeys);
     return parsed ? [parsed] : [];
   });
   if (declarations.length !== item.declarations.length
@@ -286,16 +354,22 @@ export function parseEnvironmentDeclarationsFact(
 
 export function collectEnvironmentDeclarations(
   sources: RepositorySourceContext,
+  configuredKeys: readonly string[] = DEFAULT_EVENT_ENVIRONMENT_KEYS,
 ): EnvironmentDeclarationsFact {
+  const keys = normalizeEventEnvironmentKeys(configuredKeys);
+  const allowedKeys = new Set(keys);
   const all = sources.entries().flatMap((snapshot) =>
-    snapshotDeclarations(snapshot.filePath, snapshot.text))
+    snapshotDeclarations(
+      snapshot.filePath, snapshot.text, keys, allowedKeys,
+    ))
     .sort(compareDeclaration);
   const values = new Set(all.map((item) => `${item.key}\0${item.value}`));
-  const ambiguous = EVENT_ENVIRONMENT_KEY_ALLOWLIST.some((key) =>
+  const ambiguous = keys.some((key) =>
     [...values].filter((value) => value.startsWith(`${key}\0`)).length > 1);
   const declarations = all.slice(0, ENVIRONMENT_DECLARATION_RECORD_CAP);
   return {
     schema: ENVIRONMENT_DECLARATIONS_SCHEMA,
+    allowedKeys: keys,
     status: ambiguous
       ? 'ambiguous'
       : all.length > ENVIRONMENT_DECLARATION_RECORD_CAP
@@ -313,9 +387,12 @@ export function collectEnvironmentDeclarations(
   };
 }
 
-export function emptyEnvironmentDeclarations(): EnvironmentDeclarationsFact {
+export function emptyEnvironmentDeclarations(
+  configuredKeys: readonly string[] = DEFAULT_EVENT_ENVIRONMENT_KEYS,
+): EnvironmentDeclarationsFact {
   return {
     schema: ENVIRONMENT_DECLARATIONS_SCHEMA,
+    allowedKeys: normalizeEventEnvironmentKeys(configuredKeys),
     status: 'not_applicable',
     reason: null,
     recordCap: ENVIRONMENT_DECLARATION_RECORD_CAP,

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

@@ -55,9 +55,15 @@ interface EventNameState {
   resolved: ExpressionResolution;
   unresolvedReason?: string;
   constant?: StaticStringConstant;
+  foldedConstants?: StaticStringConstant[];
   packageImportReference?: SymbolImportReference;
 }
 
+const CAP_CRUD_EVENTS = new Set(['READ', 'CREATE', 'UPDATE', 'DELETE']);
+const KNOWN_NON_CAP_EVENT_RECEIVERS = new Set([
+  'io', 'socket', 'writeStream', 'file', 'win', 'app',
+]);
+
 function eventNameReason(
   resolved: ExpressionResolution,
 ): string | undefined {
@@ -67,40 +73,111 @@ function eventNameReason(
     : 'dynamic_event_name_unsupported_expression';
 }
 
+function stringConstantLookup(
+  expression: ts.Expression,
+  context: EventCallAnalysisContext,
+): ImportedEventNameResult | StaticStringLookupResult {
+  const local = resolveStringConstant(expression, context.constants);
+  return local.status === 'not_found'
+    ? context.importedConstant?.(expression) ?? local : local;
+}
+
+function foldedTemplateState(
+  expression: ts.TemplateExpression,
+  context: EventCallAnalysisContext,
+): EventNameState | undefined {
+  let eventName = expression.head.text;
+  const placeholderKeys: string[] = [];
+  const constants: StaticStringConstant[] = [];
+  for (const span of expression.templateSpans) {
+    const key = span.expression.getText(expression.getSourceFile()).trim();
+    const lookup = stringConstantLookup(span.expression, context);
+    if (lookup.status === 'resolved') {
+      eventName += lookup.constant.value;
+      constants.push(lookup.constant);
+    } else {
+      eventName += `\${${key}}`;
+      placeholderKeys.push(key);
+    }
+    eventName += span.literal.text;
+  }
+  if (constants.length === 0) return undefined;
+  const empty = eventName.length === 0;
+  return {
+    eventName: empty ? expression.getText(expression.getSourceFile()) : eventName,
+    resolved: {
+      status: empty ? 'dynamic'
+        : placeholderKeys.length > 0 ? 'dynamic' : 'static',
+      sourceKind: 'template_with_substitutions',
+      value: empty ? undefined : eventName,
+      rawExpression: expression.getText(expression.getSourceFile()),
+      placeholderKeys,
+      evidence: ['event_name_template_static_holes_folded'],
+    },
+    unresolvedReason: empty
+      ? 'event_name_constant_value_empty'
+      : placeholderKeys.length > 0
+        ? 'dynamic_event_name_identifier' : undefined,
+    foldedConstants: constants,
+  };
+}
+
+function resolvedConstantState(
+  expression: ts.Expression,
+  constant: StaticStringConstant,
+): EventNameState {
+  const empty = constant.value.length === 0;
+  return {
+    eventName: empty ? expression.getText(expression.getSourceFile())
+      : constant.value,
+    resolved: {
+      status: empty ? 'dynamic' : 'static',
+      sourceKind: constant.kind,
+      value: empty ? undefined : constant.value,
+      rawExpression: expression.getText(expression.getSourceFile()),
+      placeholderKeys: [],
+      evidence: [`event_name_${constant.kind}`],
+    },
+    unresolvedReason: empty ? 'event_name_constant_value_empty' : undefined,
+    constant,
+  };
+}
+
+function refusedConstantState(
+  expression: ts.Expression,
+  lookup: ImportedEventNameResult | StaticStringLookupResult,
+): EventNameState | undefined {
+  if (lookup.status !== 'refused') return undefined;
+  const raw = expression.getText(expression.getSourceFile());
+  return {
+    eventName: raw,
+    resolved: {
+      status: 'dynamic',
+      sourceKind: 'dynamic_expression',
+      rawExpression: raw,
+      placeholderKeys: [],
+      evidence: [lookup.reason],
+    },
+    unresolvedReason: lookup.reason,
+    packageImportReference: packageReference(lookup),
+  };
+}
+
 function eventNameState(
   node: ts.CallExpression,
   context: EventCallAnalysisContext,
 ): EventNameState | undefined {
   const expression = node.arguments[0];
   if (expression) {
-    const local = resolveStringConstant(expression, context.constants);
-    const lookup = local.status === 'not_found'
-      ? context.importedConstant?.(expression) ?? local
-      : local;
-    if (lookup.status === 'resolved') return {
-      eventName: lookup.constant.value,
-      resolved: {
-        status: 'static',
-        sourceKind: lookup.constant.kind,
-        value: lookup.constant.value,
-        rawExpression: expression.getText(node.getSourceFile()),
-        placeholderKeys: [],
-        evidence: [`event_name_${lookup.constant.kind}`],
-      },
-      constant: lookup.constant,
-    };
-    if (lookup.status === 'refused') return {
-      eventName: expression.getText(node.getSourceFile()),
-      resolved: {
-        status: 'dynamic',
-        sourceKind: 'dynamic_expression',
-        rawExpression: expression.getText(node.getSourceFile()),
-        placeholderKeys: [],
-        evidence: [lookup.reason],
-      },
-      unresolvedReason: lookup.reason,
-      packageImportReference: packageReference(lookup),
-    };
+    if (ts.isTemplateExpression(expression)) {
+      const folded = foldedTemplateState(expression, context);
+      if (folded) return folded;
+    }
+    const lookup = stringConstantLookup(expression, context);
+    if (lookup.status === 'resolved')
+      return resolvedConstantState(expression, lookup.constant);
+    const refused = refusedConstantState(expression, lookup);
+    if (refused) return refused;
   }
   const resolved = resolveExpression(expression, node, 'operation_path');
   const eventName = resolved.value
@@ -139,7 +216,42 @@ function excludedEvent(
   if (state.resolved.status !== 'static') return false;
   if (receiver.effectiveReceiver === 'cds'
     && CDS_LIFECYCLE_EVENTS.has(state.eventName)) return true;
-  return method === 'on' && state.eventName === 'error';
+  return method === 'on'
+    && (state.eventName === 'error'
+      || (CAP_CRUD_EVENTS.has(state.eventName)
+        && capCrudReceiver(receiver)));
+}
+
+function capCrudReceiver(receiver: EventReceiverProof): boolean {
+  const name = receiver.rootReceiver ?? receiver.effectiveReceiver;
+  return name === 'this'
+    || ['cds', 'srv', 'service', 'serviceClient'].includes(name);
+}
+
+function receiverRootName(expression: ts.Expression): string | undefined {
+  if (ts.isIdentifier(expression)) return expression.text;
+  if (ts.isPropertyAccessExpression(expression)
+    || ts.isElementAccessExpression(expression))
+    return receiverRootName(expression.expression);
+  if (ts.isCallExpression(expression))
+    return receiverRootName(expression.expression);
+  return undefined;
+}
+
+function pipeReceiver(expression: ts.Expression): boolean {
+  return ts.isCallExpression(expression)
+    && ts.isPropertyAccessExpression(expression.expression)
+    && expression.expression.name.text === 'pipe';
+}
+
+function knownNonCapReceiver(
+  expression: ts.Expression,
+  receiver: EventReceiverProof,
+): boolean {
+  if (receiver.receiverClassification !== 'unproven') return false;
+  const root = receiverRootName(expression);
+  return Boolean(root && KNOWN_NON_CAP_EVENT_RECEIVERS.has(root))
+    || pipeReceiver(expression);
 }
 
 function eventEvidence(
@@ -154,6 +266,8 @@ function eventEvidence(
       ? 'cap_service_event_subscription' : 'cap_service_event_emit',
     receiverClassification: receiver.receiverClassification,
     receiverProof: receiver.receiverProof,
+    receiverUnresolvedReason: receiver.unresolvedReason,
+    receiverFallbackRefusedReason: receiver.fallbackRefusedReason,
     consideredBindingSites: receiver.consideredBindingSites,
     eventNameUnresolvedReason: state.unresolvedReason,
     eventNameConstantImportBinding: state.packageImportReference,
@@ -167,6 +281,16 @@ function eventEvidence(
         declarationEndOffset: state.constant.declarationEndOffset,
       },
     } : {}),
+    ...(state.foldedConstants ? {
+      eventNameTemplateFoldedConstants: state.foldedConstants.slice(0, 8)
+        .map((constant) => ({
+          sourceKind: constant.kind,
+          sourceFile: constant.sourceFile,
+          declarationStartOffset: constant.declarationStartOffset,
+          declarationEndOffset: constant.declarationEndOffset,
+        })),
+      eventNameTemplateFoldedConstantCount: state.foldedConstants.length,
+    } : {}),
     ...(state.resolved.status === 'static' ? {} : {
       eventNameStatus: state.resolved.status,
       eventNameSourceKind: state.resolved.sourceKind,
@@ -177,13 +301,12 @@ function eventEvidence(
 
 export function createEventCallAnalysisContext(
   source: ts.SourceFile,
-  compatibilityNames: Set<string>,
   importedConstant?: ImportedEventNameResolver,
   environmentReference?: EventEnvironmentReferenceResolver,
 ): EventCallAnalysisContext {
   return {
     source,
-    receivers: createEventReceiverIndex(source, compatibilityNames),
+    receivers: createEventReceiverIndex(source),
     constants: collectStringConstantLookups(source),
     importedConstant,
     environmentReference,
@@ -196,7 +319,10 @@ function eventSkeleton(
   resolver: EventEnvironmentReferenceResolver | undefined,
 ): EventSkeletonFact | undefined {
   const expression = node.arguments[0];
-  if (!expression || !ts.isTemplateExpression(expression)) return undefined;
+  if (!expression) return undefined;
+  if (!ts.isTemplateExpression(expression))
+    return eventName.includes('${')
+      ? deriveEventSkeleton(eventName) : undefined;
   const skeleton = deriveEventSkeleton(eventName);
   if (!skeleton || !resolver) return skeleton;
   return {
@@ -222,9 +348,11 @@ export function analyzeEventCall(
   const receiver = proveEventReceiver(
     expression.expression, node, context.receivers,
   );
+  if (receiver.unresolvedReason === 'event_receiver_not_cap_client'
+    || receiver.receiverProof === 'binding_not_found'
+    || knownNonCapReceiver(expression.expression, receiver))
+    return { status: 'excluded' };
   if (excludedEvent(method, receiver, state)) return { status: 'excluded' };
-  const unresolvedReason = receiver.unresolvedReason
-    ?? state.unresolvedReason;
   return {
     status: 'classified',
     fact: {
@@ -235,7 +363,7 @@ export function analyzeEventCall(
         node, state.eventName, context.environmentReference,
       ),
       confidence: eventConfidence(receiver, state.unresolvedReason),
-      unresolvedReason,
+      unresolvedReason: state.unresolvedReason,
     },
     evidence: eventEvidence(method, receiver, state),
   };