@saptools/service-flow 0.1.68 → 0.1.70

package/src/db/{000-call-fact-repository.ts → call-fact-repository.ts}

@@ -3,19 +3,25 @@ import {
   selectCallOwner,
   type OwnerCandidate,
   type OwnerSelection,
-} from '../parsers/004-fact-identity.js';
+} from '../parsers/fact-identity.js';
 import type { Db, Statement } from './connection.js';
 import {
   resolveRelativeSymbolCall,
-} from './006-relative-symbol-resolution.js';
+} from './relative-symbol-resolution.js';
 import {
   parsePackageImportReference,
-} from '../parsers/012-package-fact-contract.js';
+} from '../parsers/package-fact-contract.js';
 import {
   resolvedBindingReferenceProofValid,
   type BindingProofCall,
   type BindingProofTarget,
-} from './012-binding-reference-proof.js';
+} from './binding-reference-proof.js';
+import {
+  preparedCallSnapshotError,
+} from './index-publication-failure.js';
+import {
+  hasSingleHopHelperReturn,
+} from './binding-helper-provenance.js';
 
 export function insertSymbolCalls(db: Db, repoId: number, rows: SymbolCallFact[]): void {
   const insertStmt = db.prepare('INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,call_site_start_offset,call_site_end_offset,call_role,status,confidence,evidence_json,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)');
@@ -58,8 +64,8 @@ function assertImportProvenance(call: SymbolCallFact): void {
   const direct = directPackageProvenanceValid(call);
   const derived = derivedPackageProvenanceValid(call);
   if (!direct && !derived)
-    throw new Error(
-      'invalid_prepared_repository_snapshot:package_import_provenance_missing',
+    throw preparedCallSnapshotError(
+      'package_import_provenance_missing', 'symbol_call', call,
     );
 }
 
@@ -156,7 +162,9 @@ function requiredSymbolCallOwnerId(
   );
   if (selected.status !== 'resolved'
     || selected.owner?.qualifiedName !== call.callerQualifiedName)
-    throw new Error('invalid_prepared_repository_snapshot:symbol_call_owner_mismatch');
+    throw preparedCallSnapshotError(
+      'symbol_call_owner_mismatch', 'symbol_call', call,
+    );
   return selected.owner.id;
 }
 
@@ -265,9 +273,11 @@ function exportedSymbolRows(db: Db, repoId: number, r: SymbolCallFact): SymbolTa
   ));
 }
 
