@saptools/service-flow 0.1.70 → 0.1.73

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

@@ -0,0 +1,408 @@
+import ts from 'typescript';
+import { stableLocalValueReference } from './stable-local-value.js';
+import { lexicalIdentifierDeclaration } from './symbol-import-bindings.js';
+
+export type StaticStringConstantKind =
+  | 'const_identifier'
+  | 'enum_member'
+  | 'const_object_property';
+
+export interface StaticStringConstant {
+  key: string;
+  value: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  valueStartOffset: number;
+  valueEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+}
+
+export interface StaticStringRefusal {
+  key: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+  reason: 'event_name_constant_member_not_string'
+    | 'event_name_constant_container_mutable'
+    | 'event_name_constant_container_unsafe_reference'
+    | 'event_name_constant_container_unsupported_shape';
+}
+
+export interface StringConstantLookups {
+  identifiers: Map<string, StaticStringConstant>;
+  enumMembers: Map<string, StaticStringConstant>;
+  objectProperties: Map<string, StaticStringConstant>;
+  refusedMembers: Map<string, StaticStringRefusal>;
+}
+
+export type StaticStringLookupResult =
+  | { status: 'resolved'; constant: StaticStringConstant }
+  | { status: 'refused'; reason: string }
+  | { status: 'not_found' };
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}
+
+function stringValue(
+  expression: ts.Expression | undefined,
+): { value: string; node: ts.Expression } | undefined {
+  if (!expression) return undefined;
+  const value = unwrapExpression(expression);
+  return ts.isStringLiteralLike(value)
+    ? { value: value.text, node: value } : undefined;
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name) ? name.text : undefined;
+}
+
+function exportedNames(source: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of source.statements) {
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier
+      || !statement.exportClause
+      || !ts.isNamedExports(statement.exportClause)) continue;
+    for (const element of statement.exportClause.elements)
+      names.add(element.propertyName?.text ?? element.name.text);
+  }
+  return names;
+}
+
+function hasExportModifier(node: ts.Node): boolean {
+  return ts.canHaveModifiers(node)
+    && Boolean(ts.getModifiers(node)?.some((modifier) =>
+      modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
+function staticFact(
+  source: ts.SourceFile,
+  key: string,
+  value: { value: string; node: ts.Expression },
+  declaration: ts.Node,
+  fields: Pick<StaticStringConstant, 'kind' | 'exported' | 'stable'>
+    & Partial<Pick<StaticStringConstant, 'containerName' | 'memberName'>>,
+): StaticStringConstant {
+  return {
+    key,
+    value: value.value,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    valueStartOffset: value.node.getStart(source),
+    valueEndOffset: value.node.getEnd(),
+    ...fields,
+  };
+}
+
+function refusalFact(
+  source: ts.SourceFile,
+  key: string,
+  declaration: ts.Node,
+  fields: Pick<StaticStringRefusal,
+    'kind' | 'exported' | 'stable' | 'reason'>
+    & Partial<Pick<StaticStringRefusal, 'containerName' | 'memberName'>>,
+): StaticStringRefusal {
+  return {
+    key,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    ...fields,
+  };
+}
+
+function collectEnum(
+  source: ts.SourceFile,
+  statement: ts.EnumDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  const stable = stableLocalValueReference(source, statement.name);
+  const exported = hasExportModifier(statement)
+    || exports.has(statement.name.text);
+  for (const member of statement.members) {
+    const memberName = propertyName(member.name);
+    if (!memberName) continue;
+    const key = `${statement.name.text}.${memberName}`;
+    const value = stringValue(member.initializer);
+    if (!stable) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_container_unsafe_reference',
+      },
+    ));
+    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_member_not_string',
+      },
+    ));
+    else lookups.enumMembers.set(key, staticFact(
+      source, key, value, member, {
+        kind: 'enum_member',
+        containerName: statement.name.text,
+        memberName,
+        exported,
+        stable,
+      },
+    ));
+  }
+}
+
+function objectLiteral(
+  expression: ts.Expression,
+): ts.ObjectLiteralExpression | undefined {
+  const value = unwrapExpression(expression);
+  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,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const object = objectLiteral(declaration.initializer);
+  if (!object) return;
+  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))
+      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, 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(
+  source: ts.SourceFile,
+  statement: ts.VariableStatement,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const value = stringValue(declaration.initializer);
+  if (!value) return;
+  const key = declaration.name.text;
+  lookups.identifiers.set(key, staticFact(
+    source, key, value, declaration, {
+      kind: 'const_identifier',
+      exported: hasExportModifier(statement) || exports.has(key),
+      stable: true,
+    },
+  ));
+}
+
+export function collectStringConstantLookups(
+  source: ts.SourceFile,
+): StringConstantLookups {
+  const lookups: StringConstantLookups = {
+    identifiers: new Map(),
+    enumMembers: new Map(),
+    objectProperties: new Map(),
+    refusedMembers: new Map(),
+  };
+  const exports = exportedNames(source);
+  for (const statement of source.statements) {
+    if (ts.isEnumDeclaration(statement))
+      collectEnum(source, statement, exports, lookups);
+    if (!ts.isVariableStatement(statement)
+      || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      collectIdentifier(source, statement, declaration, exports, lookups);
+      collectObject(source, statement, declaration, exports, lookups);
+    }
+  }
+  return lookups;
+}
+
+export function resolveStringConstant(
+  expression: ts.Expression,
+  lookups: StringConstantLookups,
+): StaticStringLookupResult {
+  const value = unwrapExpression(expression);
+  if (ts.isIdentifier(value)) {
+    const constant = lookups.identifiers.get(value.text);
+    return constant && constantReferenceMatches(value, constant)
+      ? { status: 'resolved', constant } : { status: 'not_found' };
+  }
+  if (ts.isElementAccessExpression(value)
+    && ts.isIdentifier(value.expression)) {
+    const prefix = `${value.expression.text}.`;
+    const known = [
+      ...lookups.enumMembers.keys(),
+      ...lookups.objectProperties.keys(),
+      ...lookups.refusedMembers.keys(),
+    ].some((key) => key.startsWith(prefix));
+    return known && constantContainerMatches(
+      value.expression, lookups, prefix,
+    ) ? {
+      status: 'refused',
+      reason: 'event_name_constant_container_ambiguous',
+    } : { status: 'not_found' };
+  }
+  if (!ts.isPropertyAccessExpression(value)
+    || value.questionDotToken || !ts.isIdentifier(value.expression))
+    return { status: 'not_found' };
+  const key = `${value.expression.text}.${value.name.text}`;
+  const constant = lookups.enumMembers.get(key)
+    ?? lookups.objectProperties.get(key);
+  if (constant && constantReferenceMatches(value.expression, constant))
+    return { status: 'resolved', constant };
+  const reason = lookups.refusedMembers.get(key);
+  return reason && refusalReferenceMatches(value.expression, reason)
+    ? { status: 'refused', reason: reason.reason }
+    : constant || reason ? {
+        status: 'refused',
+        reason: 'event_name_constant_container_ambiguous',
+      } : { status: 'not_found' };
+}
+
+function declarationContains(
+  identifier: ts.Identifier,
+  startOffset: number,
+  endOffset: number,
+): boolean {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration) return false;
+  const owner = declaration.parent;
+  return owner.getSourceFile() === identifier.getSourceFile()
+    && owner.getStart(identifier.getSourceFile()) <= startOffset
+    && owner.getEnd() >= endOffset;
+}
+
+function constantReferenceMatches(
+  identifier: ts.Identifier,
+  constant: StaticStringConstant,
+): boolean {
+  return declarationContains(
+    identifier,
+    constant.declarationStartOffset,
+    constant.declarationEndOffset,
+  );
+}
+
+function refusalReferenceMatches(
+  identifier: ts.Identifier,
+  refusal: StaticStringRefusal,
+): boolean {
+  return declarationContains(
+    identifier,
+    refusal.declarationStartOffset,
+    refusal.declarationEndOffset,
+  );
+}
+
+function constantContainerMatches(
+  identifier: ts.Identifier,
+  lookups: StringConstantLookups,
+  prefix: string,
+): boolean {
+  const constants = [
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values(),
+  ].filter((item) => item.key.startsWith(prefix));
+  const refusals = [...lookups.refusedMembers.values()]
+    .filter((item) => item.key.startsWith(prefix));
+  return [...constants, ...refusals].some((item) =>
+    declarationContains(
+      identifier, item.declarationStartOffset, item.declarationEndOffset,
+    ));
+}

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-runtime-resolution.ts

