@saptools/service-flow 0.1.70 → 0.1.73

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

@@ -8,6 +8,10 @@ import {
   type TraversalScopeScheduler,
   type TraversalScopeState,
 } from './traversal-scope.js';
+import {
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export type EventSubscriberTransitionStatus =
   | 'resolved'
@@ -60,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;
@@ -96,7 +114,8 @@ export function planEventSubscriberTransitions(
 ): PlannedEventSubscriberTransition[] {
   return loadEventSubscriberTransitions(db, query).map((transition) => {
     const handler = transition.handler;
-    if (!handler) return plannedTransition(transition, 'not_resolved');
+    if (transition.status !== 'resolved' || !handler)
+      return plannedTransition(transition, 'not_resolved');
     if (depth >= maxDepth)
       return plannedTransition(transition, 'depth_limited');
     const state = scheduler.schedule({
@@ -166,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,
@@ -234,24 +257,72 @@ 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(
   row: Record<string, unknown>,
   query: EventSubscriberTransitionQuery,
 ): Record<string, unknown> | undefined {
+  const exact = exactPersistedEventRow(row, query);
+  if (exact) return exact;
   const variables = query.vars;
-  if (variables === undefined) return exactPersistedEventRow(row, query);
+  if (variables === undefined) return undefined;
   const evidence = parseEvidence(row.evidenceJson);
   const resolution = isRecord(evidence.eventTemplateResolution)
     ? evidence.eventTemplateResolution : {};
   if (typeof resolution.original !== 'string')
-    return exactPersistedEventRow(row, query);
+    return undefined;
   return runtimeMatchedEventRow(
     row, query, evidence, resolution.original, variables,
   );
@@ -272,7 +343,10 @@ function runtimeMatchedEventRow(
   template: string,
   variables: Record<string, string>,
 ): Record<string, unknown> | undefined {
-  const substitution = substituteVariables(template, variables);
+  const skeleton = parseEventSkeletonFact(evidence.eventSkeleton);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables),
+  );
   if (substitution.missing.length > 0
     || substitution.effective !== query.eventName) return undefined;
   const resolvedAssociation = evidence.associationStatus === 'resolved';
@@ -295,8 +369,7 @@ export function eventSubscriberMissingVariables(
   db: Db,
   query: EventSubscriberTransitionQuery,
 ): string[] {
-  if (query.vars === undefined) return [];
-  const variables = query.vars;
+  const variables = query.vars ?? {};
   const rows = db.prepare(`SELECT ge.from_id eventName,
     ge.evidence_json evidenceJson FROM graph_edges ge
     WHERE ge.workspace_id=? AND ge.generation=?
@@ -311,7 +384,10 @@ export function eventSubscriberMissingVariables(
     const template = typeof resolution.original === 'string'
       ? resolution.original : undefined;
     if (!template) return [];
-    const substitution = substituteVariables(template, variables);
+    const skeleton = parseEventSkeletonFact(evidence.eventSkeleton);
+    const substitution = substituteVariables(
+      template, eventTemplateVariables(skeleton, variables),
+    );
     if (substitution.missing.length === 0
       || matchRuntimeTemplate(
         substitution.effective, query.eventName,
@@ -382,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;
@@ -262,6 +255,8 @@ function runtimeDiagnosticTotals(
     const effective = parseObject(edge.evidence.effectiveResolution);
     if (!['dynamic', 'unresolved', 'ambiguous'].includes(String(effective.status ?? '')))
       continue;
+    for (const key of stringArray(edge.evidence.missingRuntimeVariables))
+      missing.add(key);
     const substitutions = edge.evidence.runtimeSubstitutions;
     if (!substitutions || typeof substitutions !== 'object' || Array.isArray(substitutions)) continue;
     for (const value of Object.values(substitutions as Record<string, RuntimeSubstitution>))
@@ -340,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,
@@ -648,6 +622,11 @@ function stringValue(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined;
 }
 
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
 function numeric(value: unknown): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 }

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,
@@ -20,7 +20,6 @@ import {
 import type { PlannedEventSubscriberTransition } from './event-subscriber-traversal.js';
 import {
   graphForCalls,
-  operationNode,
   symbolNode,
   type TraceGraphEdgeRow,
 } from './trace-graph-lookups.js';
@@ -51,6 +50,12 @@ import type { ImplementationHintOptions } from './trace-implementation-scope.js'
 import { processOperationTarget } from './trace-operation-execution.js';
 import { runtimeEventResolution, runtimeEventSubscriberPlans } from './event-runtime-resolution.js';
 import { planLocalCallExpansion } from './local-call-expansion.js';
+import {
+  eventShapeRuntimeEvidence,
+  outboundTraceEdgeType,
+  outboundTraceTargetNode,
+  visibleEventShapeRows,
+} from './event-shape-candidate-trace.js';
 
 export interface CallRow extends Record<string, unknown> {
   id: number;
@@ -90,16 +95,6 @@ export interface TraceExecutionRuntime {
   recorder: TraceEdgeRecorder;
 }
 
-function traceEdgeType(call: CallRow, row: TraceGraphRow): string {
-  if (row.to_kind === 'operation'
-    && row.edge_type === 'REMOTE_CALL_RESOLVES_TO_OPERATION')
-    return 'remote_action';
-  if (row.to_kind === 'operation'
-    && row.edge_type === 'LOCAL_CALL_RESOLVES_TO_OPERATION')
-    return 'local_service_call';
-  return String(call.call_type);
-}
-
 function includeCall(type: string, options: TraceOptions): boolean {
   if (!options.includeDb && type === 'local_db_query') return false;
   if (!options.includeExternal && type === 'external_http') return false;
@@ -339,7 +334,9 @@ function processOutboundCall(
   const contextual = contextualRuntimeResolution(
     runtime.db, call, bindings.get(receiver), call.workspaceId, persistedRows,
   );
-  const rows = contextual.row ? [contextual.row] : persistedRows;
+  const rows = contextual.row
+    ? [contextual.row]
+    : visibleEventShapeRows(persistedRows, runtime.options);
   for (const row of rows)
     processOutboundRow(runtime, current, call, { ...row }, contextual);
 }
@@ -385,16 +382,23 @@ function recordEffectiveOutbound(
 ): EffectiveOutbound {
   const persisted = parseTraceEvidence(row.evidence_json);
   const raw = baseTraceEvidence(row, call, persisted, contextual.evidence);
-  const effective = runtimeEventResolution(row, raw, runtime.options.vars)
+  const resolved = runtimeEventResolution(row, raw, runtime.options.vars)
     ?? runtimeResolution(runtime.db, row, raw, {
       vars: runtime.options.vars,
       dynamicMode: runtime.options.dynamicMode ?? 'strict',
       maxDynamicCandidates: runtime.options.maxDynamicCandidates,
     }, call.workspaceId, contextual.state);
+  const effective = {
+    ...resolved,
+    evidence: eventShapeRuntimeEvidence(
+      runtime.db, call.workspaceId, call.id, call.call_type,
+      resolved.evidence, runtime.options.vars,
+    ),
+  };
   const target = `${effective.row.to_kind}:${effective.row.to_id}`;
-  const operation = effective.row.to_kind === 'operation'
-    ? operationNode(runtime.db, effective.row.to_id) : undefined;
-  runtime.nodes.set(target, operation ?? targetNode(target, effective.row));
+  runtime.nodes.set(
+    target, outboundTraceTargetNode(runtime.db, target, effective.row),
+  );
   const to = edgeTarget(effective.row, effective.evidence);
   const edge = outboundTraceEdge(
     current.depth, call, effective.row, to,
@@ -418,18 +422,6 @@ function recordEffectiveOutbound(
   };
 }
 
-function targetNode(
-  id: string,
-  row: TraceGraphRow,
-): Record<string, unknown> {
-  return {
-    id,
-    kind: row.to_kind,
-    label: row.to_kind === 'db_entity'
-      ? `Entity: ${row.to_id || 'unknown'}` : row.to_id,
-  };
-}
-
 function outboundTraceEdge(
   depth: number,
   call: CallRow,
@@ -440,7 +432,7 @@ function outboundTraceEdge(
 ): TraceEdge {
   return {
     step: depth,
-    type: traceEdgeType(call, row),
+    type: outboundTraceEdgeType(call, row),
     from: `${call.repoName}:${call.source_file}:${call.source_line}`,
     to,
     evidence,

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { EventSkeletonFact } from './utils/event-skeleton.js';
+
 export type RepoKind =
   | 'cap-service'
   | 'cap-db-model'
@@ -36,6 +38,7 @@ export type EdgeType =
   | 'HANDLER_EMITS_EVENT'
   | 'EVENT_CONSUMED_BY_HANDLER'
   | 'EVENT_SUBSCRIPTION_HANDLED_BY'
+  | 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
   | 'REPO_IMPORTS_HELPER_PACKAGE'
   | 'HELPER_PACKAGE_PROVIDES_HANDLER'
   | 'DYNAMIC_EDGE_CANDIDATE'
@@ -229,6 +232,7 @@ export interface OutboundCallFact {
   operationPathExpr?: string;
   queryEntity?: string;
   eventNameExpr?: string;
+  eventSkeleton?: EventSkeletonFact;
   payloadSummary?: string;
   sourceFile: string;
   sourceLine: number;
@@ -272,9 +276,23 @@ export interface SymbolCallFact {
 }
 export interface GeneratedConstantFact {
   name: string;
-  value: string;
+  value?: string;
   sourceFile: string;
   sourceLine: number;
+  containerName?: string;
+  memberName?: string;
+  constantKind: 'const_identifier' | 'enum_member' | 'const_object_property';
+  exported: boolean;
+  stable: boolean;
+  resolutionStatus: 'resolved' | 'refused';
+  unresolvedReason?: 'event_name_constant_member_not_string'
+    | 'event_name_constant_container_mutable'
+    | 'event_name_constant_container_unsafe_reference'
+    | 'event_name_constant_container_unsupported_shape';
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  valueStartOffset: number;
+  valueEndOffset: number;
 }
 export interface TraceStart {
   repo?: string;

package/src/utils/event-skeleton.ts

@@ -0,0 +1,207 @@
+import { sha256Text } from './hashing.js';
+import { scanPlaceholderStructure } from './placeholders.js';
+import type {
+  EventEnvironmentReference,
+} from '../parsers/event-environment-reference.js';
+
+export const EVENT_SKELETON_SCHEMA = 'service-flow/event-skeleton@1';
+export const EVENT_SKELETON_LITERAL_THRESHOLD = 8;
+export const EVENT_SKELETON_TEXT_LIMIT = 512;
+
+export interface EventSkeletonFact {
+  schema: typeof EVENT_SKELETON_SCHEMA;
+  status: 'complete' | 'malformed' | 'too_large';
+  signature: string | null;
+  literalSpans: string[];
+  holeCount: number;
+  sourceKeys: string[];
+  canonicalKeys: string[];
+  candidateEligible: boolean;
+  environmentBindings: EventEnvironmentReference[];
+  reason?: string;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function parseJson(value: unknown): unknown {
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function stringArray(value: unknown): string[] | undefined {
+  return Array.isArray(value) && value.every((item) =>
+    typeof item === 'string')
+    ? value as string[] : undefined;
+}
+
+function canonicalKey(signature: string, index: number): string {
+  return `event.${signature.slice(0, 16)}.hole${index + 1}`;
+}
+
+function skeletonSignature(
+  literalSpans: readonly string[],
+  holeCount: number,
+): string {
+  return sha256Text(JSON.stringify({ literalSpans, holeCount }));
+}
+
+function completeSkeleton(
+  template: string,
+): EventSkeletonFact {
+  const scan = scanPlaceholderStructure(template);
+  if (scan.status === 'malformed') return {
+    schema: EVENT_SKELETON_SCHEMA,
+    status: 'malformed',
+    signature: null,
+    literalSpans: [],
+    holeCount: 0,
+    sourceKeys: [],
+    canonicalKeys: [],
+    candidateEligible: false,
+    environmentBindings: [],
+    reason: scan.reason,
+  };
+  const literals: string[] = [];
+  let cursor = 0;
+  for (const span of scan.spans) {
+    literals.push(template.slice(cursor, span.start));
+    cursor = span.end;
+  }
+  literals.push(template.slice(cursor));
+  const signature = skeletonSignature(literals, scan.spans.length);
+  return {
+    schema: EVENT_SKELETON_SCHEMA,
+    status: 'complete',
+    signature,
+    literalSpans: literals,
+    holeCount: scan.spans.length,
+    sourceKeys: scan.spans.map((span) => span.key.trim()),
+    canonicalKeys: scan.spans.map((_, index) =>
+      canonicalKey(signature, index)),
+    candidateEligible: scan.spans.length > 0
+      && literals.some((literal) =>
+        literal.length >= EVENT_SKELETON_LITERAL_THRESHOLD),
+    environmentBindings: [],
+  };
+}
+
+function validCompleteSkeleton(
+  item: Record<string, unknown>,
+  literals: string[],
+  sourceKeys: string[],
+  canonicalKeys: string[],
+): boolean {
+  const holes = item.holeCount;
+  const signature = item.signature;
+  if (!Number.isInteger(holes) || Number(holes) < 1
+    || typeof signature !== 'string'
+    || !/^[a-f0-9]{64}$/.test(signature)) return false;
+  const count = Number(holes);
+  return literals.length === count + 1
+    && sourceKeys.length === count
+    && canonicalKeys.length === count
+    && sourceKeys.every((key) => key.length > 0 && key === key.trim())
+    && canonicalKeys.every((key, index) =>
+      key === canonicalKey(signature, index))
+    && new Set(canonicalKeys).size === canonicalKeys.length
+    && signature === skeletonSignature(literals, count)
+    && item.candidateEligible === literals.some((literal) =>
+      literal.length >= EVENT_SKELETON_LITERAL_THRESHOLD)
+    && item.reason === undefined;
+}
+
+function validClosedSkeleton(
+  item: Record<string, unknown>,
+  literals: string[],
+  sourceKeys: string[],
+  canonicalKeys: string[],
+): boolean {
+  const reason = item.reason;
+  if (item.signature !== null || item.holeCount !== 0
+    || item.candidateEligible !== false
+    || literals.length > 0 || sourceKeys.length > 0
+    || canonicalKeys.length > 0
+    || !Array.isArray(item.environmentBindings)
+    || item.environmentBindings.length > 0) return false;
+  if (item.status === 'too_large')
+    return reason === 'event_skeleton_text_limit_exceeded';
+  return item.status === 'malformed'
+    && typeof reason === 'string' && reason.length > 0;
+}
+
+export function parseEventSkeletonFact(
+  value: unknown,
+): EventSkeletonFact | undefined {
+  const item = record(parseJson(value));
+  if (!item || item.schema !== EVENT_SKELETON_SCHEMA
+    || !['complete', 'malformed', 'too_large'].includes(String(item.status))
+    || !Array.isArray(item.environmentBindings)) return undefined;
+  const literals = stringArray(item.literalSpans);
+  const sourceKeys = stringArray(item.sourceKeys);
+  const canonicalKeys = stringArray(item.canonicalKeys);
+  if (!literals || !sourceKeys || !canonicalKeys) return undefined;
+  const valid = item.status === 'complete'
+    ? validCompleteSkeleton(item, literals, sourceKeys, canonicalKeys)
+    : validClosedSkeleton(item, literals, sourceKeys, canonicalKeys);
+  return valid ? item as unknown as EventSkeletonFact : undefined;
+}
+
+export function deriveEventSkeleton(
+  template: string | undefined,
+): EventSkeletonFact | undefined {
+  if (!template || !template.includes('${')) return undefined;
+  if (template.length <= EVENT_SKELETON_TEXT_LIMIT)
+    return completeSkeleton(template);
+  return {
+    schema: EVENT_SKELETON_SCHEMA,
+    status: 'too_large',
+    signature: null,
+    literalSpans: [],
+    holeCount: 0,
+    sourceKeys: [],
+    canonicalKeys: [],
+    candidateEligible: false,
+    environmentBindings: [],
+    reason: 'event_skeleton_text_limit_exceeded',
+  };
+}
+
+export function eventTemplateVariables(
+  skeleton: EventSkeletonFact | undefined,
+  variables: Record<string, string>,
+): Record<string, string> {
+  if (!skeleton || skeleton.status !== 'complete') return variables;
+  const expanded = { ...variables };
+  for (let index = 0; index < skeleton.sourceKeys.length; index += 1) {
+    const sourceKey = skeleton.sourceKeys[index];
+    const canonicalKeyValue = skeleton.canonicalKeys[index];
+    if (!sourceKey || !canonicalKeyValue
+      || Object.hasOwn(expanded, sourceKey)
+      || !Object.hasOwn(expanded, canonicalKeyValue)) continue;
+    expanded[sourceKey] = expanded[canonicalKeyValue] ?? '';
+  }
+  return expanded;
+}
+
+export function eventMissingVariableNames(
+  skeleton: EventSkeletonFact | undefined,
+  missingSourceKeys: readonly string[],
+): string[] {
+  const names = new Set(missingSourceKeys);
+  if (skeleton?.status === 'complete')
+    for (let index = 0; index < skeleton.sourceKeys.length; index += 1) {
+      const sourceKey = skeleton.sourceKeys[index];
+      const canonical = skeleton.canonicalKeys[index];
+      if (sourceKey && canonical && names.has(sourceKey))
+        names.add(canonical);
+    }
+  return [...names].sort((left, right) =>
+    left < right ? -1 : left > right ? 1 : 0);
+}

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.69-facts.1';
+export const ANALYZER_VERSION = '0.1.73-facts.1';