@saptools/service-flow 0.1.67 → 0.1.69

package/src/indexer/cds-extension-resolver.ts

@@ -15,9 +15,12 @@ interface BaseRow { id: number; repoId: number }
 interface DesiredOperation { id: number; operationType: string; operationName: string; operationPath: string; paramsJson: string; returnType: string | null; sourceFile: string; sourceLine: number }
 interface ExistingOperation extends DesiredOperation { baseOperationId: number | null }
 
-export function materializeCdsExtensionOperations(db: Db, workspaceId: number): void {
-  const extensions = db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,s.qualified_name qualifiedName,s.source_file sourceFile,s.extension_module_specifier moduleSpecifier,s.extension_imported_symbol importedSymbol,s.extension_import_kind importKind
-    FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=1`).all(workspaceId) as unknown as ExtensionRow[];
+export function materializeCdsExtensionOperations(
+  db: Db,
+  workspaceId: number,
+  excludedRepoIds: ReadonlySet<number> = new Set(),
+): void {
+  const extensions = extensionRows(db, workspaceId, excludedRepoIds);
   db.transaction(() => {
     const changedRepos = new Set<number>();
     for (const extension of extensions) {
@@ -27,6 +30,27 @@ export function materializeCdsExtensionOperations(db: Db, workspaceId: number):
   });
 }
 
+function extensionRows(
+  db: Db,
+  workspaceId: number,
+  excludedRepoIds: ReadonlySet<number>,
+): ExtensionRow[] {
+  const excluded = [...excludedRepoIds].sort((left, right) => left - right);
+  const exclusion = excluded.length > 0
+    ? ` AND r.id NOT IN (${excluded.map(() => '?').join(',')})`
+    : '';
+  return db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,
+    s.qualified_name qualifiedName,s.source_file sourceFile,
+    s.extension_module_specifier moduleSpecifier,
+    s.extension_imported_symbol importedSymbol,
+    s.extension_import_kind importKind
+    FROM cds_services s JOIN repositories r ON r.id=s.repo_id
+    WHERE r.workspace_id=? AND s.is_extend=1${exclusion}
+    ORDER BY r.id,s.id`).all(
+    workspaceId, ...excluded,
+  ) as unknown as ExtensionRow[];
+}
+
 function reconcileExtension(db: Db, workspaceId: number, extension: ExtensionRow): boolean {
   const bases = resolveBase(db, workspaceId, extension);
   const status = bases.length === 1 ? 'resolved' : bases.length > 1 ? 'ambiguous' : 'unresolved';

package/src/indexer/repository-indexer.ts

@@ -18,16 +18,37 @@ import { classifyRepository } from '../discovery/classify-repository.js';
 import { parseCdsFile } from '../parsers/cds-parser.js';
 import { parseDecorators } from '../parsers/decorator-parser.js';
 import { parseHandlerRegistrations } from '../parsers/handler-registration-parser.js';
-import { parseOutboundCalls } from '../parsers/outbound-call-parser.js';
+import {
+  classifyOutboundCallsInSource,
+  parseOutboundCalls,
+} from '../parsers/outbound-call-parser.js';
 import { parseExecutableSymbols } from '../parsers/symbol-parser.js';
 import {
   loadPackageJsonSnapshot,
 } from '../parsers/package-json-parser.js';
 import { parseServiceBindings } from '../parsers/service-binding-parser.js';
+import { reconcileSourceFacts } from '../parsers/007-source-fact-reconciliation.js';
+import {
+  analyzeRepositoryPackageSurface,
+  mergePackageSymbolEvidence,
+} from '../parsers/008-package-surface-publication.js';
+import type {
+  PackagePublicSurfaceFact,
+} from '../parsers/003-package-public-surface.js';
 import { normalizePath } from '../utils/path-utils.js';
 import { errorMessage } from '../utils/diagnostics.js';
 import { sha256Text } from '../utils/hashing.js';
 import { ANALYZER_VERSION } from '../version.js';
+import {
+  createPackageInvalidationBatch,
+  finalizePackageTargetInvalidations,
+  invalidatePackageTargetFacts,
+  type PackageInvalidationBatch,
+} from '../db/004-package-target-invalidation.js';
+import {
+  isPreparedRepositorySnapshotError,
+  recordPreparedSnapshotFailure,
+} from '../db/013-index-publication-failure.js';
 import {
   loadRepositorySourceContext,
   type RepositorySourceContext,
@@ -55,6 +76,7 @@ export interface PreparedRepositoryIndex extends IndexRepoResult {
   fingerprint?: string;
   kind?: string;
   parsed?: ParsedFacts;
+  packagePublicSurface?: PackagePublicSurfaceFact;
 }
 export async function indexRepository(
   db: Db,
@@ -64,8 +86,21 @@ export async function indexRepository(
 ): Promise<IndexRepoResult> {
   try {
     const prepared = await prepareRepositoryIndex(repo, force, instrumentation);
-    if (!prepared.skipped) db.transaction(() => publishPreparedRepositoryIndex(db, prepared));
-    return { fileCount: prepared.fileCount, diagnosticCount: prepared.diagnosticCount, skipped: prepared.skipped };
+    if (prepared.skipped)
+      return { fileCount: 0, diagnosticCount: 0, skipped: true };
+    const outcome = db.transaction(() => {
+      const batch = createPackageInvalidationBatch([prepared.repo.id]);
+      const published = publishOneRepository(db, prepared, batch);
+      if (published.ok) finalizePackageTargetInvalidations(db, batch);
+      return published;
+    });
+    return outcome.ok
+      ? {
+          fileCount: prepared.fileCount,
+          diagnosticCount: prepared.diagnosticCount,
+          skipped: false,
+        }
+      : { fileCount: 0, diagnosticCount: 1, skipped: false };
   } catch (error) {
     recordIndexFailure(db, repo.id, error);
     return { fileCount: 0, diagnosticCount: 1, skipped: false };
@@ -89,13 +124,21 @@ export async function prepareRepositoryIndex(
     sources, packageFacts, packageSnapshot.rawText,
   );
   if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
-  const parsed = await parseAllSourceFacts(repo.absolute_path, sources);
+  const parsedFacts = await parseAllSourceFacts(repo.absolute_path, sources);
+  const packageSurface = analyzeRepositoryPackageSurface(
+    packageFacts, packageSnapshot.manifest, sources,
+  );
+  const parsed = {
+    ...parsedFacts,
+    symbols: mergePackageSymbolEvidence(parsedFacts.symbols, packageSurface),
+  };
   return {
     repo,
     packageFacts,
     fingerprint,
     kind: await classifyRepository(repo.absolute_path, packageFacts),
     parsed,
+    packagePublicSurface: packageSurface.surface,
     fileCount: sourceFiles.length,
     diagnosticCount: parsed.handlers.filter((handler) =>
       handler.hasHandlerDecorator
@@ -104,12 +147,31 @@ export async function prepareRepositoryIndex(
     skipped: false,
   };
 }
-export function publishPreparedRepositoryIndex(db: Db, prepared: PreparedRepositoryIndex): void {
+export function publishPreparedRepositoryIndex(
+  db: Db,
+  prepared: PreparedRepositoryIndex,
+  invalidations: PackageInvalidationBatch,
+): void {
   if (prepared.skipped) return;
-  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind) throw new Error('Prepared repository index is missing publication facts');
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint
+    || !prepared.kind || !prepared.packagePublicSurface)
+    throw new Error('Prepared repository index is missing publication facts');
   const now = new Date().toISOString();
   const repoId = prepared.repo.id;
-  db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(prepared.packageFacts.packageName, prepared.packageFacts.packageVersion, JSON.stringify(prepared.packageFacts.dependencies), prepared.kind, 'indexing', repoId);
+  invalidatePackageTargetFacts(
+    db, repoId, prepared.packageFacts.packageName, invalidations,
+  );
+  db.prepare(`UPDATE repositories SET package_name=?, package_version=?,
+    dependencies_json=?,package_public_surface_json=?,kind=?,index_status=?
+    WHERE id=?`).run(
+    prepared.packageFacts.packageName,
+    prepared.packageFacts.packageVersion,
+    JSON.stringify(prepared.packageFacts.dependencies),
+    JSON.stringify(prepared.packagePublicSurface),
+    prepared.kind,
+    'indexing',
+    repoId,
+  );
   clearRepoFacts(db, repoId);
   insertRequires(db, repoId, prepared.packageFacts.cdsRequires);
   const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
@@ -123,10 +185,58 @@ export function publishPreparedRepositoryIndex(db: Db, prepared: PreparedReposit
   insertCalls(db, repoId, prepared.parsed.calls);
   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);
 }
+
+export type RepositoryPublicationOutcome =
+  | { ok: true }
+  | { ok: false; error: unknown };
+
+export function publishOneRepository(
+  db: Db,
+  prepared: PreparedRepositoryIndex,
+  invalidations: PackageInvalidationBatch,
+): RepositoryPublicationOutcome {
+  try {
+    db.transaction(() => withPublicationSavepoint(
+      db,
+      prepared.repo.id,
+      () => publishPreparedRepositoryIndex(db, prepared, invalidations),
+    ));
+    return { ok: true };
+  } catch (error) {
+    recordIndexFailure(db, prepared.repo.id, error);
+    return { ok: false, error };
+  }
+}
+
+function withPublicationSavepoint<T>(
+  db: Db,
+  repoId: number,
+  publish: () => T,
+): T {
+  const name = `service_flow_repository_${repoId}`;
+  db.exec(`SAVEPOINT ${name}`);
+  try {
+    const result = publish();
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    return result;
+  } catch (error) {
+    db.exec(`ROLLBACK TO SAVEPOINT ${name}`);
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    throw error;
+  }
+}
+
 export function recordIndexFailure(db: Db, repoId: number, error: unknown): void {
+  if (isPreparedRepositorySnapshotError(error)) {
+    recordPreparedSnapshotFailure(db, repoId, error);
+    return;
+  }
   const message = errorMessage(error);
   db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
-  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare(`DELETE FROM diagnostics WHERE repo_id=? AND (
+    code IN ('index_failed_snapshot_preserved','source_read_failed')
+    OR code GLOB 'invalid_prepared_repository_snapshot:*'
+  )`).run(repoId);
   db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repoId, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
 }
 async function parseAllSourceFacts(
@@ -139,13 +249,25 @@ async function parseAllSourceFacts(
     facts.fileRecords.push({ relativePath: normalizePath(file), extension: path.extname(file), sha256: sha256Text(snapshot.text), 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.handlers.push(...(await parseDecorators(root, file, sources)));
       facts.registrations.push(...(await parseHandlerRegistrations(root, file, sources)));
-      facts.bindings.push(...(await parseServiceBindings(root, file, sources)));
-      const symbolFacts = await parseExecutableSymbols(root, file, sources);
-      facts.symbols.push(...symbolFacts.symbols);
-      facts.symbolCalls.push(...symbolFacts.calls);
-      facts.calls.push(...(await parseOutboundCalls(root, file, sources)));
+      const bindings = await parseServiceBindings(root, file, sources);
+      const symbolFacts = await parseExecutableSymbols(
+        root, file, sources, classified,
+      );
+      const outboundCalls = await parseOutboundCalls(
+        root, file, sources, classified, bindings,
+      );
+      const reconciled = reconcileSourceFacts(
+        source, classified, bindings, outboundCalls,
+        symbolFacts.symbols, symbolFacts.calls,
+      );
+      facts.bindings.push(...reconciled.bindings);
+      facts.symbols.push(...reconciled.symbols);
+      facts.symbolCalls.push(...reconciled.symbolCalls);
+      facts.calls.push(...reconciled.outboundCalls);
     }
   }
   return facts;

package/src/indexer/workspace-indexer.ts

@@ -1,8 +1,23 @@
 import type { Db } from '../db/connection.js';
 import { listRepositories, reposByName } from '../db/repositories.js';
 import { errorMessage } from '../utils/diagnostics.js';
-import { prepareRepositoryIndex, publishPreparedRepositoryIndex, recordIndexFailure, type PreparedRepositoryIndex } from './repository-indexer.js';
+import {
+  prepareRepositoryIndex,
+  publishOneRepository,
+  recordIndexFailure,
+  type PreparedRepositoryIndex,
+} from './repository-indexer.js';
 import { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
+import {
+  createPackageInvalidationBatch,
+  finalizePackageTargetInvalidations,
+  mergePackageInvalidationEffects,
+  type PackageInvalidationBatch,
+} from '../db/004-package-target-invalidation.js';
+import {
+  isPreparedRepositorySnapshotError,
+} from '../db/013-index-publication-failure.js';
+import { binaryCompare } from '../parsers/004-fact-identity.js';
 // Ownerless rows predate PID coordination; this matches doctor's stale-run threshold without taking over a recent legacy writer.
 const LEGACY_OWNER_RECOVERY_MS = 60 * 60 * 1_000;
 type RunningIndexRow = Record<string, unknown>;
@@ -76,46 +91,234 @@ export function claimIndexRun(
     throw error;
   }
 }
+export interface IndexWorkspaceSummary {
+  repoCount: number;
+  indexedCount: number;
+  skippedCount: number;
+  failedCount: number;
+  failedRepos: Array<{ name: string; code: string }>;
+  fileCount: number;
+  diagnosticCount: number;
+}
+
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
   options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
-): Promise<{ repoCount: number; indexedCount: number; skippedCount: number; fileCount: number; diagnosticCount: number }> {
-  const repos = options.repo
-    ? reposByName(db, options.repo, workspaceId)
-    : listRepositories(db, workspaceId);
-  if (options.repo && repos.length === 0)
-    throw new Error(`selector_repo_not_found: no indexed repository matched ${options.repo}.`);
-  if (options.repo && repos.length > 1)
-    throw new Error(`selector_repo_ambiguous: repository selector ${options.repo} matched ${repos.length} repositories; use a unique repository name.`);
+): Promise<IndexWorkspaceSummary> {
+  const repos = selectedRepositories(db, workspaceId, options.repo);
   const runId = claimIndexRun(db, workspaceId, repos.length);
-  let fileCount = 0;
-  let diagnosticCount = 0;
-  let skippedCount = 0;
-  const preparedRows: PreparedRepositoryIndex[] = [];
-  let activeRepoId: number | undefined;
+  const state: PreparationState = {
+    fileCount: 0, diagnosticCount: 0, skippedCount: 0, rows: [],
+  };
   try {
-    for (const repo of repos) {
-      activeRepoId = repo.id;
-      const result = await prepareRepositoryIndex(repo, options.force);
-      preparedRows.push(result);
-      fileCount += result.fileCount;
-      diagnosticCount += result.diagnosticCount;
-      skippedCount += result.skipped ? 1 : 0;
-    }
-    db.transaction(() => {
-      for (const row of preparedRows) {
-        activeRepoId = row.repo.id;
-        publishPreparedRepositoryIndex(db, row);
-      }
-      if (options.injectDerivedMaterializationFailure) throw new Error('Injected derived materialization failure');
-      materializeCdsExtensionOperations(db, workspaceId);
-      db.prepare("UPDATE index_runs SET finished_at=?, status='success', file_count=?, diagnostic_count=? WHERE id=?").run(new Date().toISOString(), fileCount, diagnosticCount, runId);
-    });
-    return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
+    await prepareRepositories(repos, options.force, state);
+    return publishPreparedWorkspaceRows(
+      db, workspaceId, runId, state.rows, options,
+    );
   } catch (error) {
-    db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run(new Date().toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
-    if (activeRepoId && preparedRows.length < repos.length) recordIndexFailure(db, activeRepoId, error);
+    finishFailedRun(db, runId, state, error);
+    if (state.activeRepoId && state.rows.length < repos.length)
+      recordIndexFailure(db, state.activeRepoId, error);
     throw error;
   }
 }
+
+type IndexRepository = ReturnType<typeof listRepositories>[number];
+interface PreparationState {
+  fileCount: number;
+  diagnosticCount: number;
+  skippedCount: number;
+  rows: PreparedRepositoryIndex[];
+  activeRepoId?: number;
+}
+
+interface PublicationState {
+  fileCount: number;
+  diagnosticCount: number;
+  skippedCount: number;
+  indexedCount: number;
+  publicationFailureCount: number;
+  failedRepoIds: Set<number>;
+  failedRepos: Array<{ name: string; code: string }>;
+  rows: readonly PreparedRepositoryIndex[];
+  activeRepoId?: number;
+}
+
+function selectedRepositories(
+  db: Db,
+  workspaceId: number,
+  repoName: string | undefined,
+): IndexRepository[] {
+  const repos = repoName
+    ? reposByName(db, repoName, workspaceId)
+    : listRepositories(db, workspaceId);
+  if (repoName && repos.length === 0)
+    throw new Error(
+      `selector_repo_not_found: no indexed repository matched ${repoName}.`,
+    );
+  if (repoName && repos.length > 1)
+    throw new Error(
+      `selector_repo_ambiguous: repository selector ${repoName} matched ${repos.length} repositories; use a unique repository name.`,
+    );
+  return repos;
+}
+
+async function prepareRepositories(
+  repos: readonly IndexRepository[],
+  force: boolean,
+  state: PreparationState,
+): Promise<void> {
+  for (const repo of repos) {
+    state.activeRepoId = repo.id;
+    const result = await prepareRepositoryIndex(repo, force);
+    state.rows.push(result);
+    state.fileCount += result.fileCount;
+    state.diagnosticCount += result.diagnosticCount;
+    state.skippedCount += result.skipped ? 1 : 0;
+  }
+}
+
+export function publishPreparedWorkspaceRows(
+  db: Db,
+  workspaceId: number,
+  runId: number,
+  rows: readonly PreparedRepositoryIndex[],
+  options: { injectDerivedMaterializationFailure?: boolean } = {},
+): IndexWorkspaceSummary {
+  const state = publicationState(rows);
+  db.transaction(() => {
+    const effects = createPackageInvalidationBatch([]);
+    const publishedRepoIds: number[] = [];
+    for (const row of state.rows) {
+      state.activeRepoId = row.repo.id;
+      if (row.skipped) continue;
+      const result = publishPreparedRow(db, row);
+      if (result.status === 'failed') {
+        recordPublicationFailure(db, state, row, result.error);
+        continue;
+      }
+      state.indexedCount += 1;
+      publishedRepoIds.push(row.repo.id);
+      mergePackageInvalidationEffects(effects, result.effects);
+    }
+    if (options.injectDerivedMaterializationFailure)
+      throw new Error('Injected derived materialization failure');
+    materializeCdsExtensionOperations(
+      db, workspaceId, state.failedRepoIds,
+    );
+    const invalidations = createPackageInvalidationBatch(publishedRepoIds);
+    mergePackageInvalidationEffects(invalidations, effects);
+    finalizePackageTargetInvalidations(db, invalidations);
+    finishCompletedRun(db, runId, state);
+  });
+  return indexSummary(rows.length, state);
+}
+
+function publicationState(
+  rows: readonly PreparedRepositoryIndex[],
+): PublicationState {
+  return {
+    rows,
+    fileCount: rows.reduce((total, row) => total + row.fileCount, 0),
+    diagnosticCount: rows.reduce(
+      (total, row) => total + row.diagnosticCount, 0,
+    ),
+    skippedCount: rows.filter((row) => row.skipped).length,
+    indexedCount: 0,
+    publicationFailureCount: 0,
+    failedRepoIds: new Set(),
+    failedRepos: [],
+  };
+}
+
+type PublicationResult =
+  | { status: 'published'; effects: PackageInvalidationBatch }
+  | { status: 'failed'; error: unknown };
+
+function publishPreparedRow(
+  db: Db,
+  row: PreparedRepositoryIndex,
+): PublicationResult {
+  const effects = createPackageInvalidationBatch([row.repo.id]);
+  const outcome = publishOneRepository(db, row, effects);
+  if (!outcome.ok && !isPreparedRepositorySnapshotError(outcome.error))
+    throw outcome.error;
+  return outcome.ok
+    ? { status: 'published', effects }
+    : { status: 'failed', error: outcome.error };
+}
+
+function recordPublicationFailure(
+  db: Db,
+  state: PublicationState,
+  row: PreparedRepositoryIndex,
+  error: unknown,
+): void {
+  state.failedRepoIds.add(row.repo.id);
+  state.failedRepos.push({
+    name: row.repo.name,
+    code: isPreparedRepositorySnapshotError(error)
+      ? error.message : 'source_read_failed',
+  });
+  state.publicationFailureCount += 1;
+}
+
+function finishCompletedRun(
+  db: Db,
+  runId: number,
+  state: PublicationState,
+): void {
+  const status = completedRunStatus(
+    state.rows.length, state.publicationFailureCount,
+  );
+  const error = status === 'success' ? null
+    : `${state.publicationFailureCount} repositories failed index publication.`;
+  db.prepare(`UPDATE index_runs SET finished_at=?,status=?,
+    file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
+    new Date().toISOString(), status, state.fileCount,
+    completedDiagnosticCount(state), error, runId,
+  );
+}
+
+function completedRunStatus(
+  repoCount: number,
+  failedCount: number,
+): 'success' | 'partial_failure' | 'failed' {
+  if (failedCount === 0) return 'success';
+  return failedCount === repoCount ? 'failed' : 'partial_failure';
+}
+
+function completedDiagnosticCount(state: PublicationState): number {
+  return state.diagnosticCount + state.publicationFailureCount;
+}
+
+function finishFailedRun(
+  db: Db,
+  runId: number,
+  state: PreparationState,
+  error: unknown,
+): void {
+  db.prepare(`UPDATE index_runs SET finished_at=?,status='failed',
+    file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
+    new Date().toISOString(), state.fileCount, state.diagnosticCount + 1,
+    errorMessage(error), runId,
+  );
+}
+
+function indexSummary(
+  repoCount: number,
+  state: PublicationState,
+): IndexWorkspaceSummary {
+  return {
+    repoCount,
+    indexedCount: state.indexedCount,
+    skippedCount: state.skippedCount,
+    failedCount: state.publicationFailureCount,
+    failedRepos: [...state.failedRepos].sort((left, right) =>
+      binaryCompare(left.name, right.name)
+      || binaryCompare(left.code, right.code)),
+    fileCount: state.fileCount,
+    diagnosticCount: completedDiagnosticCount(state),
+  };
+}