@saptools/service-flow 0.1.52 → 0.1.53

package/src/linker/helper-package-linker.ts

@@ -1,4 +1,5 @@
 import type { Db } from '../db/connection.js';
+import { projectBounded } from '../utils/000-bounded-projection.js';
 
 interface RepoDependencyRow {
   id: number;
@@ -34,6 +35,10 @@ export function linkHelperPackages(db: Db, workspaceId: number, generation: numb
       if (result.candidates.length === 0) continue;
       const status = result.candidates.length === 1 ? 'resolved' : 'ambiguous';
       const helper = status === 'resolved' ? result.candidates[0] : undefined;
+      const projection = projectBounded(result.candidates, (left, right) =>
+        left.name.localeCompare(right.name)
+        || String(left.package_name ?? '').localeCompare(String(right.package_name ?? ''))
+        || left.id - right.id);
       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,
         'REPO_IMPORTS_HELPER_PACKAGE',
@@ -41,9 +46,20 @@ export function linkHelperPackages(db: Db, workspaceId: number, generation: numb
         'repo',
         String(repo.id),
         helper ? 'repo' : 'repo_candidates',
-        helper ? String(helper.id) : result.candidates.map((candidate) => candidate.id).join(','),
+        helper ? String(helper.id) : projection.items.map((candidate) => candidate.id).join(','),
         helper ? 1 : 0.5,
-        JSON.stringify({ dependency: dep, candidates: result.candidates.map((candidate) => ({ id: candidate.id, name: candidate.name, packageName: candidate.package_name })), match: result.strategy }),
+        JSON.stringify({
+          dependency: dep,
+          candidates: projection.items.map((candidate) => ({
+            id: candidate.id,
+            name: candidate.name,
+            packageName: candidate.package_name,
+          })),
+          candidateCount: projection.totalCount,
+          shownCandidateCount: projection.shownCount,
+          omittedCandidateCount: projection.omittedCount,
+          match: result.strategy,
+        }),
         0,
         helper ? null : 'Ambiguous dependency package candidates',
         generation,

package/src/linker/service-resolver.ts

@@ -1,4 +1,5 @@
 import type { Db } from '../db/connection.js';
+import { canonicalImplementationEvidence } from './000-implementation-candidates.js';
 export interface OperationTarget {
   operationId: number;
   repoName: string;
@@ -209,8 +210,11 @@ function ownershipReason(db: Db, candidate: OperationTarget, callerRepoId: numbe
     if (row?.repoId === callerRepoId) return { candidate, reason: 'resolved_implementation_handler_repo_matches_caller' };
   }
   if (edge?.evidence_json) {
-    const evidence = JSON.parse(edge.evidence_json) as { candidates?: Array<{ accepted?: boolean; handlerPackage?: { id?: number }; applicationPackage?: { id?: number } }> };
-    const hit = evidence.candidates?.find((item) => item.accepted && (Number(item.handlerPackage?.id) === callerRepoId || Number(item.applicationPackage?.id) === callerRepoId));
+    const stored = parsedRecord(edge.evidence_json);
+    const evidence = canonicalImplementationEvidence(db, candidate.operationId) ?? stored;
+    const hit = implementationEvidenceCandidates(evidence).find((item) =>
+      item.accepted && (item.handlerRepoId === callerRepoId
+        || item.applicationRepoId === callerRepoId));
     if (hit) return { candidate, reason: edge.status === 'ambiguous' ? 'ambiguous_implementation_candidate_repo_matches_caller' : 'registration_package_matches_caller' };
   }
   const dep = db.prepare("SELECT 1 FROM graph_edges WHERE edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND status='resolved' AND from_kind='repo' AND from_id=? AND to_id=?").get(String(callerRepoId), String(candidate.repoId));
@@ -218,6 +222,45 @@ function ownershipReason(db: Db, candidate: OperationTarget, callerRepoId: numbe
   return undefined;
 }
 
+function implementationEvidenceCandidates(
+  evidence: Record<string, unknown>,
+): Array<{ accepted: boolean; handlerRepoId?: number; applicationRepoId?: number }> {
+  const candidates = evidence.candidates;
+  if (!Array.isArray(candidates)) return [];
+  return candidates.flatMap((candidate) => {
+    if (!isRecord(candidate)) return [];
+    const row = candidate;
+    const handler = recordValue(row.handlerPackage);
+    const application = recordValue(row.applicationPackage);
+    return [{
+      accepted: row.accepted === true,
+      handlerRepoId: numberValue(handler.id),
+      applicationRepoId: numberValue(application.id),
+    }];
+  });
+}
+
+function recordValue(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function parsedRecord(value: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return recordValue(parsed);
+  } catch {
+    return {};
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
 function matchesLocalRepo(db: Db, operationId: number, repoId: number | undefined): boolean {
   if (repoId === undefined) return true;
   const row = db.prepare('SELECT s.repo_id repoId FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?').get(operationId) as { repoId?: number } | undefined;

package/src/output/doctor-output.ts

@@ -56,8 +56,11 @@ function compactMessage(diagnostic: Diagnostic): string {
 
 function suggestedHintLines(diagnostic: Diagnostic): string[] {
   const direct = cliHints(diagnostic.suggestedHints);
-  if (direct.length > 0) return cappedHints(direct);
-  return cappedHints(cliHintsFromSuggestions(diagnostic.implementationHintSuggestions));
+  const omitted = numericValue(diagnostic.omittedImplementationHintSuggestionCount);
+  if (direct.length > 0) return cappedHints(direct, omitted);
+  return cappedHints(
+    cliHintsFromSuggestions(diagnostic.implementationHintSuggestions), omitted,
+  );
 }
 
 function cliHints(value: unknown): string[] {
@@ -76,13 +79,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
 
-function cappedHints(hints: string[]): string[] {
+function cappedHints(hints: string[], omitted: number): string[] {
   const unique = [...new Set(hints)];
   const shown = unique.slice(0, 3);
-  if (unique.length > shown.length) shown.push(`... ${unique.length - shown.length} more hint(s) available in --format json`);
+  const remaining = Math.max(0, unique.length - shown.length) + omitted;
+  if (remaining > 0)
+    shown.push(`... ${remaining} additional hint(s) omitted; use a scoped --implementation-hint`);
   return shown;
 }
 
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
 function cleanDoctorMessage(): string {
   return `${pc.green('No diagnostics recorded')}\n`;
 }

package/src/output/table-output.ts

@@ -60,8 +60,10 @@ function hintLines(evidence: Record<string, unknown>): string[] {
       : []);
   const unique = [...new Set(hints)];
   const shown = unique.slice(0, 3).map((hint) => `try ${hint}`);
-  if (unique.length > shown.length)
-    shown.push(`... ${unique.length - shown.length} more hint(s) available in JSON`);
+  const omitted = numberValue(evidence.omittedImplementationHintSuggestionCount);
+  const remaining = Math.max(0, unique.length - shown.length) + omitted;
+  if (remaining > 0)
+    shown.push(`... ${remaining} additional hint(s) omitted; use a scoped --implementation-hint`);
   return [...dynamicLines, ...shown];
 }
 

package/src/trace/000-dynamic-target-types.ts

@@ -47,8 +47,16 @@ export interface DynamicTargetCandidate {
   derivedVariables: Record<string, string>;
   derivedVariableSources: Record<string, DynamicVariableProvenance>;
   derivationProvenance: Record<string, DynamicVariableProvenance[]>;
+  derivationProvenanceCounts?: Record<string, {
+    provenanceCount: number;
+    shownProvenanceCount: number;
+    omittedProvenanceCount: number;
+  }>;
   missingVariables: string[];
   conflicts: DynamicVariableConflict[];
+  conflictCount?: number;
+  shownConflictCount?: number;
+  omittedConflictCount?: number;
   score: number;
   explicitSignalStrength: number;
   reasons: string[];
@@ -80,5 +88,9 @@ export interface DynamicTargetAnalysis {
   shownCandidates: DynamicTargetCandidate[];
   rejectedCandidates: DynamicTargetCandidate[];
   suggestedVarSets: Array<{ variables: Record<string, string>; cli: string }>;
+  suggestedVarSetCount: number;
+  shownSuggestedVarSetCount: number;
+  omittedSuggestedVarSetCount: number;
   inference: Record<string, unknown>;
+  routingContext?: Record<string, unknown>;
 }

package/src/trace/001-dynamic-identity.ts

@@ -5,8 +5,12 @@ import type {
   DynamicVariableProvenance,
 } from './000-dynamic-target-types.js';
 
-interface ImplementationOwner {
-  repoId?: number;
+interface RouteImplementationEvidence {
+  routeRepoId?: number;
+  handlerRepo?: string;
+  operationProvenance?: string;
+  baseOperationId?: number;
+  edgeStatus?: string;
 }
 
 interface IdentityProposal {
@@ -44,11 +48,13 @@ export function uniqueIdentityDerivations(
 ): IdentityDerivation[] {
   const identities = workspaceIdentities(db, candidates);
   const proposals = candidates.flatMap((candidate) => {
-    const owner = implementationOwner(db, candidate.candidateOperationId);
+    const implementation = routeImplementationEvidence(
+      db, candidate.candidateOperationId,
+    );
     const identity = identities.find((item) => item.repoId === candidate.repoId);
-    return ownerAgrees(candidate, owner) && identity
-      ? identityProposals(candidate, identity, templates)
-      : [];
+    if (!identity || !implementation || !routeOwnerAgrees(candidate, implementation))
+      return [];
+    return identityProposals(candidate, identity, templates, implementation);
   });
   const matches = workspaceIdentityMatches(identities, templates);
   const competing = competingIdentityKeys(matches);
@@ -68,6 +74,7 @@ function identityProposals(
   candidate: DynamicTargetCandidate,
   identity: RepositoryIdentity,
   templates: DynamicTemplates,
+  implementation: RouteImplementationEvidence,
 ): IdentityProposal[] {
   const routeTemplates = [templates.alias, templates.destination]
     .filter((value): value is string => Boolean(value));
@@ -81,7 +88,7 @@ function identityProposals(
     identities.flatMap((identity) =>
       proposalForIdentity(
         candidate, template, identity.name, identity.sourceKind,
-        identity.npmPackage,
+        identity.npmPackage, implementation,
       )));
   return deduplicateProposals(proposals);
 }
@@ -92,6 +99,7 @@ function proposalForIdentity(
   identity: string,
   sourceKind: string,
   npmPackage: boolean,
+  implementation: RouteImplementationEvidence,
 ): IdentityProposal[] {
   const match = matchIdentityTemplate(template, identity, npmPackage);
   if (!match) return [];
@@ -108,6 +116,12 @@ function proposalForIdentity(
       matchedName: identity,
       normalizedForm: match.normalizedIdentity,
       sourceRepo: candidate.repoName,
+      routeOwner: candidate.repoName,
+      candidateOperationId: candidate.candidateOperationId,
+      effectiveBaseOperationId: implementation.baseOperationId,
+      candidateOperationProvenance: implementation.operationProvenance,
+      implementationEdgeStatus: implementation.edgeStatus,
+      implementationHandlerRepo: implementation.handlerRepo,
     },
   }];
 }
@@ -229,30 +243,44 @@ function deduplicateProposals(rows: IdentityProposal[]): IdentityProposal[] {
   });
 }
 
-function ownerAgrees(
+function routeOwnerAgrees(
   candidate: DynamicTargetCandidate,
-  owner: ImplementationOwner | undefined,
+  implementation: RouteImplementationEvidence | undefined,
 ): boolean {
   return candidate.repoId !== undefined
-    && owner?.repoId !== undefined
-    && owner.repoId === candidate.repoId;
+    && implementation?.routeRepoId === candidate.repoId
+    && implementation.edgeStatus === 'resolved'
+    && candidate.viable
+    && candidate.reasons.includes('service_path_template_match');
 }
 
-function implementationOwner(db: Db, operationId: number): ImplementationOwner | undefined {
+function routeImplementationEvidence(
+  db: Db,
+  operationId: number,
+): RouteImplementationEvidence | undefined {
   const rows = db.prepare(
-    `SELECT r.id repoId
-     FROM graph_edges e JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
+    `SELECT s.repo_id routeRepoId,o.provenance operationProvenance,
+      o.base_operation_id baseOperationId,e.status edgeStatus,
+      r.name handlerRepo
+     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+     JOIN graph_edges e ON e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER'
+       AND e.from_kind='operation' AND e.from_id=CAST(o.id AS TEXT)
+     JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
      JOIN handler_classes hc ON hc.id=hm.handler_class_id
      JOIN repositories r ON r.id=hc.repo_id
      WHERE e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND e.status='resolved'
-       AND e.from_kind='operation' AND e.from_id=?
-     ORDER BY r.id,hm.id,e.id`,
+       AND o.id=?
+     ORDER BY e.id,hm.id`,
   ).all(String(operationId));
   if (rows.length !== 1) return undefined;
   const row = rows[0];
   if (!row) return undefined;
   return {
-    repoId: numberValue(row.repoId),
+    routeRepoId: numberValue(row.routeRepoId),
+    handlerRepo: stringValue(row.handlerRepo),
+    operationProvenance: stringValue(row.operationProvenance),
+    baseOperationId: numberValue(row.baseOperationId),
+    edgeStatus: stringValue(row.edgeStatus),
   };
 }
 

package/src/trace/003-dynamic-references.ts

@@ -1,43 +1,78 @@
 import type { Db } from '../db/connection.js';
+import {
+  projectBounded,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
 import type { DynamicVariableProvenance } from './000-dynamic-target-types.js';
 
 export interface DynamicReferenceRow {
+  bindingId?: number;
   alias?: string;
+  aliasExpr?: string;
   destination?: string;
   servicePath?: string;
   sourceKind: 'service_binding' | 'cds_require';
+  selection: 'selected_binding' | 'selected_binding_require' | 'fallback';
   repoName: string;
   sourceFile?: string;
   sourceLine?: number;
+  helperChain?: unknown;
 }
 
-export function dynamicReferenceRows(
+export interface DynamicRoutingContext {
+  outboundCallId?: number;
+  callerRepoId?: number;
+  callerRepo?: string;
+  selectedBindingId?: number;
+  bindingResolutionStatus: string;
+  selectedBinding?: DynamicReferenceRow;
+  bindingAlternatives: Array<Record<string, unknown>>;
+  bindingAlternativeCount: number;
+  shownBindingAlternativeCount: number;
+  omittedBindingAlternativeCount: number;
+  references: DynamicReferenceRow[];
+  fallbackUsed: boolean;
+}
+
+interface SelectedDynamicReference extends DynamicReferenceRow {
+  outboundCallId: number;
+  callerRepoId: number;
+}
+
+export function dynamicRoutingContext(
   db: Db,
   workspaceId: number | undefined,
-  callerRepoId: number | undefined,
-  callerRepo: string | undefined,
-): DynamicReferenceRow[] {
-  if (callerRepoId === undefined && callerRepo === undefined) return [];
-  const rows = db.prepare(
-    `SELECT COALESCE(b.alias,b.alias_expr) alias,b.destination_expr destination,
-      b.service_path_expr servicePath,'service_binding' sourceKind,r.name repoName,
-      b.source_file sourceFile,b.source_line sourceLine,0 sourcePriority
-     FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
-     WHERE (? IS NULL OR r.workspace_id=?)
-       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
-     UNION ALL
-     SELECT req.alias,req.destination,req.service_path,'cds_require',r.name,
-      'package.json',1,1 FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
-     WHERE (? IS NULL OR r.workspace_id=?)
-       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
-     ORDER BY sourcePriority,repoName,sourceFile,sourceLine`,
-  ).all(
-    workspaceId, workspaceId,
-    callerRepoId, callerRepoId, callerRepoId, callerRepo,
-    workspaceId, workspaceId,
-    callerRepoId, callerRepoId, callerRepoId, callerRepo,
+  evidence: Record<string, unknown>,
+): DynamicRoutingContext {
+  const selected = selectedBinding(db, workspaceId, evidence);
+  const persisted = persistedBindingResolution(evidence);
+  const alternatives = boundedAlternatives(
+    persisted.candidates,
+    persisted.candidateCount,
   );
-  return rows.flatMap(referenceFromRow);
+  if (selected) {
+    const requires = exactRequireReferences(db, workspaceId, selected);
+    return {
+      ...contextBase(selected, persisted.status, alternatives),
+      selectedBinding: selected,
+      references: [selected, ...requires],
+      fallbackUsed: false,
+    };
+  }
+  const callerRepoId = numberValue(evidence.repoId);
+  const callerRepo = stringValue(evidence.repo);
+  return {
+    outboundCallId: numberValue(evidence.outboundCallId ?? evidence.callId),
+    callerRepoId,
+    callerRepo,
+    bindingResolutionStatus: persisted.status,
+    bindingAlternatives: alternatives.items,
+    bindingAlternativeCount: alternatives.totalCount,
+    shownBindingAlternativeCount: alternatives.shownCount,
+    omittedBindingAlternativeCount: alternatives.omittedCount,
+    references: fallbackReferences(db, workspaceId, callerRepoId, callerRepo),
+    fallbackUsed: true,
+  };
 }
 
 export function dynamicReferenceProvenance(
@@ -46,33 +81,199 @@ export function dynamicReferenceProvenance(
   template: string,
   value: string,
 ): DynamicVariableProvenance {
+  const sourceKind = reference.selection === 'selected_binding'
+    ? `selected_binding.${kind}`
+    : reference.selection === 'selected_binding_require'
+      ? `selected_binding_require.${kind}`
+      : `${reference.sourceKind}.${kind}`;
   return {
-    sourceKind: `${reference.sourceKind}.${kind}`,
+    sourceKind,
     value,
     rule: 'exact_indexed_reference_template_match',
     template,
     sourceRepo: reference.repoName,
     sourceFile: reference.sourceFile,
     sourceLine: reference.sourceLine,
+    selection: reference.selection,
+    bindingId: reference.bindingId,
+  };
+}
+
+function contextBase(
+  selected: SelectedDynamicReference,
+  status: string,
+  alternatives: ReturnType<typeof boundedAlternatives>,
+): Omit<DynamicRoutingContext, 'selectedBinding' | 'references' | 'fallbackUsed'> {
+  return {
+    outboundCallId: selected.outboundCallId,
+    callerRepoId: selected.callerRepoId,
+    callerRepo: selected.repoName,
+    selectedBindingId: selected.bindingId,
+    bindingResolutionStatus: status,
+    bindingAlternatives: alternatives.items,
+    bindingAlternativeCount: alternatives.totalCount,
+    shownBindingAlternativeCount: alternatives.shownCount,
+    omittedBindingAlternativeCount: alternatives.omittedCount,
   };
 }
 
-function referenceFromRow(row: Record<string, unknown>): DynamicReferenceRow[] {
-  const sourceKind = row.sourceKind;
-  const repoName = stringValue(row.repoName);
-  if ((sourceKind !== 'service_binding' && sourceKind !== 'cds_require')
-    || !repoName) return [];
+function selectedBinding(
+  db: Db,
+  workspaceId: number | undefined,
+  evidence: Record<string, unknown>,
+): SelectedDynamicReference | undefined {
+  const callId = numberValue(evidence.outboundCallId ?? evidence.callId);
+  if (callId === undefined) return undefined;
+  const row = db.prepare(`SELECT c.id outboundCallId,c.repo_id callerRepoId,r.name repoName,
+      b.id bindingId,b.alias,b.alias_expr aliasExpr,b.destination_expr destination,
+      b.service_path_expr servicePath,b.source_file sourceFile,b.source_line sourceLine,
+      b.helper_chain_json helperChainJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    JOIN service_bindings b ON b.id=c.service_binding_id AND b.repo_id=c.repo_id
+    WHERE c.id=? AND (? IS NULL OR r.workspace_id=?)`).get(
+    callId, workspaceId, workspaceId,
+  );
+  return selectedReferenceFromRow(row);
+}
+
+function selectedReferenceFromRow(
+  row: Record<string, unknown> | undefined,
+): SelectedDynamicReference | undefined {
+  const outboundCallId = numberValue(row?.outboundCallId);
+  const callerRepoId = numberValue(row?.callerRepoId);
+  const reference = referenceFromRow(
+    row, 'service_binding', 'selected_binding',
+  )[0];
+  return reference && outboundCallId !== undefined && callerRepoId !== undefined
+    ? { ...reference, outboundCallId, callerRepoId }
+    : undefined;
+}
+
+function exactRequireReferences(
+  db: Db,
+  workspaceId: number | undefined,
+  selected: SelectedDynamicReference,
+): DynamicReferenceRow[] {
+  if (!(selected.aliasExpr ?? selected.alias)) return [];
+  const rows = db.prepare(`SELECT req.alias,req.destination,req.service_path servicePath,
+      r.name repoName,'package.json' sourceFile,1 sourceLine
+    FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+    WHERE req.repo_id=? AND (? IS NULL OR r.workspace_id=?)
+    ORDER BY req.alias,req.id`).all(
+    selected.callerRepoId, workspaceId, workspaceId,
+  );
+  return rows.flatMap((row) => referenceFromRow(
+    row, 'cds_require', 'selected_binding_require', selected.bindingId,
+  ));
+}
+
+function fallbackReferences(
+  db: Db,
+  workspaceId: number | undefined,
+  callerRepoId: number | undefined,
+  callerRepo: string | undefined,
+): DynamicReferenceRow[] {
+  if (callerRepoId === undefined && callerRepo === undefined) return [];
+  const rows = db.prepare(`SELECT b.id bindingId,COALESCE(b.alias,b.alias_expr) alias,
+      b.alias_expr aliasExpr,b.destination_expr destination,b.service_path_expr servicePath,
+      'service_binding' sourceKind,r.name repoName,b.source_file sourceFile,
+      b.source_line sourceLine,b.helper_chain_json helperChainJson,0 sourcePriority
+    FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+    UNION ALL
+    SELECT NULL,req.alias,req.alias,req.destination,req.service_path,
+      'cds_require',r.name,'package.json',1,NULL,1
+    FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+    ORDER BY sourcePriority,repoName,sourceFile,sourceLine`).all(
+    workspaceId, workspaceId, callerRepoId, callerRepoId, callerRepoId, callerRepo,
+    workspaceId, workspaceId, callerRepoId, callerRepoId, callerRepoId, callerRepo,
+  );
+  return rows.flatMap((row) => {
+    const sourceKind = row.sourceKind;
+    return sourceKind === 'service_binding' || sourceKind === 'cds_require'
+      ? referenceFromRow(row, sourceKind, 'fallback')
+      : [];
+  });
+}
+
+function referenceFromRow(
+  row: Record<string, unknown> | undefined,
+  sourceKind: DynamicReferenceRow['sourceKind'],
+  selection: DynamicReferenceRow['selection'],
+  bindingId = numberValue(row?.bindingId),
+): DynamicReferenceRow[] {
+  const repoName = stringValue(row?.repoName);
+  if (!repoName) return [];
   return [{
-    alias: stringValue(row.alias),
-    destination: stringValue(row.destination),
-    servicePath: stringValue(row.servicePath),
+    bindingId,
+    alias: stringValue(row?.alias),
+    aliasExpr: stringValue(row?.aliasExpr),
+    destination: stringValue(row?.destination),
+    servicePath: stringValue(row?.servicePath),
     sourceKind,
+    selection,
     repoName,
-    sourceFile: stringValue(row.sourceFile),
-    sourceLine: numberValue(row.sourceLine),
+    sourceFile: stringValue(row?.sourceFile),
+    sourceLine: numberValue(row?.sourceLine),
+    helperChain: parsedJson(row?.helperChainJson),
   }];
 }
 
+function persistedBindingResolution(evidence: Record<string, unknown>): {
+  status: string;
+  candidates: Array<Record<string, unknown>>;
+  candidateCount: number;
+} {
+  const outbound = record(evidence.outboundEvidence);
+  const resolution = record(outbound.serviceBindingResolution);
+  return {
+    status: stringValue(resolution.status) ?? 'unknown',
+    candidates: recordArray(resolution.candidates),
+    candidateCount: numberValue(resolution.candidateCount) ?? 0,
+  };
+}
+
+function boundedAlternatives(
+  rows: Array<Record<string, unknown>>,
+  reportedCount: number,
+): BoundedProjection<Record<string, unknown>> {
+  const projection = projectBounded(rows, (left, right) =>
+    Number(left.bindingId ?? 0) - Number(right.bindingId ?? 0)
+    || String(left.sourceFile ?? '').localeCompare(String(right.sourceFile ?? ''))
+    || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0));
+  const totalCount = Math.max(reportedCount, projection.totalCount);
+  return {
+    ...projection,
+    totalCount,
+    omittedCount: Math.max(0, totalCount - projection.shownCount),
+  };
+}
+
+function parsedJson(value: unknown): unknown {
+  if (typeof value !== 'string' || value.length === 0) return undefined;
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function recordArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> =>
+        Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+    : [];
+}
+
 function stringValue(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined;
 }