@saptools/service-flow 0.1.69 → 0.1.72

package/src/linker/cross-repo-linker.ts

@@ -1,10 +1,13 @@
 import type { Db } from '../db/connection.js';
 import { linkHelperPackages } from './helper-package-linker.js';
-import { linkImplementations as linkCanonicalImplementations } from './000-implementation-candidates.js';
-import { linkPackageImportSymbolCalls } from './003-package-import-symbol-resolver.js';
-import { linkEventSubscriptionHandlers } from './004-event-subscription-handler-linker.js';
-import { insertCallEdge } from './007-call-edge-insertion.js';
-import { assertWorkspaceLinkable } from '../db/001-fact-lifecycle.js';
+import { linkImplementations as linkCanonicalImplementations } from './implementation-candidates.js';
+import { linkPackageImportSymbolCalls } from './package-import-symbol-resolver.js';
+import { linkEventSubscriptionHandlers } from './event-subscription-handler-linker.js';
+import { insertCallEdge } from './call-edge-insertion.js';
+import { linkEventShapeCandidates } from './event-shape-candidate-linker.js';
+import { assertWorkspaceLinkable } from '../db/fact-lifecycle.js';
+import { linkPackageEventConstants } from
+  './package-event-constant-resolver.js';
 export interface LinkWorkspaceResult {
   edgeCount: number;
   unresolvedCount: number;
@@ -23,11 +26,13 @@ export interface LinkWorkspaceResult {
   subscriptionHandlerAmbiguousCount: number;
   subscriptionHandlerUnresolvedCount: number;
   subscriptionHandlerMissingAssociationCount: number;
+  eventShapeCandidateCount: number;
 }
 export function linkWorkspace(db: Db, workspaceId: number, vars: Record<string, string> = {}): LinkWorkspaceResult {
   return db.transaction(() => {
     assertWorkspaceLinkable(db, workspaceId);
     linkPackageImportSymbolCalls(db, workspaceId);
+    linkPackageEventConstants(db, workspaceId);
     assertWorkspaceLinkable(db, workspaceId, 'terminal');
     const generation = nextGraphGeneration(db, workspaceId);
     db.prepare('DELETE FROM graph_edges WHERE workspace_id=?').run(workspaceId);
@@ -35,10 +40,13 @@ export function linkWorkspace(db: Db, workspaceId: number, vars: Record<string,
     const subscriptions = linkEventSubscriptionHandlers(
       db, workspaceId, generation, vars,
     );
+    const eventShapes = linkEventShapeCandidates(
+      db, workspaceId, generation,
+    );
     const impl = linkCanonicalImplementations(db, workspaceId, generation);
     const callSummary = linkCalls(db, workspaceId, vars, generation);
     db.prepare("UPDATE repositories SET graph_generation=?, graph_stale_reason=NULL, graph_stale_at=NULL WHERE workspace_id=?").run(generation, workspaceId);
-    return { ...callSummary, edgeCount: deps.edgeCount + callSummary.edgeCount + impl.edgeCount + subscriptions.edgeCount, dependencyResolvedCount: deps.resolvedCount, dependencyAmbiguousCount: deps.ambiguousCount, implementationResolvedCount: impl.resolvedCount, implementationAmbiguousCount: impl.ambiguousCount, implementationUnresolvedCount: impl.unresolvedCount, subscriptionHandlerResolvedCount: subscriptions.resolvedCount, subscriptionHandlerAmbiguousCount: subscriptions.ambiguousCount, subscriptionHandlerUnresolvedCount: subscriptions.unresolvedCount, subscriptionHandlerMissingAssociationCount: subscriptions.missingAssociationCount };
+    return { ...callSummary, edgeCount: deps.edgeCount + callSummary.edgeCount + impl.edgeCount + subscriptions.edgeCount + eventShapes.edgeCount, dependencyResolvedCount: deps.resolvedCount, dependencyAmbiguousCount: deps.ambiguousCount, implementationResolvedCount: impl.resolvedCount, implementationAmbiguousCount: impl.ambiguousCount, implementationUnresolvedCount: impl.unresolvedCount, subscriptionHandlerResolvedCount: subscriptions.resolvedCount, subscriptionHandlerAmbiguousCount: subscriptions.ambiguousCount, subscriptionHandlerUnresolvedCount: subscriptions.unresolvedCount, subscriptionHandlerMissingAssociationCount: subscriptions.missingAssociationCount, eventShapeCandidateCount: eventShapes.edgeCount };
   });
 }
 function nextGraphGeneration(db: Db, workspaceId: number): number {
@@ -54,7 +62,8 @@ type CallLinkSummary = Omit<LinkWorkspaceResult,
   | 'subscriptionHandlerResolvedCount'
   | 'subscriptionHandlerAmbiguousCount'
   | 'subscriptionHandlerUnresolvedCount'
-  | 'subscriptionHandlerMissingAssociationCount'>;
+  | 'subscriptionHandlerMissingAssociationCount'
+  | 'eventShapeCandidateCount'>;
 
 function linkCalls(db: Db, workspaceId: number, vars: Record<string, string>, generation: number): CallLinkSummary {
   let edgeCount = 0;
@@ -65,7 +74,20 @@ function linkCalls(db: Db, workspaceId: number, vars: Record<string, string>, ge
   let ambiguousCount = 0;
   let dynamicCount = 0;
   let terminalCount = 0;
-  const calls = db.prepare(`SELECT c.*,r.name repoName,b.id selectedBindingId,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.source_file bindingSourceFile,b.source_line bindingSourceLine,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`).all(workspaceId) as Array<Record<string, unknown>>;
+  const calls = db.prepare(`SELECT c.*,r.name repoName,
+    r.environment_declarations_json environmentDeclarationsJson,
+    b.id selectedBindingId,b.alias,b.alias_expr aliasExpr,
+    b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,
+    b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,
+    b.source_file bindingSourceFile,b.source_line bindingSourceLine,
+    b.helper_chain_json helperChainJson,req.service_path requireServicePath,
+    req.destination requireDestination
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    LEFT JOIN service_bindings b ON b.id=c.service_binding_id
+    LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias
+    WHERE r.workspace_id=?`).all(
+    workspaceId,
+  ) as Array<Record<string, unknown>>;
   for (const call of calls) {
     const result = insertCallEdge(db, workspaceId, call, vars, generation);
     edgeCount += 1;

package/src/linker/dynamic-edge-resolver.ts

@@ -1,4 +1,4 @@
-import { extractPlaceholderKeys, scanPlaceholders } from '../utils/001-placeholders.js';
+import { extractPlaceholderKeys, scanPlaceholders } from '../utils/placeholders.js';
 
 export interface RuntimeSubstitution {
   original?: string;

package/src/linker/event-environment-link.ts

@@ -0,0 +1,211 @@
+import type { Db } from '../db/connection.js';
+import {
+  applyEventEnvironmentTransforms,
+  type EventEnvironmentReference,
+} from '../parsers/event-environment-reference.js';
+import {
+  parseEnvironmentDeclarationsFact,
+  type EnvironmentDeclarationsFact,
+} from '../parsers/environment-declarations.js';
+import {
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+} from '../utils/event-skeleton.js';
+
+export interface EventEnvironmentResolution {
+  status: 'resolved' | 'ambiguous' | 'unresolved' | 'not_applicable';
+  variables: Record<string, string>;
+  reason?: string;
+  provenance: Array<Record<string, unknown>>;
+}
+
+export interface SubscriptionEnvironmentTarget {
+  consumerRepoId?: number;
+  consumerRepoName?: string;
+  resolution: EventEnvironmentResolution;
+  collisionCount: number;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function parsedJson(value: unknown): unknown {
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function bindingEnvironmentValues(
+  binding: EventEnvironmentReference,
+  fact: EnvironmentDeclarationsFact,
+): string[] {
+  if (!binding.environmentKey) return [];
+  return [...new Set(fact.declarations
+    .filter((item) => item.key === binding.environmentKey)
+    .map((item) => item.value))];
+}
+
+function bindingResolution(
+  binding: EventEnvironmentReference,
+  fact: EnvironmentDeclarationsFact,
+): { value?: string; reason?: string; ambiguous?: boolean } {
+  if (binding.status === 'refused')
+    return { reason: binding.reason ?? 'event_environment_reference_refused' };
+  if (fact.status === 'incomplete') return {
+    reason: 'event_environment_declarations_incomplete',
+  };
+  const values = bindingEnvironmentValues(binding, fact);
+  if (fact.status === 'ambiguous' || values.length > 1) return {
+    reason: 'event_environment_declaration_ambiguous', ambiguous: true,
+  };
+  const value = values[0];
+  if (value === undefined)
+    return { reason: 'event_environment_declaration_missing' };
+  return {
+    value: applyEventEnvironmentTransforms(value, binding.transforms),
+  };
+}
+
+function provenance(
+  binding: EventEnvironmentReference,
+  fact: EnvironmentDeclarationsFact,
+): Record<string, unknown> {
+  const rank = new Map([
+    ['env_declaration_mta', 0],
+    ['env_declaration_manifest', 1],
+    ['env_declaration_dotenv', 2],
+    ['env_declaration_dev', 3],
+  ]);
+  const declaration = fact.declarations.filter((item) =>
+    item.key === binding.environmentKey).sort((left, right) =>
+    (rank.get(left.provenance) ?? 99) - (rank.get(right.provenance) ?? 99)
+    || (left.sourceFile < right.sourceFile
+      ? -1 : left.sourceFile > right.sourceFile ? 1 : 0)
+    || left.startOffset - right.startOffset)[0];
+  return {
+    sourceKey: binding.sourceKey,
+    environmentKey: binding.environmentKey,
+    transforms: binding.transforms,
+    declarationProvenance: declaration?.provenance,
+    declarationSourceFile: declaration?.sourceFile,
+    declarationStartOffset: declaration?.startOffset,
+    declarationEndOffset: declaration?.endOffset,
+  };
+}
+
+export function resolveEventEnvironment(
+  skeletonValue: unknown,
+  environmentValue: unknown,
+  variables: Record<string, string>,
+): EventEnvironmentResolution {
+  const skeleton = parseEventSkeletonFact(skeletonValue);
+  if (!skeleton || skeleton.environmentBindings.length === 0) return {
+    status: 'not_applicable',
+    variables: eventTemplateVariables(skeleton, variables),
+    provenance: [],
+  };
+  const fact = parseEnvironmentDeclarationsFact(environmentValue);
+  if (!fact) return {
+    status: 'unresolved', variables,
+    reason: 'event_environment_declarations_invalid', provenance: [],
+  };
+  const expanded = eventTemplateVariables(skeleton, variables);
+  const outcomes = skeleton.environmentBindings.map((binding) =>
+    Object.hasOwn(expanded, binding.sourceKey)
+      ? {} : bindingResolution(binding, fact));
+  for (let index = 0; index < outcomes.length; index += 1) {
+    const binding = skeleton.environmentBindings[index];
+    const outcome = outcomes[index];
+    if (binding?.sourceKey && outcome?.value !== undefined
+      && !Object.hasOwn(expanded, binding.sourceKey))
+      expanded[binding.sourceKey] = outcome.value;
+  }
+  const ambiguous = outcomes.find((outcome) => outcome.ambiguous);
+  const unresolved = outcomes.find((outcome) => outcome.reason);
+  return {
+    status: ambiguous ? 'ambiguous'
+      : unresolved ? 'unresolved' : 'resolved',
+    variables: expanded,
+    reason: ambiguous?.reason ?? unresolved?.reason,
+    provenance: skeleton.environmentBindings.map((binding) =>
+      provenance(binding, fact)),
+  };
+}
+
+function dependencies(value: unknown): Record<string, string> {
+  const parsed = record(parsedJson(value));
+  if (!parsed) return {};
+  return Object.fromEntries(Object.entries(parsed).flatMap(([key, item]) =>
+    typeof item === 'string' ? [[key, item]] : []));
+}
+
+function consumerRows(
+  db: Db,
+  workspaceId: number,
+  packageName: string,
+): Array<Record<string, unknown>> {
+  return db.prepare(`SELECT id,name,dependencies_json dependenciesJson,
+    environment_declarations_json environmentJson
+    FROM repositories WHERE workspace_id=?
+    ORDER BY name COLLATE BINARY,id`).all(workspaceId)
+    .filter((row) => Object.hasOwn(
+      dependencies(row.dependenciesJson), packageName,
+    ));
+}
+
+function collisionCounts(
+  targets: readonly SubscriptionEnvironmentTarget[],
+): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const target of targets) {
+    const values = Object.entries(target.resolution.variables)
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    const key = JSON.stringify(values);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+
+export function subscriptionEnvironmentTargets(
+  db: Db,
+  workspaceId: number,
+  packageName: string | undefined,
+  skeletonValue: unknown,
+  ownEnvironmentValue: unknown,
+  variables: Record<string, string>,
+): SubscriptionEnvironmentTarget[] {
+  const skeleton = parseEventSkeletonFact(skeletonValue);
+  if (!skeleton || skeleton.environmentBindings.length === 0
+    || !packageName) return [{
+    resolution: resolveEventEnvironment(
+      skeletonValue, ownEnvironmentValue, variables,
+    ),
+    collisionCount: 1,
+  }];
+  const rows = consumerRows(db, workspaceId, packageName);
+  const provisional = rows.map((row): SubscriptionEnvironmentTarget => ({
+    consumerRepoId: Number(row.id),
+    consumerRepoName: String(row.name),
+    resolution: resolveEventEnvironment(
+      skeletonValue, row.environmentJson, variables,
+    ),
+    collisionCount: 1,
+  }));
+  if (provisional.length === 0) return [{
+    resolution: resolveEventEnvironment(
+      skeletonValue, ownEnvironmentValue, variables,
+    ),
+    collisionCount: 1,
+  }];
+  const counts = collisionCounts(provisional);
+  return provisional.map((target) => {
+    const key = JSON.stringify(Object.entries(target.resolution.variables)
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+    return { ...target, collisionCount: counts.get(key) ?? 1 };
+  });
+}

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

@@ -0,0 +1,161 @@
+import type { Db } from '../db/connection.js';
+import { parseEventSkeletonFact } from '../utils/event-skeleton.js';
+
+export interface EventShapeCandidateLinkSummary {
+  edgeCount: number;
+}
+
+interface EventShapeRow extends Record<string, unknown> {
+  id: number;
+  repoId: number;
+  repoName: string;
+  signature: string;
+  skeletonJson: string;
+}
+
+interface SubscriberAssociation extends Record<string, unknown> {
+  graphEdgeId: number;
+  subscribeCallId: number;
+  targetKind: string;
+  targetId: string;
+  status: string;
+  evidenceJson: string;
+}
+
+function eventRows(
+  db: Db,
+  workspaceId: number,
+  callType: 'async_emit' | 'async_subscribe',
+): EventShapeRow[] {
+  return db.prepare(`SELECT c.id,c.repo_id repoId,r.name repoName,
+    c.event_skeleton_signature signature,
+    c.event_skeleton_json skeletonJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND c.call_type=?
+      AND c.event_skeleton_signature IS NOT NULL
+      AND c.event_skeleton_json IS NOT NULL
+    ORDER BY c.event_skeleton_signature COLLATE BINARY,
+      r.name COLLATE BINARY,r.id,c.source_file COLLATE BINARY,
+      c.call_site_start_offset,c.call_site_end_offset,c.id`).all(
+    workspaceId, callType,
+  ) as unknown as EventShapeRow[];
+}
+
+function associations(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+): SubscriberAssociation[] {
+  return db.prepare(`SELECT id graphEdgeId,
+    CAST(json_extract(evidence_json,'$.subscribeCallId') AS INTEGER)
+      subscribeCallId,
+    to_kind targetKind,to_id targetId,status,evidence_json evidenceJson
+    FROM graph_edges
+    WHERE workspace_id=? AND generation=?
+      AND edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND to_kind='symbol'
+    ORDER BY subscribeCallId,id`).all(
+    workspaceId, generation,
+  ) as unknown as SubscriberAssociation[];
+}
+
+function parsedEvidence(value: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function candidateEligible(
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+): boolean {
+  if (emit.signature !== subscribe.signature) return false;
+  const left = parseEventSkeletonFact(emit.skeletonJson);
+  const right = parseEventSkeletonFact(subscribe.skeletonJson);
+  return Boolean(left?.candidateEligible && right?.candidateEligible
+    && left.holeCount === right.holeCount
+    && JSON.stringify(left.literalSpans) === JSON.stringify(right.literalSpans));
+}
+
+function candidateEvidence(
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+  association: SubscriberAssociation,
+): Record<string, unknown> {
+  const evidence = parsedEvidence(association.evidenceJson);
+  return {
+    publishCallId: emit.id,
+    subscribeCallId: subscribe.id,
+    eventSkeletonSignature: emit.signature,
+    dispatchScope: 'workspace_event_name_only',
+    dispatchCertainty: 'skeleton_equivalent',
+    subscriptionRepositoryId: subscribe.repoId,
+    subscriptionRepositoryName: subscribe.repoName,
+    subscriptionConsumerRepositoryId:
+      evidence.subscriptionConsumerRepositoryId,
+    subscriptionConsumerRepositoryName:
+      evidence.subscriptionConsumerRepositoryName,
+    handlerSymbolId: Number(association.targetId),
+    associationGraphEdgeId: association.graphEdgeId,
+  };
+}
+
+function insertCandidate(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+  association: SubscriberAssociation,
+): void {
+  db.prepare(`INSERT INTO graph_edges(
+    workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
+    confidence,evidence_json,is_dynamic,unresolved_reason,generation
+  ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(
+    workspaceId,
+    'EVENT_SHAPE_CANDIDATE_SUBSCRIBER',
+    'dynamic',
+    'call',
+    String(emit.id),
+    association.targetKind,
+    association.targetId,
+    0.3,
+    JSON.stringify(candidateEvidence(
+      emit, subscribe, association,
+    )),
+    1,
+    'event_skeleton_equivalent_non_authoritative',
+    generation,
+  );
+}
+
+export function linkEventShapeCandidates(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+): EventShapeCandidateLinkSummary {
+  const emits = eventRows(db, workspaceId, 'async_emit');
+  const subscriptions = eventRows(db, workspaceId, 'async_subscribe');
+  const bySubscription = new Map<number, SubscriberAssociation[]>();
+  for (const association of associations(db, workspaceId, generation))
+    bySubscription.set(association.subscribeCallId, [
+      ...(bySubscription.get(association.subscribeCallId) ?? []),
+      association,
+    ]);
+  let edgeCount = 0;
+  for (const emit of emits)
+    for (const subscription of subscriptions) {
+      if (!candidateEligible(emit, subscription)) continue;
+      for (const association of bySubscription.get(subscription.id) ?? []) {
+        insertCandidate(
+          db, workspaceId, generation, emit, subscription, association,
+        );
+        edgeCount += 1;
+      }
+    }
+  return { edgeCount };
+}

package/src/linker/{004-event-subscription-handler-linker.ts → event-subscription-handler-linker.ts}

@@ -2,7 +2,12 @@ import type { Db } from '../db/connection.js';
 import {
   linkEventTemplate,
   type LinkedEventTemplate,
-} from './006-event-template-link.js';
+} from './event-template-link.js';
+import {
+  subscriptionEnvironmentTargets,
+  type SubscriptionEnvironmentTarget,
+} from './event-environment-link.js';
+import { parseEventSkeletonFact } from '../utils/event-skeleton.js';
 
 export interface SubscriptionHandlerLinkSummary {
   edgeCount: number;
@@ -25,6 +30,9 @@ interface SubscriptionRow {
   endOffset?: number | null;
   confidence: number;
   unresolvedReason?: string | null;
+  packageName?: string | null;
+  environmentJson?: string | null;
+  eventSkeletonJson?: string | null;
 }
 
 interface HandlerCallRow {
@@ -63,7 +71,10 @@ function subscriptionRows(db: Db, workspaceId: number): SubscriptionRow[] {
     c.source_symbol_id sourceSymbolId,c.event_name_expr eventName,
     c.source_file sourceFile,c.source_line sourceLine,
     c.call_site_start_offset startOffset,c.call_site_end_offset endOffset,
-    c.confidence,c.unresolved_reason unresolvedReason
+    c.confidence,c.unresolved_reason unresolvedReason,
+    c.event_skeleton_json eventSkeletonJson,
+    r.package_name packageName,
+    r.environment_declarations_json environmentJson
     FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
     WHERE r.workspace_id=? AND c.call_type='async_subscribe'
       AND json_extract(c.evidence_json,'$.handlerReferenceStatus')
@@ -208,11 +219,18 @@ function evidenceFor(
   subscription: SubscriptionRow,
   association: HandlerAssociation,
   event: LinkedEventTemplate,
+  environment?: SubscriptionEnvironmentTarget,
 ): Record<string, unknown> {
   const call: Partial<HandlerCallRow> = association.call ?? {};
   const symbolCallReason = boundedSymbolCallReason(call.unresolvedReason);
+  const environmentAmbiguous = environment?.resolution.status === 'ambiguous'
+    || Number(environment?.collisionCount ?? 1) > 1;
+  const resolutionStatus = event.isDynamic
+    ? 'unresolved'
+    : environmentAmbiguous ? 'ambiguous' : association.status;
   return {
     eventName: subscription.eventName,
+    ...(eventSkeletonEvidence(subscription.eventSkeletonJson)),
     ...(event.substitution.placeholders.length > 0 ? {
       effectiveEventName: event.targetId,
       eventTemplateResolution: event.substitution,
@@ -226,6 +244,18 @@ function evidenceFor(
     factOrigin: association.factOrigin ?? call.factOrigin,
     repositoryId: subscription.repoId,
     repositoryName: subscription.repoName,
+    subscriptionConsumerRepositoryId: environment?.consumerRepoId,
+    subscriptionConsumerRepositoryName: environment?.consumerRepoName,
+    dispatchCertainty: environment?.resolution.status === 'resolved'
+      ? 'environment_declaration_exact' : 'static_name_only',
+    ...(environment?.resolution.status === 'not_applicable' ? {} : {
+      eventEnvironmentResolution: {
+        status: environment?.resolution.status,
+        reason: environment?.resolution.reason,
+        provenance: environment?.resolution.provenance,
+        collisionCount: environment?.collisionCount,
+      },
+    }),
     sourceFile: subscription.sourceFile,
     sourceLine: subscription.sourceLine,
     callSiteStartOffset: subscription.startOffset,
@@ -237,14 +267,23 @@ function evidenceFor(
     associationStatus: association.status,
     symbolCallResolutionStatus:
       association.symbolCallResolutionStatus ?? call.status,
-    resolutionStatus: association.status,
+    resolutionStatus,
     resolutionStrategy: call.strategy,
     candidateCount: call.candidateCount,
-    reasonCode: association.reasonCode,
+    reasonCode: environmentAmbiguous
+      ? environment?.resolution.reason ?? 'event_environment_value_collision'
+      : association.reasonCode,
     ...symbolCallReason,
   };
 }
 
+function eventSkeletonEvidence(
+  value: string | null | undefined,
+): Record<string, unknown> {
+  const skeleton = parseEventSkeletonFact(value);
+  return skeleton ? { eventSkeleton: skeleton } : {};
+}
+
 function boundedSymbolCallReason(
   reason: string | null | undefined,
 ): Record<string, unknown> {
@@ -264,10 +303,20 @@ function insertAssociationEdge(
   subscription: SubscriptionRow,
   association: HandlerAssociation,
   event: LinkedEventTemplate,
+  environment?: SubscriptionEnvironmentTarget,
 ): void {
-  const status = event.isDynamic ? 'unresolved' : association.status;
+  const environmentAmbiguous = environment?.resolution.status === 'ambiguous'
+    || Number(environment?.collisionCount ?? 1) > 1;
+  const status = event.isDynamic
+    ? 'unresolved'
+    : environmentAmbiguous ? 'ambiguous' : association.status;
   const reason = event.isDynamic
-    ? 'event_template_variables_missing'
+    ? event.substitution.missing.length > 0
+      ? 'event_template_variables_missing'
+      : event.unresolvedReason ?? 'event_name_unsupported_constant_expression'
+    : environmentAmbiguous
+      ? environment?.resolution.reason
+        ?? 'event_environment_value_collision'
     : association.reasonCode ?? association.call?.unresolvedReason ?? null;
   db.prepare(`INSERT INTO graph_edges(
     workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
@@ -281,13 +330,68 @@ function insertAssociationEdge(
     association.toKind,
     association.toId,
     association.call?.confidence ?? subscription.confidence,
-    JSON.stringify(evidenceFor(subscription, association, event)),
+    JSON.stringify(evidenceFor(
+      subscription, association, event, environment,
+    )),
     event.isDynamic ? 1 : 0,
     reason,
     generation,
   );
 }
 
+function linkedSubscriptionEvents(
+  db: Db,
+  workspaceId: number,
+  subscription: SubscriptionRow,
+  variables: Record<string, string>,
+): Array<{
+  event: LinkedEventTemplate;
+  environment: SubscriptionEnvironmentTarget;
+}> {
+  const skeleton = parseEventSkeletonFact(subscription.eventSkeletonJson);
+  return subscriptionEnvironmentTargets(
+    db,
+    workspaceId,
+    subscription.packageName ?? undefined,
+    subscription.eventSkeletonJson,
+    subscription.environmentJson,
+    variables,
+  ).map((environment) => ({
+    environment,
+    event: linkEventTemplate(
+      subscription.eventName,
+      environment.resolution.variables,
+      subscription.unresolvedReason ?? undefined,
+      skeleton,
+    ),
+  }));
+}
+
+function targetStatus(
+  association: HandlerAssociation,
+  event: LinkedEventTemplate,
+  environment: SubscriptionEnvironmentTarget,
+): 'resolved' | 'ambiguous' | 'unresolved' {
+  if (event.isDynamic || association.status === 'unresolved')
+    return 'unresolved';
+  if (association.status === 'ambiguous'
+    || environment.resolution.status === 'ambiguous'
+    || environment.collisionCount > 1) return 'ambiguous';
+  return 'resolved';
+}
+
+function incrementSummary(
+  summary: SubscriptionHandlerLinkSummary,
+  status: 'resolved' | 'ambiguous' | 'unresolved',
+  missing: boolean,
+): void {
+  summary.edgeCount += 1;
+  summary.resolvedCount += status === 'resolved' ? 1 : 0;
+  summary.ambiguousCount += status === 'ambiguous' ? 1 : 0;
+  summary.unresolvedCount += status === 'unresolved' ? 1 : 0;
+  summary.missingAssociationCount += missing ? 1 : 0;
+}
+
 export function linkEventSubscriptionHandlers(
   db: Db,
   workspaceId: number,
@@ -302,22 +406,22 @@ export function linkEventSubscriptionHandlers(
     missingAssociationCount: 0,
   };
   for (const subscription of subscriptionRows(db, workspaceId)) {
-    const event = linkEventTemplate(
-      subscription.eventName, variables,
-      subscription.unresolvedReason ?? undefined,
-    );
     const association = associationFor(
       subscription, roleSiteRows(db, subscription),
     );
-    insertAssociationEdge(
-      db, workspaceId, generation, subscription, association, event,
-    );
-    const status = event.isDynamic ? 'unresolved' : association.status;
-    summary.edgeCount += 1;
-    summary.resolvedCount += status === 'resolved' ? 1 : 0;
-    summary.ambiguousCount += status === 'ambiguous' ? 1 : 0;
-    summary.unresolvedCount += status === 'unresolved' ? 1 : 0;
-    summary.missingAssociationCount += association.missing ? 1 : 0;
+    for (const target of linkedSubscriptionEvents(
+      db, workspaceId, subscription, variables,
+    )) {
+      insertAssociationEdge(
+        db, workspaceId, generation, subscription, association,
+        target.event, target.environment,
+      );
+      incrementSummary(
+        summary,
+        targetStatus(association, target.event, target.environment),
+        association.missing,
+      );
+    }
   }
   return summary;
 }