-function isRelativeImportedSymbolCall(r: SymbolCallFact): boolean {
-  return Boolean(r.importSource?.startsWith('.'));
-}
+const sameFileEligibleRelations = new Set([
+  'indexed_local_symbol',
+  'indexed_local_symbol_unproven',
+  'indexed_this_method',
+]);
 
 function eligibleSymbolResolution(
   rows: SymbolTargetRow[],
@@ -292,8 +302,7 @@ function sameFileResolution(
   r: SymbolCallFact,
   relation: unknown,
 ): SymbolCallResolution | undefined {
-  if (isRelativeImportedSymbolCall(r) || relation === 'package_import')
-    return undefined;
+  if (!sameFileEligibleRelations.has(String(relation))) return undefined;
   if (relation === 'indexed_local_symbol_unproven')
     return unresolvedSymbol(
       'exact_symbol_match', 'no_local_symbol_target', 0,
@@ -452,6 +461,7 @@ interface PersistedBinding {
   ownerResolution: string;
   ownerStartOffset: number | null;
   ownerEndOffset: number | null;
+  singleHopHelperReturn: boolean;
 }
 
 function outboundOwnerId(
@@ -471,13 +481,18 @@ function outboundOwnerId(
   );
   const resolution = call.evidence?.sourceOwnerResolution;
   if (resolution === 'ownerless_file_scope')
-    return ownerlessOutboundOwner(selected.status);
+    return ownerlessOutboundOwner(call, selected.status);
   return ownedOutboundOwner(call, resolution, selected);
 }
 
-function ownerlessOutboundOwner(status: string): null {
+function ownerlessOutboundOwner(
+  call: OutboundCallFact,
+  status: string,
+): null {
   if (status !== 'none')
-    throw new Error('invalid_prepared_repository_snapshot:outbound_owner_mismatch');
+    throw preparedCallSnapshotError(
+      'outbound_owner_mismatch', 'outbound_call', call,
+    );
   return null;
 }
 
@@ -488,10 +503,14 @@ function ownedOutboundOwner(
 ): number {
   if (resolution !== 'owned_exact' || selected.status !== 'resolved'
     || selected.owner?.qualifiedName !== call.sourceSymbolQualifiedName)
-    throw new Error('invalid_prepared_repository_snapshot:outbound_owner_mismatch');
+    throw preparedCallSnapshotError(
+      'outbound_owner_mismatch', 'outbound_call', call,
+    );
   const owner = selected.owner;
   if (!owner)
-    throw new Error('invalid_prepared_repository_snapshot:outbound_owner_mismatch');
+    throw preparedCallSnapshotError(
+      'outbound_owner_mismatch', 'outbound_call', call,
+    );
   return owner.id;
 }
 
@@ -506,14 +525,18 @@ function resolvePersistedBinding(
 } {
   const reference = call.serviceBindingReference;
   if (!reference)
-    throw new Error('invalid_prepared_repository_snapshot:binding_reference_missing');
+    throw preparedCallSnapshotError(
+      'binding_reference_missing', 'outbound_call', call,
+    );
   if (reference.status !== 'resolved_exact')
     return unresolvedBinding(reference);
   const candidates = exactBindingRows(db, repoId, reference);
   const selected = candidates[0];
   if (candidates.length !== 1 || !selected
     || selected.variableName !== call.serviceVariableName)
-    throw new Error('invalid_prepared_repository_snapshot:binding_reference_mismatch');
+    throw preparedCallSnapshotError(
+      'binding_reference_mismatch', 'outbound_call', call,
+    );
   assertResolvedBindingProof(repoId, call, selected, reference);
   return {
     bindingId: selected.id,
@@ -533,8 +556,8 @@ function bindingProofCall(
 ): BindingProofCall {
   if (call.callSiteStartOffset === undefined
     || call.callSiteEndOffset === undefined)
-    throw new Error(
-      'invalid_prepared_repository_snapshot:binding_lexical_proof_invalid',
+    throw preparedCallSnapshotError(
+      'binding_lexical_proof_invalid', 'outbound_call', call,
     );
   return {
     repoId,
@@ -561,6 +584,7 @@ function bindingProofTarget(
     ownerResolution: binding.ownerResolution,
     ownerStartOffset: binding.ownerStartOffset,
     ownerEndOffset: binding.ownerEndOffset,
+    singleHopHelperReturn: binding.singleHopHelperReturn,
   };
 }
 
@@ -576,8 +600,8 @@ function assertResolvedBindingProof(
     bindingProofTarget(repoId, binding),
   );
   if (!valid)
-    throw new Error(
-      'invalid_prepared_repository_snapshot:binding_lexical_proof_invalid',
+    throw preparedCallSnapshotError(
+      'binding_lexical_proof_invalid', 'outbound_call', call,
     );
 }
 
@@ -608,6 +632,7 @@ function exactBindingRows(
     binding.binding_site_start_offset siteStart,
     binding.binding_site_end_offset siteEnd,
     binding.owner_resolution ownerResolution,
+    binding.helper_chain_json helperChainJson,
     owner.start_offset ownerStartOffset,owner.end_offset ownerEndOffset
     FROM service_bindings binding
     LEFT JOIN symbols owner ON owner.id=binding.symbol_id
@@ -642,6 +667,7 @@ function persistedBindingRow(
     ownerResolution: row.ownerResolution,
     ownerStartOffset,
     ownerEndOffset,
+    singleHopHelperReturn: hasSingleHopHelperReturn(row.helperChainJson),
   }];
 }
 

package/src/db/{003-current-fact-semantics.ts → current-fact-semantics.ts}

@@ -3,16 +3,16 @@ import type { CallType, RepoKind } from '../types.js';
 import { ANALYZER_VERSION } from '../version.js';
 import {
   invalidPackageFactCategories,
-} from './007-package-fact-semantics.js';
+} from './package-fact-semantics.js';
 import {
   invalidRelativeFactCategories,
-} from './008-relative-fact-semantics.js';
+} from './relative-fact-semantics.js';
 import {
   invalidBindingFactCategories,
-} from './009-binding-fact-semantics.js';
+} from './binding-fact-semantics.js';
 import {
   invalidSymbolFactCategories,
-} from './011-symbol-call-semantics.js';
+} from './symbol-call-semantics.js';
 
 export type PackageFactPhase = 'pre_package' | 'terminal';
 
@@ -71,6 +71,7 @@ const symbolReasons = [
   'relative_import_type_only',
   'relative_import_module_resolution_ambiguous',
   'relative_import_requested_module_has_no_executable_body',
+  'relative_import_proxy_alias_targets_package_unsupported',
   'relative_import_requested_module_has_no_target',
   'multiple_relative_class_targets_in_requested_module',
   'multiple_namespace_targets_in_requested_module',

package/src/db/{001-fact-lifecycle.ts → fact-lifecycle.ts}

@@ -3,16 +3,16 @@ import { CURRENT_SCHEMA_VERSION, schemaVersion } from './migrations.js';
 import {
   invalidFactJsonCategories,
   type FactJsonCategoryCount,
-} from './002-fact-json-inventory.js';
+} from './fact-json-inventory.js';
 import {
   invalidFactSemanticCategories,
   type FactSemanticCategoryCount,
   type PackageFactPhase,
-} from './003-current-fact-semantics.js';
+} from './current-fact-semantics.js';
 import {
   invalidSchemaStructureCategories,
   type SchemaStructureCategoryCount,
-} from './005-schema-structure.js';
+} from './schema-structure.js';
 import { ANALYZER_VERSION } from '../version.js';
 
 export type FactLifecycleCode =

package/src/db/index-publication-failure.ts

@@ -0,0 +1,91 @@
+import type { Db } from './connection.js';
+
+export type PreparedRepositoryFactKind =
+  | 'outbound_call'
+  | 'service_binding'
+  | 'symbol_call';
+
+export type PreparedSnapshotFailureCode =
+  | 'binding_lexical_proof_invalid'
+  | 'binding_owner_mismatch'
+  | 'binding_reference_mismatch'
+  | 'binding_reference_missing'
+  | 'binding_site_missing'
+  | 'duplicate_service_binding_site'
+  | 'outbound_owner_mismatch'
+  | 'package_import_provenance_missing'
+  | 'symbol_call_owner_mismatch';
+
+export interface PreparedSnapshotFailureSite {
+  factKind: PreparedRepositoryFactKind;
+  sourceFile?: string;
+  sourceLine?: number;
+  callSiteStartOffset?: number;
+  callSiteEndOffset?: number;
+}
+
+export class PreparedRepositorySnapshotError extends Error {
+  readonly failureCode: PreparedSnapshotFailureCode;
+  readonly site: PreparedSnapshotFailureSite;
+
+  constructor(
+    failureCode: PreparedSnapshotFailureCode,
+    site: PreparedSnapshotFailureSite,
+  ) {
+    super(`invalid_prepared_repository_snapshot:${failureCode}`);
+    this.name = 'PreparedRepositorySnapshotError';
+    this.failureCode = failureCode;
+    this.site = site;
+  }
+}
+
+interface PreparedCallSite {
+  sourceFile: string;
+  sourceLine: number;
+  callSiteStartOffset?: number;
+  callSiteEndOffset?: number;
+}
+
+export function preparedCallSnapshotError(
+  failureCode: PreparedSnapshotFailureCode,
+  factKind: 'outbound_call' | 'symbol_call',
+  call: PreparedCallSite,
+): PreparedRepositorySnapshotError {
+  return new PreparedRepositorySnapshotError(failureCode, {
+    factKind,
+    sourceFile: call.sourceFile,
+    sourceLine: call.sourceLine,
+    callSiteStartOffset: call.callSiteStartOffset,
+    callSiteEndOffset: call.callSiteEndOffset,
+  });
+}
+
+export function isPreparedRepositorySnapshotError(
+  error: unknown,
+): error is PreparedRepositorySnapshotError {
+  return error instanceof PreparedRepositorySnapshotError;
+}
+
+export function recordPreparedSnapshotFailure(
+  db: Db,
+  repoId: number,
+  error: PreparedRepositorySnapshotError,
+): void {
+  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')
+    OR code GLOB 'invalid_prepared_repository_snapshot:*'
+  )`).run(repoId);
+  db.prepare(`INSERT INTO diagnostics(
+    repo_id,severity,code,message,source_file,source_line
+  ) VALUES(?,?,?,?,?,?)`).run(
+    repoId,
+    'error',
+    error.message,
+    'Index publication failed before commit for this repository; previous facts and fingerprint were preserved. '
+      + `factKind=${error.site.factKind}`,
+    error.site.sourceFile,
+    error.site.sourceLine,
+  );
+}

package/src/db/{007-package-fact-semantics.ts → package-fact-semantics.ts}

@@ -4,21 +4,21 @@ import type {
   PackagePublicScope,
   PackagePublicSurfaceFact,
   PublicSurfaceTarget,
-} from '../parsers/003-package-public-surface.js';
+} from '../parsers/package-public-surface.js';
 import {
   parsePackageImportReference,
   parsePackagePublicSurfaceFact,
-} from '../parsers/012-package-fact-contract.js';
+} from '../parsers/package-fact-contract.js';
 import type { SymbolImportReference } from
-  '../parsers/002-symbol-import-bindings.js';
-import type { PackageFactPhase } from './003-current-fact-semantics.js';
+  '../parsers/symbol-import-bindings.js';
+import type { PackageFactPhase } from './current-fact-semantics.js';
 import {
   expectedPackageImportResolutions,
   type PackageCallResolution,
-} from '../linker/003-package-import-symbol-resolver.js';
+} from '../linker/package-import-symbol-resolver.js';
 import {
   invalidPackageSymbolSurfaceCount,
-} from './010-package-symbol-surface-semantics.js';
+} from './package-symbol-surface-semantics.js';
 
 export interface PackageFactCategoryCount {
   category: string;

package/src/db/{010-package-symbol-surface-semantics.ts → package-symbol-surface-semantics.ts}

@@ -6,10 +6,10 @@ import {
   type PackagePublicScope,
   type PackagePublicSurfaceFact,
   type PublicSurfaceTarget,
-} from '../parsers/003-package-public-surface.js';
+} from '../parsers/package-public-surface.js';
 import {
   parsePackagePublicSurfaceFact,
-} from '../parsers/012-package-fact-contract.js';
+} from '../parsers/package-fact-contract.js';
 import type { Db } from './connection.js';
 
 interface Exposure {

package/src/db/{004-package-target-invalidation.ts → package-target-invalidation.ts}

@@ -2,7 +2,7 @@ import type { Db } from './connection.js';
 import { ANALYZER_VERSION } from '../version.js';
 import {
   parsePackageImportReference,
-} from '../parsers/012-package-fact-contract.js';
+} from '../parsers/package-fact-contract.js';
 
 interface PackageCallRow {
   id: number;
@@ -157,6 +157,16 @@ export function createPackageInvalidationBatch(
   };
 }
 
+export function mergePackageInvalidationEffects(
+  target: PackageInvalidationBatch,
+  source: PackageInvalidationBatch,
+): void {
+  for (const repoId of source.affectedCallerRepoIds)
+    target.affectedCallerRepoIds.add(repoId);
+  for (const workspaceId of source.affectedWorkspaceIds)
+    target.affectedWorkspaceIds.add(workspaceId);
+}
+
 export function finalizePackageTargetInvalidations(
   db: Db,
   batch: PackageInvalidationBatch,

package/src/db/{008-relative-fact-semantics.ts → relative-fact-semantics.ts}

@@ -2,12 +2,12 @@ import type { Db } from './connection.js';
 import { ANALYZER_VERSION } from '../version.js';
 import {
   resolveRelativeSymbolCall,
-} from './006-relative-symbol-resolution.js';
+} from './relative-symbol-resolution.js';
 import type { SymbolCallFact } from '../types.js';
 import { parseRelativeImportReference } from
-  '../parsers/012-package-fact-contract.js';
+  '../parsers/package-fact-contract.js';
 import type { SymbolImportReference } from
-  '../parsers/002-symbol-import-bindings.js';
+  '../parsers/symbol-import-bindings.js';
 
 export interface RelativeFactCategoryCount {
   category: string;
@@ -81,9 +81,12 @@ function derivedRelativeProvenance(
   targetName: string,
 ): boolean {
   if (!memberReference(binding)) return false;
-  if (evidence.relation === 'class_instance_method')
-    return targetName === binding.requestedPublicName
-      && evidence.methodName === binding.referencedMemberName;
+  if (evidence.relation === 'class_instance_method') {
+    if (evidence.methodName !== binding.referencedMemberName) return false;
+    return binding.bindingKind === 'esm_default'
+      ? targetName === `${binding.localName}.${binding.referencedMemberName}`
+      : targetName === binding.requestedPublicName;
+  }
   if (evidence.relation !== 'relative_import_proxy_member') return false;
   return targetName === binding.referencedMemberName
     && typeof evidence.proxyVariableName === 'string';

package/src/db/{006-relative-symbol-resolution.ts → relative-symbol-resolution.ts}

@@ -1,5 +1,7 @@
 import { posix } from 'node:path';
 import type { SymbolCallFact } from '../types.js';
+import { packageModuleRequest } from
+  '../parsers/symbol-import-bindings.js';
 import type { Db } from './connection.js';
 
 export interface RelativeSymbolCallResolution {
@@ -33,6 +35,7 @@ interface MappingTarget {
 interface MappedExecutableRows {
   rows: TargetRow[];
   ambiguous: boolean;
+  packageTargetUnsupported: boolean;
 }
 
 const stripExtension = (value: string): string =>
@@ -138,8 +141,12 @@ function handlerMemberPubliclyCarried(
 ): boolean {
   if (row.exported) return true;
   const evidence = parsedRecord(row.evidenceJson);
-  return evidence?.source === 'exported_class_instance_member'
-    && evidence.exportedClass === binding.importedName;
+  if (evidence?.source !== 'exported_class_instance_member') return false;
+  const exportKind = evidence.exportedClassExportKind;
+  if (exportKind !== 'default' && exportKind !== 'named') return false;
+  return binding.bindingKind === 'esm_default'
+    ? exportKind === 'default'
+    : evidence.exportedClass === binding.importedName;
 }
 
 function requiresPublicClassMember(
@@ -287,9 +294,12 @@ function mappingTargetScope(
 ): RelativeModuleScope | undefined {
   const target = mappingTarget(row);
   if (!target) return undefined;
-  return target.specifier
-    ? relativeModuleScope(db, repoId, row.sourceFile, target.specifier)
-    : { paths: new Set([stripExtension(row.sourceFile)]), ambiguous: false };
+  if (!target.specifier)
+    return {
+      paths: new Set([stripExtension(row.sourceFile)]), ambiguous: false,
+    };
+  if (packageModuleRequest(target.specifier)) return undefined;
+  return relativeModuleScope(db, repoId, row.sourceFile, target.specifier);
 }
 
 function mappedExecutableRows(
@@ -298,18 +308,24 @@ function mappedExecutableRows(
   rows: readonly TargetRow[],
   aliases: readonly TargetRow[],
 ): MappedExecutableRows {
+  const packageTargetUnsupported = aliases.some((alias) => {
+    const target = mappingTarget(alias);
+    return Boolean(target?.specifier && packageModuleRequest(target.specifier));
+  });
   const scopes = aliases.flatMap((alias) => {
     const scope = mappingTargetScope(db, repoId, alias);
     return scope ? [scope] : [];
   });
   if (scopes.some((scope) => scope.ambiguous))
-    return { rows: [], ambiguous: true };
+    return { rows: [], ambiguous: true, packageTargetUnsupported };
   const mapped = scopes.flatMap((scope) => {
     return rows.filter((row) =>
       row.kind !== 'object_alias' && bodyEligible(row)
       && scope.paths.has(stripExtension(row.sourceFile)));
   });
-  return { rows: uniqueRows(mapped), ambiguous: false };
+  return {
+    rows: uniqueRows(mapped), ambiguous: false, packageTargetUnsupported,
+  };
 }
 
 function proxyResolution(
@@ -326,6 +342,11 @@ function proxyResolution(
     'relative_import_module_resolution_ambiguous',
     rows.length, 0, false,
   );
+  if (mapped.packageTargetUnsupported) return unresolved(
+    'proxy_member_exported_object_map',
+    'relative_import_proxy_alias_targets_package_unsupported',
+    rows.length,
+  );
   const direct = scoped.filter((row) =>
     row.kind !== 'object_alias' && row.exported && bodyEligible(row));
   const eligible = uniqueRows([

package/src/db/repositories.ts

@@ -11,7 +11,11 @@ import type {
 import {
   selectCallOwner,
   type OwnerCandidate,
-} from '../parsers/004-fact-identity.js';
+} from '../parsers/fact-identity.js';
+import {
+  PreparedRepositorySnapshotError,
+  type PreparedSnapshotFailureCode,
+} from './index-publication-failure.js';
 export interface RepoRow {
   id: number;
   name: string;
@@ -414,6 +418,19 @@ interface PersistedOwnerCandidate extends OwnerCandidate {
   id: number;
 }
 
+function bindingSnapshotError(
+  failureCode: PreparedSnapshotFailureCode,
+  fact: ServiceBindingFact,
+): PreparedRepositorySnapshotError {
+  return new PreparedRepositorySnapshotError(failureCode, {
+    factKind: 'service_binding',
+    sourceFile: fact.sourceFile,
+    sourceLine: fact.sourceLine,
+    callSiteStartOffset: fact.bindingSiteStartOffset,
+    callSiteEndOffset: fact.bindingSiteEndOffset,
+  });
+}
+
 function persistedOwnerCandidates(
   db: Db,
   repoId: number,
@@ -454,16 +471,16 @@ function bindingOwnerId(
   );
   if (fact.ownerResolution === 'ownerless_file_scope') {
     if (selected.status !== 'none')
-      throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+      throw bindingSnapshotError('binding_owner_mismatch', fact);
     return null;
   }
   if (fact.ownerResolution !== 'owned_exact'
     || selected.status !== 'resolved'
     || selected.owner?.qualifiedName !== fact.sourceSymbolQualifiedName)
-    throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+    throw bindingSnapshotError('binding_owner_mismatch', fact);
   const owner = selected.owner;
   if (!owner)
-    throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+    throw bindingSnapshotError('binding_owner_mismatch', fact);
   return owner.id;
 }
 
@@ -474,13 +491,13 @@ function assertUniquePreparedBindingSites(
   for (const row of rows) {
     if (row.bindingSiteStartOffset === undefined
       || row.bindingSiteEndOffset === undefined)
-      throw new Error('invalid_prepared_repository_snapshot:binding_site_missing');
+      throw bindingSnapshotError('binding_site_missing', row);
     const key = [
       row.sourceFile, row.variableName,
       row.bindingSiteStartOffset, row.bindingSiteEndOffset,
     ].join('\u0000');
     if (seen.has(key))
-      throw new Error('invalid_prepared_repository_snapshot:duplicate_service_binding_site');
+      throw bindingSnapshotError('duplicate_service_binding_site', row);
     seen.add(key);
   }
 }
@@ -488,4 +505,4 @@ export function insertExecutableSymbols(db: Db, repoId: number, rows: Executable
   const stmt = db.prepare('INSERT INTO symbols(repo_id,file_id,kind,name,qualified_name,exported,start_line,end_line,start_offset,end_offset,source_file,exported_name,evidence_json) VALUES(?,(SELECT id FROM files WHERE repo_id=? AND relative_path=?),?,?,?,?,?,?,?,?,?,?,?)');
   for (const r of rows) stmt.run(repoId, repoId, r.sourceFile, r.kind, r.localName, r.qualifiedName, r.exported ? 1 : 0, r.startLine, r.endLine, r.startOffset, r.endOffset, r.sourceFile, r.exportedName, r.importExportEvidence ? JSON.stringify(r.importExportEvidence) : null);
 }
-export { insertCalls, insertSymbolCalls } from './000-call-fact-repository.js';
+export { insertCalls, insertSymbolCalls } from './call-fact-repository.js';

package/src/db/{011-symbol-call-semantics.ts → symbol-call-semantics.ts}

@@ -1,6 +1,6 @@
 import type { SymbolCallFact } from '../types.js';
 import { ANALYZER_VERSION } from '../version.js';
-import { resolveSymbolCallTarget } from './000-call-fact-repository.js';
+import { resolveSymbolCallTarget } from './call-fact-repository.js';
 import type { Db } from './connection.js';
 
 export interface SymbolFactCategoryCount {

package/src/index.ts

@@ -13,8 +13,8 @@ export { trace } from './trace/trace-engine.js';
 export {
   compactTrace,
   traceAndCompact,
-} from './trace/018-compact-trace.js';
-export type { CompactTraceExecution } from './trace/018-compact-trace.js';
+} from './trace/compact-trace.js';
+export type { CompactTraceExecution } from './trace/compact-trace.js';
 export type {
   CompactDecisionV1,
   CompactDiagnosticDetailsV1,
@@ -31,7 +31,7 @@ export type {
   CompactStartV1,
   CompactStatus,
   CompactStatusCountsV1,
-} from './trace/014-compact-contract.js';
+} from './trace/compact-contract.js';
 export { parseImplementationHint } from './trace/implementation-hints.js';
 export type { DynamicMode, ImplementationHint, TraceOptions } from './types.js';
 export { redactValue, redactText } from './utils/redaction.js';

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';