@saptools/service-flow 0.1.68 → 0.1.69

package/dist/index.d.ts

@@ -130,7 +130,7 @@ interface ServiceBindingReference {
     bindingSourceFile?: string;
     bindingSiteStartOffset?: number;
     bindingSiteEndOffset?: number;
-    resolutionStrategy?: 'lexical_declaration' | 'lexical_alias_declaration' | 'deterministic_reaching_assignment';
+    resolutionStrategy?: 'lexical_declaration' | 'lexical_alias_declaration' | 'deterministic_reaching_assignment' | 'single_hop_helper_return';
     lexicalScopeChain?: LexicalScopeFact[];
     bindingScopeIndex?: number;
     scopeChainTotal: number;
@@ -274,6 +274,7 @@ interface ClassifiedOutboundCall {
     fact: OutboundCallFact;
     node: ts.CallExpression;
 }
+
 declare function parseOutboundCalls(repoPath: string, filePath: string, context?: RepositorySourceContext, classified?: readonly ClassifiedOutboundCall[], preparedBindings?: readonly ServiceBindingFact[]): Promise<OutboundCallFact[]>;
 
 declare function parseGeneratedConstants(repoPath: string, filePath: string): Promise<GeneratedConstantFact[]>;
@@ -393,6 +394,7 @@ interface CompactDecisionV1 {
     implementationStrategy?: string;
     implementationGuided?: boolean;
     implementationContextual?: boolean;
+    tiedCandidateRepos?: CompactReferenceGroupV1;
     eventMatchStrategy?: string;
     dispatchCertainty?: string;
     eventSubscriptionCount?: number;
@@ -413,6 +415,10 @@ interface CompactEdgeDetailsV1 {
 }
 interface CompactDiagnosticDetailsV1 {
     reasonCode?: string;
+    tiedCandidateRepos?: CompactReferenceGroupV1;
+    selectorKind?: string;
+    selectorSuggestions?: CompactReferenceGroupV1;
+    invalidFactCategories?: CompactReferenceGroupV1;
     missingVariableNames?: string[];
     missingVariableCount?: number;
     shownMissingVariableCount?: number;

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   substituteVariables,
   trace,
   traceAndCompact
-} from "./chunk-AEM4JY22.js";
+} from "./chunk-3N3B5KHV.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.68",
+  "version": "0.1.69",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli/001-index-summary.ts

@@ -0,0 +1,22 @@
+import type {
+  IndexWorkspaceSummary,
+} from '../indexer/workspace-indexer.js';
+
+export interface IndexCommandOutcome {
+  stdout: string;
+  exitCode: 0 | 1;
+}
+
+export function indexCommandOutcome(
+  summary: IndexWorkspaceSummary,
+): IndexCommandOutcome {
+  const failed = summary.failedCount > 0
+    ? `, failed ${summary.failedCount} (${
+      summary.failedRepos.map(({ name, code }) => `${name}: ${code}`).join(', ')
+    })`
+    : '';
+  return {
+    stdout: `Indexed ${summary.indexedCount} repositories, skipped ${summary.skippedCount}${failed}, ${summary.fileCount} files, ${summary.diagnosticCount} diagnostics\n`,
+    exitCode: summary.failedCount > 0 ? 1 : 0,
+  };
+}

package/src/cli.ts

@@ -41,6 +41,7 @@ import type {
   TraceStart,
 } from './types.js';
 import { cleanWorkspaceState } from './cli/000-clean.js';
+import { indexCommandOutcome } from './cli/001-index-summary.js';
 
 const stdout = createStdoutWriter(process.stdout, fail);
 const TRACE_FORMATS = ['table', 'json', 'mermaid', 'compact-json'] as const;
@@ -245,14 +246,16 @@ function runGraphCommand(opts: GraphCommandOptions): Promise<void> {
   });
 }
 
-export function createProgram(): Command {
-  const program = new Command();
-  program
+function configuredProgram(): Command {
+  return new Command()
     .name('service-flow')
     .description(
       'Trace SAP CAP service-to-service flows across multi-repository workspaces',
     )
     .version(VERSION);
+}
+
+function registerInitCommand(program: Command): void {
   program
     .command('init')
     .argument('<workspace>')
@@ -262,6 +265,9 @@ export function createProgram(): Command {
       (workspace: string, opts: { db?: string; ignore?: string[] }) =>
         void init(workspace, opts).catch(fail),
     );
+}
+
+function registerIndexCommand(program: Command): void {
   program
     .command('index')
     .option('--workspace <path>')
@@ -274,11 +280,14 @@ export function createProgram(): Command {
             repo: opts.repo,
             force: Boolean(opts.force),
           });
-          writeStdout(
-            `Indexed ${r.indexedCount} repositories, skipped ${r.skippedCount}, ${r.fileCount} files, ${r.diagnosticCount} diagnostics\n`,
-          );
+          const outcome = indexCommandOutcome(r);
+          writeStdout(outcome.stdout);
+          if (outcome.exitCode !== 0) process.exitCode = outcome.exitCode;
         }).catch(fail),
     );
