@saptools/service-flow 0.1.70 → 0.1.73

package/src/indexer/repository-indexer.ts

@@ -7,6 +7,7 @@ import {
   insertCalls,
   insertExecutableSymbols,
   insertHandler,
+  insertGeneratedConstants,
   handlerMethodIsExecutable,
   insertRegistrations,
   insertSymbolCalls,
@@ -23,6 +24,9 @@ import {
   parseOutboundCalls,
 } from '../parsers/outbound-call-parser.js';
 import { parseExecutableSymbols } from '../parsers/symbol-parser.js';
+import {
+  generatedConstantFacts,
+} from '../parsers/generated-constants-parser.js';
 import {
   loadPackageJsonSnapshot,
 } from '../parsers/package-json-parser.js';
@@ -52,9 +56,22 @@ import {
 import {
   loadRepositorySourceContext,
   type RepositorySourceContext,
+  type SourceFileSnapshot,
   type SourceContextInstrumentation,
 } from '../parsers/ts-project.js';
-import type { CdsServiceFact, HandlerClassFact, HandlerRegistrationFact, OutboundCallFact, PackageFacts, ServiceBindingFact, ExecutableSymbolFact, SymbolCallFact } from '../types.js';
+import {
+  createImportedEventNameResolver,
+} from '../parsers/event-name-import-resolution.js';
+import {
+  collectEnvironmentDeclarations,
+  type EnvironmentDeclarationsFact,
+} from '../parsers/environment-declarations.js';
+import {
+  createEventEnvironmentReferenceResolver,
+} from '../parsers/event-environment-reference.js';
+import { invalidateEventSurfaceFacts } from
+  '../db/event-surface-invalidation.js';
+import type { CdsServiceFact, GeneratedConstantFact, HandlerClassFact, HandlerRegistrationFact, OutboundCallFact, PackageFacts, ServiceBindingFact, ExecutableSymbolFact, SymbolCallFact } from '../types.js';
 export interface IndexRepoResult {
   fileCount: number;
   diagnosticCount: number;
@@ -68,6 +85,7 @@ interface ParsedFacts {
   calls: OutboundCallFact[];
   symbols: ExecutableSymbolFact[];
   symbolCalls: SymbolCallFact[];
+  generatedConstants: GeneratedConstantFact[];
   fileRecords: Array<{ relativePath: string; extension: string; sha256: string; sizeBytes: number }>;
 }
 export interface PreparedRepositoryIndex extends IndexRepoResult {
@@ -77,6 +95,7 @@ export interface PreparedRepositoryIndex extends IndexRepoResult {
   kind?: string;
   parsed?: ParsedFacts;
   packagePublicSurface?: PackagePublicSurfaceFact;
+  environmentDeclarations?: EnvironmentDeclarationsFact;
 }
 export async function indexRepository(
   db: Db,
@@ -110,6 +129,7 @@ export async function prepareRepositoryIndex(
   repo: RepoRow,
   force: boolean,
   instrumentation?: SourceContextInstrumentation,
+  eventEnvironmentKeys?: readonly string[],
 ): Promise<PreparedRepositoryIndex> {
   const sourceFiles = await findSourceFiles(repo.absolute_path);
   const packageSnapshot = await loadPackageJsonSnapshot(repo.absolute_path, {
@@ -120,11 +140,17 @@ export async function prepareRepositoryIndex(
   const sources = await loadRepositorySourceContext(
     repo.absolute_path, sourceFiles, instrumentation,
   );
+  const environmentDeclarations = collectEnvironmentDeclarations(
+    sources, eventEnvironmentKeys,
+  );
   const fingerprint = repositoryFingerprint(
-    sources, packageFacts, packageSnapshot.rawText,
+    sources, packageFacts, packageSnapshot.rawText, environmentDeclarations,
   );
   if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
-  const parsedFacts = await parseAllSourceFacts(repo.absolute_path, sources);
+  const parsedFacts = await parseAllSourceFacts(
+    repo.absolute_path, sources, environmentDeclarations,
+    eventEnvironmentKeys,
+  );
   const packageSurface = analyzeRepositoryPackageSurface(
     packageFacts, packageSnapshot.manifest, sources,
   );
@@ -139,6 +165,7 @@ export async function prepareRepositoryIndex(
     kind: await classifyRepository(repo.absolute_path, packageFacts),
     parsed,
     packagePublicSurface: packageSurface.surface,
+    environmentDeclarations,
     fileCount: sourceFiles.length,
     diagnosticCount: parsed.handlers.filter((handler) =>
       handler.hasHandlerDecorator
@@ -154,20 +181,27 @@ export function publishPreparedRepositoryIndex(
 ): void {
   if (prepared.skipped) return;
   if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint
-    || !prepared.kind || !prepared.packagePublicSurface)
+    || !prepared.kind || !prepared.packagePublicSurface
+    || !prepared.environmentDeclarations)
     throw new Error('Prepared repository index is missing publication facts');
   const now = new Date().toISOString();
   const repoId = prepared.repo.id;
+  const environmentJson = JSON.stringify(prepared.environmentDeclarations);
   invalidatePackageTargetFacts(
     db, repoId, prepared.packageFacts.packageName, invalidations,
   );
+  invalidateEventSurfaceFacts(
+    db, repoId, prepared.parsed.calls, environmentJson,
+  );
   db.prepare(`UPDATE repositories SET package_name=?, package_version=?,
-    dependencies_json=?,package_public_surface_json=?,kind=?,index_status=?
+    dependencies_json=?,package_public_surface_json=?,
+    environment_declarations_json=?,kind=?,index_status=?
     WHERE id=?`).run(
     prepared.packageFacts.packageName,
     prepared.packageFacts.packageVersion,
     JSON.stringify(prepared.packageFacts.dependencies),
     JSON.stringify(prepared.packagePublicSurface),
+    environmentJson,
     prepared.kind,
     'indexing',
     repoId,
@@ -183,6 +217,7 @@ export function publishPreparedRepositoryIndex(
   insertRegistrations(db, repoId, prepared.parsed.registrations);
   insertBindings(db, repoId, prepared.parsed.bindings);
   insertCalls(db, repoId, prepared.parsed.calls);
+  insertGeneratedConstants(db, repoId, prepared.parsed.generatedConstants);
   db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
 }
 
@@ -242,15 +277,31 @@ export function recordIndexFailure(db: Db, repoId: number, error: unknown): void
 async function parseAllSourceFacts(
   root: string,
   sources: RepositorySourceContext,
+  environmentDeclarations: EnvironmentDeclarationsFact,
+  eventEnvironmentKeys?: readonly string[],
 ): Promise<ParsedFacts> {
-  const facts: ParsedFacts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
+  const facts: ParsedFacts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], generatedConstants: [], fileRecords: [] };
   for (const snapshot of sources.entries()) {
     const file = snapshot.filePath;
-    facts.fileRecords.push({ relativePath: normalizePath(file), extension: path.extname(file), sha256: sha256Text(snapshot.text), sizeBytes: snapshot.sizeBytes });
+    facts.fileRecords.push({
+      relativePath: normalizePath(file),
+      extension: path.extname(file),
+      sha256: sourceFactHash(snapshot, environmentDeclarations),
+      sizeBytes: snapshot.sizeBytes,
+    });
     if (file.endsWith('.cds')) facts.services.push(...(await parseCdsFile(root, file, sources)));
     if (/\.[jt]s$/.test(file)) {
       const source = snapshot.sourceFile();
-      const classified = classifyOutboundCallsInSource(source, file);
+      facts.generatedConstants.push(...generatedConstantFacts(source, file));
+      const classified = classifyOutboundCallsInSource(source, file, {
+        importedEventNameResolver: createImportedEventNameResolver(
+          sources, source, file,
+        ),
+        eventEnvironmentReferenceResolver:
+          createEventEnvironmentReferenceResolver(
+            sources, source, file, eventEnvironmentKeys,
+          ),
+      });
       facts.handlers.push(...(await parseDecorators(root, file, sources)));
       facts.registrations.push(...(await parseHandlerRegistrations(root, file, sources)));
       const bindings = await parseServiceBindings(root, file, sources);
@@ -280,12 +331,17 @@ async function findSourceFiles(root: string): Promise<string[]> {
       const rel = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
         if (!['node_modules', 'dist', 'gen', 'coverage', '.git'].includes(e.name)) await walk(path.join(dir, e.name), rel);
-      } else if (/\.(cds|ts|js)$/.test(e.name) && !isDefaultTestFile(rel)) out.push(rel);
+      } else if (isRepositoryFactInput(e.name)
+        && !isDefaultTestFile(rel)) out.push(rel);
     }
   }
   await walk(root);
   return out.sort();
 }
+function isRepositoryFactInput(name: string): boolean {
+  return /\.(cds|ts|js)$/.test(name)
+    || ['nodemon.json', '.env', 'mta.yaml', 'manifest.yml'].includes(name);
+}
 function isDefaultTestFile(relativeFile: string): boolean {
   const parts = relativeFile.split('/');
   if (parts.some((part) => ['test', 'tests', '__tests__'].includes(part))) return true;
@@ -295,6 +351,7 @@ function repositoryFingerprint(
   sources: RepositorySourceContext,
   facts: PackageFacts,
   packageJsonText: string,
+  environmentDeclarations: EnvironmentDeclarationsFact,
 ): string {
   const normalizedFacts = {
     analyzerVersion: ANALYZER_VERSION,
@@ -304,10 +361,36 @@ function repositoryFingerprint(
     cdsRequires: [...facts.cdsRequires].sort((a, b) => a.alias.localeCompare(b.alias)),
     scripts: Object.fromEntries(Object.entries(facts.scripts).sort()),
     includeTests: false,
+    eventEnvironmentKeys: environmentDeclarations.allowedKeys,
     packageJsonHash: sha256Text(packageJsonText),
   };
   const entries: string[] = [`facts:${JSON.stringify(normalizedFacts)}`];
   for (const snapshot of sources.entries())
-    entries.push(`${snapshot.filePath}:${sha256Text(snapshot.text)}`);
+    entries.push(
+      `${snapshot.filePath}:${
+        sourceFactHash(snapshot, environmentDeclarations)}`,
+    );
   return sha256Text(entries.join('\n'));
 }
+
+function sourceFactHash(
+  snapshot: SourceFileSnapshot,
+  environmentDeclarations: EnvironmentDeclarationsFact,
+): string {
+  if (!isEnvironmentFactInput(snapshot.filePath))
+    return sha256Text(snapshot.text);
+  const declarations = environmentDeclarations.declarations.filter(
+    (item) => item.sourceFile === snapshot.filePath,
+  );
+  return sha256Text(JSON.stringify({
+    allowedKeys: environmentDeclarations.allowedKeys,
+    declarations,
+  }));
+}
+
+function isEnvironmentFactInput(filePath: string): boolean {
+  const name = filePath.split('/').at(-1);
+  return ['nodemon.json', '.env', 'mta.yaml', 'manifest.yml'].includes(
+    name ?? '',
+  );
+}

package/src/indexer/workspace-indexer.ts

@@ -104,7 +104,12 @@ export interface IndexWorkspaceSummary {
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
-  options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
+  options: {
+    repo?: string;
+    force: boolean;
+    eventEnvironmentKeys?: readonly string[];
+    injectDerivedMaterializationFailure?: boolean;
+  },
 ): Promise<IndexWorkspaceSummary> {
   const repos = selectedRepositories(db, workspaceId, options.repo);
   const runId = claimIndexRun(db, workspaceId, repos.length);
@@ -112,7 +117,9 @@ export async function indexWorkspace(
     fileCount: 0, diagnosticCount: 0, skippedCount: 0, rows: [],
   };
   try {
-    await prepareRepositories(repos, options.force, state);
+    await prepareRepositories(
+      repos, options.force, state, options.eventEnvironmentKeys,
+    );
     return publishPreparedWorkspaceRows(
       db, workspaceId, runId, state.rows, options,
     );
@@ -168,10 +175,13 @@ async function prepareRepositories(
   repos: readonly IndexRepository[],
   force: boolean,
   state: PreparationState,
+  eventEnvironmentKeys?: readonly string[],
 ): Promise<void> {
   for (const repo of repos) {
     state.activeRepoId = repo.id;
-    const result = await prepareRepositoryIndex(repo, force);
+    const result = await prepareRepositoryIndex(
+      repo, force, undefined, eventEnvironmentKeys,
+    );
     state.rows.push(result);
     state.fileCount += result.fileCount;
     state.diagnosticCount += result.diagnosticCount;

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

@@ -4,7 +4,10 @@ import { linkImplementations as linkCanonicalImplementations } from './implement
 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,14 @@ export interface LinkWorkspaceResult {
   subscriptionHandlerAmbiguousCount: number;
   subscriptionHandlerUnresolvedCount: number;
   subscriptionHandlerMissingAssociationCount: number;
+  eventShapeCandidateCount: number;
+  eventShapeCandidateOmittedCount: 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 +41,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, eventShapeCandidateOmittedCount: eventShapes.omittedCount };
   });
 }
 function nextGraphGeneration(db: Db, workspaceId: number): number {
@@ -54,7 +63,9 @@ type CallLinkSummary = Omit<LinkWorkspaceResult,
   | 'subscriptionHandlerResolvedCount'
   | 'subscriptionHandlerAmbiguousCount'
   | 'subscriptionHandlerUnresolvedCount'
-  | 'subscriptionHandlerMissingAssociationCount'>;
+  | 'subscriptionHandlerMissingAssociationCount'
+  | 'eventShapeCandidateCount'
+  | 'eventShapeCandidateOmittedCount'>;
 
 function linkCalls(db: Db, workspaceId: number, vars: Record<string, string>, generation: number): CallLinkSummary {
   let edgeCount = 0;
@@ -65,7 +76,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/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 };
+  });
+}