@@ -14,6 +14,12 @@ import type {
   TraversalScopeState,
 } from './traversal-scope.js';
 import type { TraceGraphRow } from './evidence.js';
+import {
+  eventMissingVariableNames,
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+  type EventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export interface EventRuntimeResolution {
   row: TraceGraphRow;
@@ -37,6 +43,12 @@ function eventTemplate(evidence: Record<string, unknown>): string | undefined {
     ? resolution.original : undefined;
 }
 
+function eventSkeleton(
+  evidence: Record<string, unknown>,
+): EventSkeletonFact | undefined {
+  return parseEventSkeletonFact(evidence.eventSkeleton);
+}
+
 function missingReason(substitution: RuntimeSubstitution): string {
   return `Dynamic target requires runtime variable overrides: ${
     substitution.missing.join(', ')}`;
@@ -88,6 +100,10 @@ function eventEvidence(
     unresolvedReason,
     edgeType: row.edge_type,
   };
+  const skeleton = eventSkeleton(evidence);
+  const missing = eventMissingVariableNames(
+    skeleton, substitution.missing,
+  );
   return {
     ...evidence,
     runtimeSubstitutions: { eventName: substitution },
@@ -96,8 +112,10 @@ function eventEvidence(
     ),
     ...(substitution.supplied.length > 0
       ? { runtimeVariablesApplied: true } : {}),
-    ...(substitution.missing.length > 0
-      ? { missingRuntimeVariables: substitution.missing } : {}),
+    ...(missing.length > 0 ? {
+      missingRuntimeVariables: missing,
+      missingVariableCount: missing.length,
+    } : {}),
     effectiveResolution,
     linker: {
       status: effectiveResolution.status,
@@ -137,7 +155,10 @@ export function runtimeEventResolution(
   const template = eventTemplate(evidence);
   if (!template || row.to_kind === 'event' && variables === undefined)
     return undefined;
-  const substitution = substituteVariables(template, variables ?? {});
+  const skeleton = eventSkeleton(evidence);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables ?? {}),
+  );
   const effectiveRow = runtimeEventRow(
     row, evidence, substitution, template,
   );

package/src/trace/event-shape-candidate-trace.ts

@@ -0,0 +1,172 @@
+import type { Db } from '../db/connection.js';
+import type { TraceOptions } from '../types.js';
+import {
+  operationNode,
+  symbolNode,
+  type TraceGraphEdgeRow,
+} from './trace-graph-lookups.js';
+import type { TraceGraphRow } from './evidence.js';
+import {
+  eventMissingVariableNames,
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+} from '../utils/event-skeleton.js';
+
+const defaultEventShapeCandidateCap = 5;
+const maximumEventShapeCandidateCap = 50;
+
+function candidateCap(options: TraceOptions): number {
+  const value = options.maxDynamicCandidates
+    ?? defaultEventShapeCandidateCap;
+  if (!Number.isSafeInteger(value) || value < 1)
+    return defaultEventShapeCandidateCap;
+  return Math.min(value, maximumEventShapeCandidateCap);
+}
+
+function withCandidateCounts(
+  row: TraceGraphEdgeRow,
+  total: number,
+  shown: number,
+): TraceGraphEdgeRow {
+  let evidence: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(row.evidence_json);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+      evidence = parsed as Record<string, unknown>;
+  } catch {
+    evidence = {};
+  }
+  return {
+    ...row,
+    evidence_json: JSON.stringify({
+      ...evidence,
+      eventShapeCandidateCount: total,
+      shownEventShapeCandidateCount: shown,
+      omittedEventShapeCandidateCount: Math.max(0, total - shown),
+    }),
+  };
+}
+
+export function visibleEventShapeRows(
+  rows: readonly TraceGraphEdgeRow[],
+  options: TraceOptions,
+): TraceGraphEdgeRow[] {
+  const regular = rows.filter((row) =>
+    row.edge_type !== 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER');
+  if ((options.dynamicMode ?? 'strict') !== 'candidates') return regular;
+  const candidates = rows.filter((row) =>
+    row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER');
+  const shown = candidates.slice(0, candidateCap(options));
+  return [
+    ...regular,
+    ...shown.map((row) =>
+      withCandidateCounts(row, candidates.length, shown.length)),
+  ];
+}
+
+export function outboundTraceEdgeType(
+  call: { call_type: string },
+  row: { edge_type: string; to_kind: string },
+): string {
+  if (row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER')
+    return 'event_shape_candidate_subscriber';
+  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 call.call_type;
+}
+
+export function outboundTraceTargetNode(
+  db: Db,
+  id: string,
+  row: TraceGraphRow,
+): Record<string, unknown> {
+  const operation = row.to_kind === 'operation'
+    ? operationNode(db, row.to_id) : undefined;
+  const candidate = row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
+    ? symbolNode(db, Number(row.to_id)) : undefined;
+  return operation ?? candidate ?? {
+    id,
+    kind: row.to_kind,
+    label: row.to_kind === 'db_entity'
+      ? `Entity: ${row.to_id || 'unknown'}` : row.to_id,
+  };
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+function subscriberSkeletons(
+  db: Db,
+  workspaceId: number,
+  publishCallId: number,
+): unknown[] {
+  return db.prepare(`SELECT subscription.event_skeleton_json skeleton
+    FROM outbound_calls publication
+    JOIN repositories publication_repo ON publication_repo.id=publication.repo_id
+    JOIN outbound_calls subscription
+      ON subscription.call_type='async_subscribe'
+      AND subscription.event_skeleton_signature
+        =publication.event_skeleton_signature
+    JOIN repositories subscription_repo
+      ON subscription_repo.id=subscription.repo_id
+      AND subscription_repo.workspace_id=publication_repo.workspace_id
+    WHERE publication.id=? AND publication_repo.workspace_id=?
+      AND publication.event_skeleton_signature IS NOT NULL
+    ORDER BY subscription_repo.name COLLATE BINARY,
+      subscription.repo_id,subscription.source_file COLLATE BINARY,
+      subscription.call_site_start_offset,subscription.id`).all(
+    publishCallId, workspaceId,
+  ).map((row) => row.skeleton);
+}
+
+export function eventShapeMissingVariableEvidence(
+  db: Db,
+  workspaceId: number,
+  publishCallId: number,
+  evidence: Record<string, unknown>,
+  variables: Record<string, string> | undefined,
+): Record<string, unknown> {
+  const current = stringArray(evidence.missingRuntimeVariables);
+  if (current.length === 0) return evidence;
+  const names = new Set(current);
+  let matchingSubscriptions = 0;
+  for (const value of subscriberSkeletons(db, workspaceId, publishCallId)) {
+    const skeleton = parseEventSkeletonFact(value);
+    if (!skeleton?.candidateEligible) continue;
+    matchingSubscriptions += 1;
+    const expanded = eventTemplateVariables(skeleton, variables ?? {});
+    const missing = skeleton.sourceKeys.filter((key) =>
+      !Object.hasOwn(expanded, key));
+    for (const name of eventMissingVariableNames(skeleton, missing))
+      names.add(name);
+  }
+  const missing = [...names].sort((left, right) =>
+    left < right ? -1 : left > right ? 1 : 0);
+  return {
+    ...evidence,
+    missingRuntimeVariables: missing,
+    missingVariableCount: missing.length,
+    eventShapeMatchingSubscriptionCount: matchingSubscriptions,
+  };
+}
+
+export function eventShapeRuntimeEvidence(
+  db: Db,
+  workspaceId: number,
+  callId: number,
+  callType: string,
+  evidence: Record<string, unknown>,
+  variables: Record<string, string> | undefined,
+): Record<string, unknown> {
+  return callType === 'async_emit'
+    ? eventShapeMissingVariableEvidence(
+        db, workspaceId, callId, evidence, variables,
+      )
+    : evidence;
+}