+}
+
+function registerLinkCommand(program: Command): void {
   program
     .command('link')
     .option('--workspace <path>')
@@ -293,6 +302,9 @@ export function createProgram(): Command {
           );
         }).catch(fail),
     );
+}
+
+function registerTraceCommand(program: Command): void {
   program
     .command('trace')
     .option('--workspace <path>')
@@ -312,23 +324,91 @@ export function createProgram(): Command {
     .option('--dynamic-mode <mode>', 'strict|candidates|infer', 'strict')
     .option('--max-dynamic-candidates <n>', 'maximum dynamic candidates to show', '5')
     .action((opts: TraceCommandOptions) => void runTraceCommand(opts).catch(fail));
+}
+
+function listRepositoriesCommand(
+  opts: { workspace?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) =>
+    writeStdout(
+      renderJson(
+        listRepositories(db, workspaceId).map((repo) => ({
+          name: repo.name,
+          kind: repo.kind,
+          packageName: repo.package_name,
+        })),
+      ),
+    ));
+}
+
+function listServicesCommand(
+  opts: { workspace?: string; repo?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo
+      ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(renderJson([selection.diagnostic]));
+      return;
+    }
+    const repo = selection.repo;
+    const rows = db.prepare(
+      'SELECT r.name repo,s.service_path servicePath,s.qualified_name qualifiedName FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path',
+    ).all(workspaceId, repo?.id, repo?.id);
+    writeStdout(renderJson(rows));
+  });
+}
+
+function listOperationsCommand(
+  opts: { workspace?: string; repo?: string; service?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo
+      ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(renderJson([selection.diagnostic]));
+      return;
+    }
+    const repo = selection.repo;
+    const rows = db.prepare(
+      'SELECT r.name repo,s.service_path servicePath,o.operation_name operation,o.operation_path path FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)',
+    ).all(
+      workspaceId, repo?.id, repo?.id, opts.service, opts.service,
+    );
+    writeStdout(renderJson(rows));
+  });
+}
+
+function listCallsCommand(
+  opts: { workspace?: string; repo?: string; operation?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo
+      ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(renderJson([selection.diagnostic]));
+      return;
+    }
+    const repo = selection.repo;
+    const rows = db.prepare(
+      'SELECT r.name repo,c.call_type type,c.operation_path_expr path,c.source_file file,c.source_line line FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE r.workspace_id=? AND (? IS NULL OR c.repo_id=?) AND (? IS NULL OR c.operation_path_expr=? OR c.operation_path_expr=? OR c.payload_summary LIKE ?)',
+    ).all(
+      workspaceId, repo?.id, repo?.id, opts.operation, opts.operation,
+      opts.operation ? `/${opts.operation}` : undefined,
+      opts.operation ? `%${opts.operation}%` : undefined,
+    );
+    writeStdout(renderJson(rows));
+  });
+}
+
+function registerListCommands(program: Command): void {
   const list = program.command('list');
   list
     .command('repos')
     .option('--workspace <path>')
     .action(
       (opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) =>
-          writeStdout(
-            renderJson(
-              listRepositories(db, workspaceId).map((r) => ({
-                name: r.name,
-                kind: r.kind,
-                packageName: r.package_name,
-              })),
-            ),
-          ),
-        ).catch(fail),
+        void listRepositoriesCommand(opts).catch(fail),
     );
   list
     .command('services')
