@saptools/service-flow 0.1.56 → 0.1.58

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-Y7H7ZU5B.js";
+} from "./chunk-CRSSXWQ2.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.56",
+  "version": "0.1.58",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/db/repositories.ts

@@ -1,3 +1,4 @@
+import { posix } from 'node:path';
 import type { Db } from './connection.js';
 import { projectBounded } from '../utils/000-bounded-projection.js';
 import type {
@@ -390,34 +391,88 @@ export function insertSymbolCalls(db: Db, repoId: number, rows: SymbolCallFact[]
   for (const r of rows) {
     const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName) as { id?: number } | undefined;
     const target = resolveSymbolCallTarget(db, repoId, r);
-    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount }), target.reason);
+    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount, resolvedModulePath: target.resolvedModulePath }), target.reason);
   }
 }
+interface SymbolTargetRow { id: number; kind?: string; sourceFile?: string | null; evidenceJson?: string | null }
+interface SymbolCallResolution { id: number | null; status: 'resolved' | 'ambiguous' | 'unresolved'; reason: string | null; strategy: string; candidateCount: number; resolvedModulePath?: string }
+const stripExt = (value: string): string => value.replace(/\.(ts|tsx|js|jsx|cds)$/, '');
+function symbolTargetRows(rows: Array<Record<string, unknown>>): SymbolTargetRow[] {
+  return rows.flatMap((row) => typeof row.id === 'number' ? [{ id: row.id, kind: typeof row.kind === 'string' ? row.kind : undefined, sourceFile: nullableString(row.sourceFile), evidenceJson: nullableString(row.evidenceJson) }] : []);
+}
+function relativeModuleTargets(callerSourceFile: string, importSource: string): Set<string> {
+  const base = posix.dirname(callerSourceFile);
+  const joined = stripExt(posix.normalize(posix.join(base, importSource)));
+  return new Set([joined, `${joined}/index`]);
+}
+function moduleRows(rows: SymbolTargetRow[], r: SymbolCallFact): SymbolTargetRow[] {
+  if (!r.importSource) return [];
+  const targets = relativeModuleTargets(r.sourceFile, r.importSource);
+  return rows.filter((row) => typeof row.sourceFile === 'string' && targets.has(stripExt(row.sourceFile)));
+}
+function resolvedSymbol(row: SymbolTargetRow, strategy: string, candidateCount: number, moduleScoped = false): SymbolCallResolution {
+  return { id: row.id, status: 'resolved', reason: null, strategy, candidateCount, resolvedModulePath: moduleScoped && row.sourceFile ? stripExt(row.sourceFile) : undefined };
+}
+function exportedSymbolRows(db: Db, repoId: number, r: SymbolCallFact): SymbolTargetRow[] {
+  return symbolTargetRows(db.prepare('SELECT id,kind,source_file sourceFile,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName));
+}
 function isRelativeImportedSymbolCall(r: SymbolCallFact): boolean {
   return Boolean(r.importSource?.startsWith('.'));
 }
-function resolveSymbolCallTarget(db: Db, repoId: number, r: SymbolCallFact): { id: number | null; status: string; reason: string | null; strategy: string; candidateCount: number } {
-  const evidence = r.evidence as { relation?: unknown };
-  const localRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number }>;
-  if (localRows.length === 1) return { id: localRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'same_file_exact', candidateCount: 1 };
-  if (localRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple same-file symbol targets matched exactly', strategy: 'same_file_exact', candidateCount: localRows.length };
-  if (evidence.relation === 'class_instance_method' && isRelativeImportedSymbolCall(r)) {
-    const classRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName) as Array<{ id: number }>;
-    if (classRows.length === 1) return { id: classRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'relative_import_class_instance_method', candidateCount: 1 };
-    if (classRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple relative class instance method targets matched exactly', strategy: 'relative_import_class_instance_method', candidateCount: classRows.length };
-  }
-  const rows = db.prepare('SELECT id,kind,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number; kind?: string; evidenceJson?: string | null }>;
-  if (evidence.relation === 'relative_import_proxy_member' && rows.length > 1) {
-    const objectMapRows = rows.filter((row) => String(row.evidenceJson ?? '').includes('exported_object_shorthand') || String(row.evidenceJson ?? '').includes('exported_object_literal'));
-    if (objectMapRows.length > 0) {
-      const concrete = rows.find((row) => row.kind !== 'object_alias') ?? objectMapRows[0];
-      return { id: concrete?.id ?? null, status: 'resolved', reason: null, strategy: 'proxy_member_exported_object_map', candidateCount: rows.length };
-    }
-    return { id: null, status: 'ambiguous', reason: 'Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous', strategy: 'proxy_member_no_global_name_fallback', candidateCount: rows.length };
+function sameFileResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  const bareImport = relation === 'relative_import' && isRelativeImportedSymbolCall(r) && !String(r.calleeLocalName).includes('.');
+  if (bareImport || relation === 'relative_import_namespace_member' || relation === 'package_import') return undefined;
+  const rows = symbolTargetRows(db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName));
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'same_file_exact', 1);
+  return rows.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple same-file symbol targets matched exactly', strategy: 'same_file_exact', candidateCount: rows.length } : undefined;
+}
+function classInstanceResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'class_instance_method' || !isRelativeImportedSymbolCall(r)) return undefined;
+  const rows = symbolTargetRows(db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName));
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'relative_import_class_instance_method', 1);
+  return rows.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple relative class instance method targets matched exactly', strategy: 'relative_import_class_instance_method', candidateCount: rows.length } : undefined;
+}
+function namespaceResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import_namespace_member' || !isRelativeImportedSymbolCall(r)) return undefined;
+  const rows = moduleRows(exportedSymbolRows(db, repoId, r), r);
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'relative_import_namespace_member', 1, true);
+  if (rows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple namespace member targets matched the imported module', strategy: 'relative_import_namespace_member', candidateCount: rows.length };
+  return { id: null, status: 'unresolved', reason: 'No namespace member target matched the imported module', strategy: 'relative_import_namespace_member', candidateCount: 0 };
+}
+function proxyResolution(rows: SymbolTargetRow[], r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import_proxy_member' || rows.length <= 1) return undefined;
+  const mapped = rows.filter((row) => String(row.evidenceJson ?? '').includes('exported_object_shorthand') || String(row.evidenceJson ?? '').includes('exported_object_literal'));
+  if (mapped.length > 0) {
+    const concrete = rows.find((row) => row.kind !== 'object_alias') ?? mapped[0];
+    return { id: concrete?.id ?? null, status: 'resolved', reason: null, strategy: 'proxy_member_exported_object_map', candidateCount: rows.length };
   }
-  if (rows.length === 1) return { id: rows[0]?.id ?? null, status: 'resolved', reason: null, strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_unique_exported_candidate' : 'relative_import_exported_exact', candidateCount: 1 };
-  if (rows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple exported symbol targets matched exactly', strategy: 'exported_exact', candidateCount: rows.length };
-  return { id: null, status: 'unresolved', reason: 'No local symbol target matched exactly', strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_no_global_name_fallback' : 'exact_symbol_match', candidateCount: 0 };
+  const scoped = moduleRows(rows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_path_disambiguated', rows.length, true);
+  return { id: null, status: 'ambiguous', reason: 'Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous', strategy: 'proxy_member_no_global_name_fallback', candidateCount: rows.length };
+}
+function exportedResolution(rows: SymbolTargetRow[], r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], relation === 'relative_import_proxy_member' ? 'proxy_member_unique_exported_candidate' : 'relative_import_exported_exact', 1, moduleRows(rows, r).length === 1);
+  if (rows.length <= 1) return undefined;
+  const scoped = isRelativeImportedSymbolCall(r) ? moduleRows(rows, r) : [];
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_path_disambiguated', rows.length, true);
+  return { id: null, status: 'ambiguous', reason: 'Multiple exported symbol targets matched exactly', strategy: 'exported_exact', candidateCount: rows.length };
+}
+function accessorResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import' || !isRelativeImportedSymbolCall(r) || !/^[^.]+\.[^.]+$/.test(String(r.calleeLocalName))) return undefined;
+  const methodRows = symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile FROM symbols WHERE repo_id=? AND source_file<>? AND kind='method' AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  const scoped = moduleRows(methodRows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_static_accessor_instance_method', 1, true);
+  return scoped.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple static-accessor instance method targets matched the imported module', strategy: 'relative_import_static_accessor_instance_method', candidateCount: scoped.length } : undefined;
+}
+function resolveSymbolCallTarget(db: Db, repoId: number, r: SymbolCallFact): SymbolCallResolution {
+  const relation = r.evidence.relation;
+  const early = sameFileResolution(db, repoId, r, relation) ?? classInstanceResolution(db, repoId, r, relation) ?? namespaceResolution(db, repoId, r, relation);
+  if (early) return early;
+  const rows = relation === 'package_import' ? [] : exportedSymbolRows(db, repoId, r);
+  const matched = proxyResolution(rows, r, relation) ?? exportedResolution(rows, r, relation) ?? accessorResolution(db, repoId, r, relation);
+  if (matched) return matched;
+  if (relation === 'package_import') return { id: null, status: 'unresolved', reason: 'Package import target resolution requires a post-publication workspace pass', strategy: 'package_import_unresolved', candidateCount: 0 };
+  return { id: null, status: 'unresolved', reason: 'No local symbol target matched exactly', strategy: relation === 'relative_import_proxy_member' ? 'proxy_member_no_global_name_fallback' : 'exact_symbol_match', candidateCount: 0 };
 }
 export function insertCalls(
   db: Db,

package/src/linker/003-package-import-symbol-resolver.ts

@@ -0,0 +1,195 @@
+import type { Db } from '../db/connection.js';
+
+export interface PackageSymbolLinkSummary {
+  resolved: number;
+  ambiguous: number;
+  unresolved: number;
+}
+
+interface RepoExports {
+  publicName: Map<string, number[]>;
+  qualified: Map<string, number[]>;
+  fileById: Map<number, string>;
+}
+
+interface PackageCallRow {
+  id: number;
+  callerRepoId: number;
+  calleeExpression: string;
+  importSource: string;
+  evidence: Record<string, unknown>;
+}
+
+interface PackageCallResolution {
+  id: number | null;
+  status: 'resolved' | 'ambiguous' | 'unresolved';
+  reason: string | null;
+  strategy: 'package_import_workspace_resolved' | 'package_import_ambiguous' | 'package_import_unresolved';
+  candidateCount: number;
+  resolvedModulePath?: string;
+}
+
+const unresolvedRepositoryReason = 'Package import target resolution requires a post-publication workspace pass';
+const unresolvedSymbolReason = 'Sibling package indexed but no matching exported symbol; the target may be a re-export, barrel, type-only export, or unindexed Receiver.member';
+const ambiguousSymbolReason = 'Multiple exported sibling-package symbol targets matched exactly';
+const stripExt = (value: string): string => value.replace(/\.(ts|tsx|js|jsx|cds)$/, '');
+
+function push(map: Map<string, number[]>, key: string, id: number): void {
+  const existing = map.get(key);
+  if (existing) existing.push(id);
+  else map.set(key, [id]);
+}
+
+function nullableString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function evidenceObject(value: unknown): Record<string, unknown> {
+  if (typeof value !== 'string' || value.length === 0) return {};
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function repoByPackageName(db: Db, workspaceId: number): Map<string, number | null> {
+  const result = new Map<string, number | null>();
+  const rows = db.prepare(`SELECT id,package_name packageName FROM repositories
+    WHERE workspace_id=? AND package_name IS NOT NULL ORDER BY package_name,id`).all(workspaceId);
+  for (const row of rows) {
+    const packageName = nullableString(row.packageName);
+    if (!packageName || typeof row.id !== 'number') continue;
+    result.set(packageName, result.has(packageName) ? null : row.id);
+  }
+  return result;
+}
+
+function packagePrefix(importSource: string): string {
+  const parts = importSource.split('/');
+  if (importSource.startsWith('@')) return parts.length >= 2 ? parts.slice(0, 2).join('/') : importSource;
+  return parts[0] ?? importSource;
+}
+
+function packageRepoId(repos: Map<string, number | null>, importSource: string): number | null {
+  const packageName = repos.has(importSource) ? importSource : packagePrefix(importSource);
+  return repos.get(packageName) ?? null;
+}
+
+function emptyRepoExports(): RepoExports {
+  return { publicName: new Map(), qualified: new Map(), fileById: new Map() };
+}
+
+function exportsByRepo(db: Db, workspaceId: number): Map<number, RepoExports> {
+  const result = new Map<number, RepoExports>();
+  const rows = db.prepare(`SELECT s.id,s.repo_id repoId,s.name,s.exported_name exportedName,
+      s.qualified_name qualifiedName,s.source_file sourceFile
+    FROM symbols s JOIN repositories r ON r.id=s.repo_id
+    WHERE r.workspace_id=? AND s.exported=1 ORDER BY s.repo_id,s.id`).all(workspaceId);
+  for (const row of rows) addExportRow(result, row);
+  return result;
+}
+
+function addExportRow(result: Map<number, RepoExports>, row: Record<string, unknown>): void {
+  if (typeof row.id !== 'number' || typeof row.repoId !== 'number') return;
+  const exports = result.get(row.repoId) ?? emptyRepoExports();
+  result.set(row.repoId, exports);
+  const publicName = nullableString(row.exportedName) ?? nullableString(row.name);
+  const qualifiedName = nullableString(row.qualifiedName);
+  const sourceFile = nullableString(row.sourceFile);
+  if (publicName) push(exports.publicName, publicName, row.id);
+  if (qualifiedName) push(exports.qualified, qualifiedName, row.id);
+  if (sourceFile) exports.fileById.set(row.id, stripExt(sourceFile));
+}
+
+function packageCallRows(db: Db, workspaceId: number): PackageCallRow[] {
+  const rows = db.prepare(`SELECT sc.id,sc.repo_id callerRepoId,
+      sc.callee_expression calleeExpression,sc.import_source importSource,
+      sc.evidence_json evidenceJson
+    FROM symbol_calls sc JOIN repositories r ON r.id=sc.repo_id
+    WHERE r.workspace_id=? AND sc.import_source IS NOT NULL
+      AND sc.import_source NOT LIKE './%' AND sc.import_source NOT LIKE '../%'
+      AND json_extract(sc.evidence_json,'$.relation')='package_import'
+      AND json_extract(sc.evidence_json,'$.candidateStrategy') IN
+        ('package_import_unresolved','package_import_workspace_resolved','package_import_ambiguous')
+    ORDER BY sc.id`).all(workspaceId);
+  return rows.flatMap((row) => packageCallRow(row));
+}
+
+function packageCallRow(row: Record<string, unknown>): PackageCallRow[] {
+  const calleeExpression = nullableString(row.calleeExpression);
+  const importSource = nullableString(row.importSource);
+  if (typeof row.id !== 'number' || typeof row.callerRepoId !== 'number'
+    || !calleeExpression || !importSource) return [];
+  return [{
+    id: row.id,
+    callerRepoId: row.callerRepoId,
+    calleeExpression,
+    importSource,
+    evidence: evidenceObject(row.evidenceJson),
+  }];
+}
+
+function candidatesForCall(call: PackageCallRow, exports: RepoExports | undefined): number[] {
+  if (!exports) return [];
+  const dotCount = [...call.calleeExpression].filter((character) => character === '.').length;
+  if (dotCount === 0) {
+    const targetName = nullableString(call.evidence.targetName);
+    return targetName ? exports.publicName.get(targetName) ?? [] : [];
+  }
+  return dotCount === 1 ? exports.qualified.get(call.calleeExpression) ?? [] : [];
+}
+
+function resolvePackageCall(
+  call: PackageCallRow,
+  repos: Map<string, number | null>,
+  exports: Map<number, RepoExports>,
+): PackageCallResolution {
+  const targetRepoId = packageRepoId(repos, call.importSource);
+  if (targetRepoId === null || targetRepoId === call.callerRepoId) return unresolvedResolution(unresolvedRepositoryReason);
+  const repoExports = exports.get(targetRepoId);
+  const candidates = candidatesForCall(call, repoExports);
+  const [id] = candidates;
+  if (candidates.length === 1 && id !== undefined) {
+    return {
+      id, status: 'resolved', reason: null, strategy: 'package_import_workspace_resolved',
+      candidateCount: 1, resolvedModulePath: repoExports?.fileById.get(id),
+    };
+  }
+  if (candidates.length > 1) {
+    return { id: null, status: 'ambiguous', reason: ambiguousSymbolReason, strategy: 'package_import_ambiguous', candidateCount: candidates.length };
+  }
+  return unresolvedResolution(unresolvedSymbolReason);
+}
+
+function unresolvedResolution(reason: string): PackageCallResolution {
+  return { id: null, status: 'unresolved', reason, strategy: 'package_import_unresolved', candidateCount: 0 };
+}
+
+function resolutionEvidence(call: PackageCallRow, resolution: PackageCallResolution): string {
+  const evidence: Record<string, unknown> = {
+    ...call.evidence,
+    candidateStrategy: resolution.strategy,
+    candidateCount: resolution.candidateCount,
+  };
+  if (resolution.resolvedModulePath) evidence.resolvedModulePath = resolution.resolvedModulePath;
+  else delete evidence.resolvedModulePath;
+  return JSON.stringify(evidence);
+}
+
+export function linkPackageImportSymbolCalls(db: Db, workspaceId: number): PackageSymbolLinkSummary {
+  const repos = repoByPackageName(db, workspaceId);
+  const exports = exportsByRepo(db, workspaceId);
+  const update = db.prepare(`UPDATE symbol_calls SET callee_symbol_id=?,status=?,
+    unresolved_reason=?,evidence_json=? WHERE id=?`);
+  const summary: PackageSymbolLinkSummary = { resolved: 0, ambiguous: 0, unresolved: 0 };
+  for (const call of packageCallRows(db, workspaceId)) {
+    const resolution = resolvePackageCall(call, repos, exports);
+    update.run(resolution.id, resolution.status, resolution.reason, resolutionEvidence(call, resolution), call.id);
+    summary[resolution.status] += 1;
+  }
+  return summary;
+}

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

@@ -12,6 +12,7 @@ import {
   objectJson,
   objectValue,
 } from './002-call-evidence.js';
+import { linkPackageImportSymbolCalls } from './003-package-import-symbol-resolver.js';
 export interface LinkWorkspaceResult {
   edgeCount: number;
   unresolvedCount: number;
@@ -32,6 +33,7 @@ export function linkWorkspace(db: Db, workspaceId: number, vars: Record<string,
     const generation = nextGraphGeneration(db, workspaceId);
     db.prepare('DELETE FROM graph_edges WHERE workspace_id=?').run(workspaceId);
     const deps = linkHelperPackages(db, workspaceId, generation);
+    linkPackageImportSymbolCalls(db, workspaceId);
     const impl = linkCanonicalImplementations(db, workspaceId, generation);
     const callSummary = linkCalls(db, workspaceId, vars, generation);
     db.prepare("UPDATE repositories SET graph_generation=?, graph_stale_reason=NULL, graph_stale_at=NULL WHERE workspace_id=?").run(generation, workspaceId);

package/src/parsers/symbol-parser.ts

@@ -184,6 +184,7 @@ export async function parseExecutableSymbols(
   const symbols: ExecutableSymbolFact[] = [];
   const calls: SymbolCallFact[] = [];
   const imports = new Map<string, string>();
+  const namespaceImports = new Set<string>();
   const exportNames = exportDeclarations(source);
   const objectExports = new Set<string>();
   const exportedClasses = new Set<string>();
@@ -214,7 +215,10 @@ export async function parseExecutableSymbols(
       if (clause?.name) imports.set(clause.name.text, sourceText);
       const named = clause?.namedBindings;
       if (named && ts.isNamedImports(named)) for (const el of named.elements) imports.set(el.name.text, sourceText);
-      if (named && ts.isNamespaceImport(named)) imports.set(named.name.text, sourceText);
+      if (named && ts.isNamespaceImport(named)) {
+        imports.set(named.name.text, sourceText);
+        namespaceImports.add(named.name.text);
+      }
     }
     if (ts.isVariableStatement(node)) {
       for (const declaration of node.declarationList.declarations) {
@@ -330,7 +334,9 @@ export async function parseExecutableSymbols(
         const instance = (callee.local ? classInstances.get(callee.local) : undefined) ?? (callee.receiver ? classInstances.get(callee.receiver) : undefined);
         const importSource = instance?.importSource ?? proxy?.importSource ?? (callee.local ? imports.get(callee.local) : undefined) ?? (callee.member && callee.local ? imports.get(callee.local) : undefined);
         const directThisMethod = callee.receiver === 'this';
-        const targetName = instance && callee.member ? `${instance.className}.${callee.member}` : proxy && callee.member ? callee.member : directThisMethod ? callee.member : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
+        const namespaceMember = Boolean(callee.member && callee.local && namespaceImports.has(callee.local));
+        const packageImport = Boolean(importSource && !isRelativeImport(importSource));
+        const targetName = instance && callee.member ? `${instance.className}.${callee.member}` : proxy && callee.member ? callee.member : directThisMethod ? callee.member : namespaceMember ? callee.member : packageImport ? (callee.member ?? callee.local) : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
         const className = caller.qualifiedName.includes('.') ? caller.qualifiedName.split('.')[0] : undefined;
         const thisTarget = directThisMethod && className && callee.member ? `${className}.${callee.member}` : undefined;
         const loggerLike = callee.receiver?.endsWith('.logger') || callee.local === 'logger' || (callee.expression.startsWith('this.logger.') && callee.member ? loggerMembers.has(callee.member) : false);
@@ -339,11 +345,11 @@ export async function parseExecutableSymbols(
         const provenThisMethod = Boolean(thisTarget && localCallables.has(thisTarget));
         const provenRelativeImport = Boolean(isRelativeImport(importSource) && targetName);
         const provenClassInstance = Boolean(instance && callee.member && targetName);
-        const importedFromPackage = Boolean(importSource && !isRelativeImport(importSource));
-        const ignored = loggerLike || terminalMember || importedFromPackage || ignoredFrameworkCall(callee);
+        const provenPackageImport = Boolean(packageImport && targetName);
+        const ignored = loggerLike || terminalMember || ignoredFrameworkCall(callee);
         const resolvedTarget = provenThisMethod ? thisTarget : targetName;
-        const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance);
-        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? (callee.local ?? callee.receiver) : undefined, importSource, sourceFile, sourceLine: line, evidence: { relation: instance ? 'class_instance_method' : proxy ? 'relative_import_proxy_member' : importSource ? 'relative_import' : provenThisMethod ? 'indexed_this_method' : 'indexed_local_symbol', caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? (instance.propertyName ?? callee.local) : undefined, className: instance?.className, methodName: instance ? callee.member : undefined, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? (instance.importSource ? 'relative_import_class_instance_method' : 'same_file_class_instance_method') : proxy ? 'proxy_member_exact_export_or_unique_member' : undefined } });
+        const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance || provenPackageImport);
+        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? (callee.local ?? callee.receiver) : undefined, importSource, sourceFile, sourceLine: line, evidence: { relation: instance ? 'class_instance_method' : proxy ? 'relative_import_proxy_member' : packageImport ? 'package_import' : namespaceMember ? 'relative_import_namespace_member' : importSource ? 'relative_import' : provenThisMethod ? 'indexed_this_method' : 'indexed_local_symbol', caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? (instance.propertyName ?? callee.local) : undefined, className: instance?.className, methodName: instance ? callee.member : undefined, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? (instance.importSource ? 'relative_import_class_instance_method' : 'same_file_class_instance_method') : proxy ? 'proxy_member_exact_export_or_unique_member' : undefined } });
       }
     }
     ts.forEachChild(node, visitCalls);