@@ -336,22 +416,7 @@ export function createProgram(): Command {
     .option('--repo <name>')
     .action(
       (opts: { workspace?: string; repo?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const selection = opts.repo
-            ? selectRepository(db, opts.repo, workspaceId)
-            : {};
-          if (selection.diagnostic) {
-            writeStdout(renderJson([selection.diagnostic]));
-            return;
-          }
-          const repo = selection.repo;
-          const rows = db
-            .prepare(
-              'SELECT r.name repo,s.service_path servicePath,s.qualified_name qualifiedName FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path',
-            )
-            .all(workspaceId, repo?.id, repo?.id);
-          writeStdout(renderJson(rows));
-        }).catch(fail),
+        void listServicesCommand(opts).catch(fail),
     );
   list
     .command('operations')
@@ -360,22 +425,7 @@ export function createProgram(): Command {
     .option('--service <path>')
     .action(
       (opts: { workspace?: string; repo?: string; service?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const selection = opts.repo
-            ? selectRepository(db, opts.repo, workspaceId)
-            : {};
-          if (selection.diagnostic) {
-            writeStdout(renderJson([selection.diagnostic]));
-            return;
-          }
-          const repo = selection.repo;
-          const rows = db
-            .prepare(
-              'SELECT r.name repo,s.service_path servicePath,o.operation_name operation,o.operation_path path FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)',
-            )
-            .all(workspaceId, repo?.id, repo?.id, opts.service, opts.service);
-          writeStdout(renderJson(rows));
-        }).catch(fail),
+        void listOperationsCommand(opts).catch(fail),
     );
   list
     .command('calls')
@@ -384,31 +434,11 @@ export function createProgram(): Command {
     .option('--operation <name>')
     .action(
       (opts: { workspace?: string; repo?: string; operation?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const selection = opts.repo
-            ? selectRepository(db, opts.repo, workspaceId)
-            : {};
-          if (selection.diagnostic) {
-            writeStdout(renderJson([selection.diagnostic]));
-            return;
-          }
-          const repo = selection.repo;
-          const rows = db
-            .prepare(
-              'SELECT r.name repo,c.call_type type,c.operation_path_expr path,c.source_file file,c.source_line line FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE r.workspace_id=? AND (? IS NULL OR c.repo_id=?) AND (? IS NULL OR c.operation_path_expr=? OR c.operation_path_expr=? OR c.payload_summary LIKE ?)',
-            )
-            .all(
-              workspaceId,
-              repo?.id,
-              repo?.id,
-              opts.operation,
-              opts.operation,
-              opts.operation ? `/${opts.operation}` : undefined,
-              opts.operation ? `%${opts.operation}%` : undefined,
-            );
-          writeStdout(renderJson(rows));
-        }).catch(fail),
+        void listCallsCommand(opts).catch(fail),
     );
+}
+
+function registerGraphCommand(program: Command): void {
   program
     .command('graph')
     .option('--workspace <path>')
@@ -423,6 +453,33 @@ export function createProgram(): Command {
     .option('--dynamic-mode <mode>', 'strict|candidates|infer', 'strict')
     .option('--max-dynamic-candidates <n>', 'maximum dynamic candidates to show', '5')
     .action((opts: GraphCommandOptions) => void runGraphCommand(opts).catch(fail));
+}
+
+function inspectRepositoryCommand(
+  name: string,
+  opts: { workspace?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = selectRepository(db, name, workspaceId);
+    writeStdout(renderJson(
+      selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
+    ));
+  });
+}
+
+function inspectOperationCommand(
+  selector: string,
+  opts: { workspace?: string },
+): Promise<void> {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const rows = db.prepare(
+      'SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)',
+    ).all(workspaceId, selector, selector);
+    writeStdout(renderJson(rows));
+  });
+}
+
+function registerInspectCommands(program: Command): void {
   const inspect = program.command('inspect');
   inspect
     .command('repo')
@@ -430,12 +487,7 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (name: string, opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const selection = selectRepository(db, name, workspaceId);
-          writeStdout(renderJson(
-            selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
-          ));
-        }).catch(fail),
+        void inspectRepositoryCommand(name, opts).catch(fail),
     );
   inspect
     .command('operation')
@@ -443,15 +495,11 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (selector: string, opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const rows = db
-            .prepare(
-              'SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)',
-            )
-            .all(workspaceId, selector, selector);
-          writeStdout(renderJson(rows));
-        }).catch(fail),
+        void inspectOperationCommand(selector, opts).catch(fail),
     );
+}
+
+function registerDoctorCommand(program: Command): void {
   program
     .command('doctor')
     .option('--workspace <path>')
@@ -467,6 +515,9 @@ export function createProgram(): Command {
           writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
         }).catch(fail),
     );
+}
+
+function registerCleanCommand(program: Command): void {
   program
     .command('clean')
     .option('--workspace <path>')
@@ -479,6 +530,19 @@ export function createProgram(): Command {
           writeStdout('Cleaned service-flow state\n');
         })().catch(fail),
     );
+}
+
+export function createProgram(): Command {
+  const program = configuredProgram();
+  registerInitCommand(program);
+  registerIndexCommand(program);
+  registerLinkCommand(program);
+  registerTraceCommand(program);
+  registerListCommands(program);
+  registerGraphCommand(program);
+  registerInspectCommands(program);
+  registerDoctorCommand(program);
+  registerCleanCommand(program);
   return program;
 }
 function collect(value: string, previous: string[]): string[] {

package/src/db/000-call-fact-repository.ts

@@ -16,6 +16,12 @@ import {
   type BindingProofCall,
   type BindingProofTarget,
 } from './012-binding-reference-proof.js';
+import {
+  preparedCallSnapshotError,
+} from './013-index-publication-failure.js';
+import {
+  hasSingleHopHelperReturn,
+} from './014-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

@@ -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/004-package-target-invalidation.ts

@@ -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,