@pharaoh-so/local-analyzer 0.1.0 → 0.1.1

package/dist/analyzer.mjs

@@ -27904,7 +27904,7 @@ function extractExportStatement(node2, source, functions, classes, imports, expo
 function extractImport(node2, imports) {
   let sourceNode = node2.childForFieldName("source");
   if (!sourceNode) return;
-  let source = sourceNode.text.replace(/['"]/g, ""), symbols2 = [], isDefault = !1, isNamespace = !1, aliases = [], isTypeOnly = node2.children.some((c) => c.type === "type");
+  let source = sourceNode.text.replace(/['"]/g, ""), symbols2 = [], isDefault = !1, isNamespace = !1, aliases = [], isTypeOnly2 = node2.children.some((c) => c.type === "type");
   for (let child of node2.children)
     if (child.type === "import_clause") {
       for (let clauseChild of child.children)
@@ -27933,7 +27933,7 @@ function extractImport(node2, imports) {
     isDefault,
     isNamespace,
     line: node2.startPosition.row + 1,
-    ...isTypeOnly ? { isTypeOnly } : {},
+    ...isTypeOnly2 ? { isTypeOnly: isTypeOnly2 } : {},
     ...aliases.length > 0 ? { aliases } : {}
   });
 }
@@ -28080,20 +28080,29 @@ function readDynamicImportCandidates(rootNode) {
       importPath,
       rootRelative: wrapper?.rootRelative ?? !1,
       line: importCallNode.startPosition.row + 1,
-      extracted
+      extracted,
+      ...extracted.names.length > 0 && moduleScopeBinding(importCallNode) && { moduleScope: !0 }
     });
   }
   return candidates;
 }
+function moduleScopeBinding(call) {
+  let expression = call.parent, awaited = expression?.type === "array" ? expression.parent?.parent?.parent : expression;
+  if (awaited?.type !== "await_expression" || awaited.parent?.type !== "variable_declarator")
+    return !1;
+  let scope = awaited.parent.parent?.parent;
+  return scope?.type === "program" || scope?.type === "export_statement" && scope.parent?.type === "program";
+}
 function bindDynamicImportCandidates(candidates, filePath, resolveSpecifier2) {
   let sites = [];
-  for (let { importPath, rootRelative, line, extracted } of candidates) {
+  for (let { importPath, rootRelative, line, extracted, moduleScope } of candidates) {
     let extensionPath = rootRelative && importPath ? extensionRootPath(importPath) : null, specifier = rootRelative ? extensionPath ? resolveSpecifier2(extensionPath, filePath, "extension-root") : void 0 : importPath && !importPath.startsWith(".") ? resolveSpecifier2(importPath, filePath) : void 0;
     specifier?.external || sites.push({
       importPath,
       resolvedTarget: importPath ? rootRelative ? specifier?.target ?? null : specifier ? specifier.target ?? null : resolveRelativeImport(filePath, importPath) : null,
       line,
-      extracted
+      extracted,
+      ...moduleScope && { moduleScope }
     });
   }
   return sites;
@@ -28176,7 +28185,7 @@ function resolveDynamicImportSites(sites, filePath, parsedFiles) {
         importLine: site.line
       });
     }
-    extracted.namespaceId && (symbols2.set(extracted.namespaceId, targetFile), extracted.namespaceMethods.length > 0 && imports.push({
+    extracted.namespaceId && (symbols2.set(extracted.namespaceId, targetFile), renames.set(extracted.namespaceId, "*"), extracted.namespaceMethods.length > 0 && imports.push({
       fromFile: filePath,
       toFile: targetFile,
       symbols: extracted.namespaceMethods,
@@ -28476,6 +28485,11 @@ var ExportRegistry = class {
     let entry = this.files.get(filePath);
     entry && returnTypes.size > 0 && (entry.returnTypes = returnTypes);
   }
+  /** Retain a file's explicit export bindings after releasing its syntax tree. */
+  addNamedReExports(filePath, exports) {
+    let entry = this.files.get(filePath);
+    entry && (entry.namedReExports = exports);
+  }
   /**
    * Get the set of all file paths stored in the registry across all chunks.
    *
@@ -28586,7 +28600,7 @@ var ExportRegistry = class {
             importLine: item.importLine
           });
         }
-        item.namespaceId && (entry.symbols.has(item.namespaceId) || entry.symbols.set(item.namespaceId, targetFile), item.namespaceMethods.length > 0 && entry.imports.push({
+        item.namespaceId && (entry.symbols.has(item.namespaceId) || (entry.symbols.set(item.namespaceId, targetFile), entry.renames.set(item.namespaceId, "*")), item.namespaceMethods.length > 0 && entry.imports.push({
           fromFile: filePath,
           toFile: targetFile,
           symbols: item.namespaceMethods,
@@ -28775,6 +28789,237 @@ function starExportTargets(fileImports) {
   return targets;
 }
 
+// src/resolver/re-exports.ts
+function isTypeOnly(node2) {
+  return node2.children.some(
+    (child) => child.type === "type" || child.type === "ERROR" && child.text === "type"
+  );
+}
+function moduleSpecifier(node2) {
+  return node2.childForFieldName("source")?.text.slice(1, -1);
+}
+function nonCallableBinding(file, name = "*") {
+  return { file, name, local: !0 };
+}
+function importedBindings(root2, file, names, resolveSpecifier2, dynamicSites, knownFiles) {
+  let bindings = /* @__PURE__ */ new Map(), add = (local, binding2) => {
+    names.has(local) && bindings.set(local, bindings.has(local) ? null : binding2);
+  };
+  for (let statement of root2.namedChildren) {
+    if (statement.type !== "import_statement") continue;
+    let source = moduleSpecifier(statement), clause = statement.namedChildren.find((child) => child.type === "import_clause");
+    if (source === void 0 || !clause) continue;
+    let typeOnly = isTypeOnly(statement), resolution, bind = (local, original, typeOnly2, namespace2 = !1) => {
+      if (!names.has(local)) return;
+      if (typeOnly2) {
+        add(local, null);
+        return;
+      }
+      resolution ??= resolveSpecifier2(source, file, void 0, statement.startPosition.row + 1);
+      let target = resolution.target;
+      add(
+        local,
+        target ? namespace2 ? nonCallableBinding(target) : { file: target, name: original } : nonCallableBinding(file, `*:${local}`)
+      );
+    };
+    for (let child of clause.namedChildren) {
+      if (child.type === "identifier" && bind(child.text, "default", typeOnly), child.type === "namespace_import") {
+        let name = child.namedChildren.find((member) => member.type === "identifier")?.text;
+        name && bind(name, "*", typeOnly, !0);
+      }
+      if (child.type === "named_imports")
+        for (let specifier of child.namedChildren) {
+          let name = specifier.childForFieldName("name")?.text, alias = specifier.childForFieldName("alias")?.text;
+          name && bind(alias ?? name, name, typeOnly || isTypeOnly(specifier));
+        }
+    }
+  }
+  for (let site of dynamicSites) {
+    if (!site.moduleScope || !site.extracted.names.some(({ local }) => names.has(local))) continue;
+    let target = site.resolvedTarget && knownFiles && findParsedFilePath(knownFiles, site.resolvedTarget);
+    for (let { local, original } of site.extracted.names)
+      add(
+        local,
+        target ? { file: target, name: original } : nonCallableBinding(file, `*:${local}`)
+      );
+  }
+  return bindings;
+}
+var CALLABLE_DECLARATIONS = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "generator_function_declaration",
+  "class_declaration",
+  "abstract_class_declaration"
+]), CALLABLE_EXPRESSIONS = /* @__PURE__ */ new Set([
+  "arrow_function",
+  "function_expression",
+  "generator_function",
+  "class"
+]);
+function recordPattern(node2, record2) {
+  if (node2.type === "identifier" || node2.type === "shorthand_property_identifier_pattern") {
+    record2(node2.text);
+    return;
+  }
+  if (node2.type === "pair_pattern" || node2.type === "assignment_pattern" || node2.type === "object_assignment_pattern") {
+    let value = node2.childForFieldName(node2.type === "pair_pattern" ? "value" : "left");
+    value && recordPattern(value, record2);
+    return;
+  }
+  for (let child of node2.namedChildren) recordPattern(child, record2);
+}
+function recordDeclaration(node2, record2) {
+  if (node2.type === "lexical_declaration" || node2.type === "variable_declaration") {
+    for (let declarator of node2.namedChildren) {
+      if (declarator.type !== "variable_declarator") continue;
+      let pattern = declarator.childForFieldName("name"), value = declarator.childForFieldName("value");
+      pattern && recordPattern(pattern, (name2) => record2(name2, CALLABLE_EXPRESSIONS.has(value?.type ?? "")));
+    }
+    return;
+  }
+  let callable = CALLABLE_DECLARATIONS.has(node2.type);
+  if (!callable && node2.type !== "enum_declaration" && node2.type !== "internal_module") return;
+  let name = node2.childForFieldName("name");
+  name && record2(name.text, callable);
+}
+function commonJsAssignment(statement) {
+  if (statement.type !== "expression_statement") return !1;
+  let expression = statement.namedChildren[0];
+  if (expression?.type !== "assignment_expression") return !1;
+  let left = expression.childForFieldName("left");
+  return !!left && /^(?:module\.exports|exports)(?:\.|\[|$)/.test(left.text);
+}
+function readNamedReExports(root2, file, resolveSpecifier2, dynamicSites = [], parsedExports = [], knownFiles) {
+  let named = /* @__PURE__ */ new Map(), stars = /* @__PURE__ */ new Set(), localValues = /* @__PURE__ */ new Set(), callable = /* @__PURE__ */ new Set(), types2 = /* @__PURE__ */ new Set(), localExports = [], commonJs = !1, hasExportStatement = !1, local = (name) => ({ file, name, local: !0, topLevel: !0 }), recordLocal = (name, isCallable) => {
+    localValues.add(name), isCallable && callable.add(name);
+  }, addNamed = (name, binding2) => named.set(name, named.has(name) ? null : binding2);
+  for (let statement of root2.namedChildren) {
+    if (statement.type !== "export_statement") {
+      recordDeclaration(statement, recordLocal), commonJs || (commonJs = commonJsAssignment(statement));
+      continue;
+    }
+    hasExportStatement = !0;
+    let source = moduleSpecifier(statement), typeOnly = isTypeOnly(statement), clause = statement.namedChildren.find((child) => child.type === "export_clause");
+    if (clause) {
+      let target = source !== void 0 && !typeOnly ? resolveSpecifier2(source, file, void 0, statement.startPosition.row + 1).target : void 0;
+      for (let specifier of clause.namedChildren) {
+        let original = specifier.childForFieldName("name")?.text;
+        if (!original) continue;
+        let name = specifier.childForFieldName("alias")?.text ?? original;
+        typeOnly || isTypeOnly(specifier) ? types2.add(name) : source === void 0 ? localExports.push({ name, original }) : addNamed(
+          name,
+          target ? { file: target, name: original } : nonCallableBinding(file, `*:${name}`)
+        );
+      }
+      continue;
+    }
+    if (typeOnly) continue;
+    if (source !== void 0) {
+      if (statement.children.some((child) => child.type === "*")) {
+        let target = resolveSpecifier2(
+          source,
+          file,
+          void 0,
+          statement.startPosition.row + 1
+        ).target;
+        target && stars.add(target);
+      } else {
+        let name = statement.namedChildren.find(
+          (child) => child.type === "namespace_export"
+        )?.namedChildren[0]?.text;
+        if (name) {
+          let target = resolveSpecifier2(
+            source,
+            file,
+            void 0,
+            statement.startPosition.row + 1
+          ).target;
+          addNamed(
+            name,
+            target ? nonCallableBinding(target) : nonCallableBinding(file, `*:${name}`)
+          );
+        }
+      }
+      continue;
+    }
+    let isDefault = statement.children.some((child) => child.type === "default"), declaration2 = statement.childForFieldName("declaration"), value = statement.childForFieldName("value");
+    if (declaration2)
+      recordDeclaration(declaration2, (name, isCallable) => {
+        recordLocal(name, isCallable), addNamed(isDefault ? "default" : name, local(name));
+      });
+    else if (isDefault && value?.type === "identifier")
+      localExports.push({ name: "default", original: value.text });
+    else if (isDefault) {
+      let name = parsedExports.find((entry) => entry.isDefault)?.name ?? "default";
+      recordLocal(name, CALLABLE_EXPRESSIONS.has(value?.type ?? "")), addNamed("default", local(name));
+    }
+  }
+  if (localExports.length > 0) {
+    let names = new Set(localExports.map(({ original }) => original)), imported = importedBindings(
+      root2,
+      file,
+      names,
+      resolveSpecifier2,
+      dynamicSites,
+      knownFiles
+    );
+    for (let { name, original } of localExports) {
+      let binding2 = imported.get(original);
+      addNamed(
+        name,
+        binding2 === void 0 ? localValues.has(original) ? local(original) : null : binding2
+      );
+    }
+  }
+  for (let name of types2) named.has(name) || named.set(name, null);
+  return {
+    named,
+    stars: [...stars],
+    callable,
+    ...commonJs && !hasExportStatement && { commonJs: !0 }
+  };
+}
+var MAX_EXPORT_STATES = 4096;
+function createImportedSymbolResolver(imports, functions, reExports, defaultName, onExhausted) {
+  return (startFile, startName) => {
+    let start = reExports(startFile), binding2 = start?.named.get(startName);
+    if (binding2 === null) return;
+    if (binding2?.local)
+      return start?.callable.has(binding2.name) && functions.get(startFile)?.has(binding2.name) ? { file: startFile, name: binding2.name, topLevel: !0 } : void 0;
+    if (!binding2 && !start?.stars.length && functions.get(startFile)?.has(startName))
+      return { file: startFile, name: startName };
+    let queue2 = [{ file: startFile, name: startName }], visited = /* @__PURE__ */ new Map([[startFile, /* @__PURE__ */ new Set([startName])]]), enqueue = (file, name) => {
+      let names = visited.get(file) ?? /* @__PURE__ */ new Set();
+      return names.has(name) ? !0 : queue2.length >= MAX_EXPORT_STATES ? (onExhausted?.(startFile), !1) : (names.add(name), visited.set(file, names), queue2.push({ file, name }), !0);
+    }, result2;
+    for (let index = 0; index < queue2.length; index++) {
+      let { file, name } = queue2[index], facts = reExports(file), explicit = facts?.named.get(name), declaration2;
+      if (explicit !== null) {
+        if (explicit?.local)
+          declaration2 = { file: explicit.file, name: explicit.name, topLevel: !0 };
+        else if (explicit) {
+          if (!enqueue(explicit.file, explicit.name)) return;
+        } else {
+          let legacy = !facts || facts.commonJs || index === 0, actualName = name === "default" ? defaultName(file) ?? name : name;
+          if (legacy && functions.get(file)?.has(actualName) && !facts?.stars.length)
+            declaration2 = { file, name: actualName };
+          else if (name !== "default") {
+            let fileImports = imports.get(file), named = fileImports?.get(name), targets = facts && !facts.commonJs ? facts.stars : named ? [named] : starExportTargets(fileImports);
+            for (let target of targets) if (!enqueue(target, name)) return;
+          }
+        }
+        if (declaration2) {
+          if (result2 && (result2.file !== declaration2.file || result2.name !== declaration2.name))
+            return;
+          result2 = declaration2;
+        }
+      }
+    }
+    if (!(!result2 || !functions.get(result2.file)?.has(result2.name)) && !(result2.topLevel && !reExports(result2.file)?.callable.has(result2.name)))
+      return result2;
+  };
+}
+
 // src/resolver/router-registration.ts
 var ROUTER_PACKAGES = /* @__PURE__ */ new Set([
   "express",
@@ -28899,6 +29144,7 @@ function resolveRegistryImports(registry, fileIndex, tsConfig, opts) {
         stats.resolved++, resolved.push({
           fromFile: filePath,
           toFile: target,
+          source: imp.source,
           symbols: imp.symbols,
           isTypeOnly: imp.isTypeOnly,
           importLine: imp.line,
@@ -29280,7 +29526,7 @@ var tsParser2 = new Parser();
 tsParser2.setLanguage(tsLanguage);
 var tsxParser2 = new Parser();
 tsxParser2.setLanguage(tsxLanguage);
-var pyParser2 = new Parser();
+var jsParser = tsxLanguage === tsxLanguage ? tsxParser2 : new Parser().setLanguage(tsxLanguage), pyParser2 = new Parser();
 pyParser2.setLanguage(pyLanguage);
 var BUILT_INS = /* @__PURE__ */ new Set([
   "console",
@@ -29473,27 +29719,39 @@ function classifyCallContext(callNode) {
   }
   return "production";
 }
-function resolveReExport(symbolName, immediateTarget, importSymbolMap, fileFunctionNames) {
-  let queue2 = [immediateTarget], visited = /* @__PURE__ */ new Set();
-  for (let currentFile = queue2.shift(); currentFile; currentFile = queue2.shift()) {
-    if (visited.has(currentFile)) continue;
-    visited.add(currentFile);
-    let fileImports = importSymbolMap.get(currentFile), named = fileImports?.get(symbolName);
-    for (let nextFile of named ? [named] : starExportTargets(fileImports)) {
-      if (fileFunctionNames.get(nextFile)?.has(symbolName)) return nextFile;
-      queue2.push(nextFile);
-    }
+function resolvedFunctionUid(repoName, target, classNames) {
+  return target ? buildFunctionUid(repoName, target.file, {
+    name: target.name,
+    className: target.topLevel ? void 0 : classNames.get(target.file)?.get(target.name)
+  }) : void 0;
+}
+function namespaceBindings(imports) {
+  let names = /* @__PURE__ */ new Set();
+  for (let statement of imports) {
+    if (!statement.isNamespace || statement.isTypeOnly) continue;
+    let name = statement.symbols.at(-1);
+    name && name !== "*" && names.add(name);
   }
-  return null;
+  return names;
 }
-function memberTarget(name, member, targetFile, importSymbolMap, fileFunctionNames, instanceClasses, hasMember) {
-  let [className2, classFrom] = instanceClassOf(
-    name,
-    targetFile,
-    importSymbolMap,
-    instanceClasses
-  ) ?? [name, targetFile], file = fileFunctionNames.get(classFrom)?.has(className2) ? classFrom : resolveReExport(className2, classFrom, importSymbolMap, fileFunctionNames);
-  return file && hasMember(file, `${className2}.${member}`) ? { file, className: className2 } : void 0;
+function isPythonModuleReceiver(file, binding2, functions) {
+  return file.endsWith(".py") && pythonModuleName(file) === binding2 && !functions.get(file)?.has(binding2);
+}
+function functionReceiverMember(member) {
+  return member === "call" || member === "apply" || member === "bind";
+}
+function pythonFactoryReceiverUid(repo, classes, file, name) {
+  return file.endsWith(".py") && classes.byName.get(name)?.some((cls) => cls.file === file) ? buildFunctionUid(repo, file, { name }) : void 0;
+}
+function memberTarget(name, member, targetFile, importSymbolMap, aliases, resolveImported, instanceClasses, hasMember) {
+  let instance = instanceClassOf(name, targetFile, importSymbolMap, instanceClasses), target;
+  if (instance) {
+    let [className2, file] = instance;
+    if (hasMember(file, `${className2}.${member}`)) return { file, className: className2 };
+    let imported = importSymbolMap.get(file)?.get(className2);
+    imported && (target = resolveImported(imported, aliases.get(file)?.get(className2) ?? className2));
+  } else target = resolveImported(targetFile, name);
+  return target && hasMember(target.file, `${target.name}.${member}`) ? { file: target.file, className: target.name } : void 0;
 }
 function instanceClassOf(name, file, importSymbolMap, instanceClasses) {
   let visited = /* @__PURE__ */ new Set(), current = file;
@@ -29956,7 +30214,15 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
       let fnMap = fileFnClassNames.get(path5);
       fnMap || (fnMap = /* @__PURE__ */ new Map(), fileFnClassNames.set(path5, fnMap)), fnMap.set(fn.name, fn.className);
     }
-  let effectiveAliasMap = aliasMap ?? /* @__PURE__ */ new Map(), instanceClasses = /* @__PURE__ */ new Map();
+  let effectiveAliasMap = aliasMap ?? /* @__PURE__ */ new Map(), namespaceNames = new Map(
+    [...registry.entries()].map(([file, entry]) => [file, namespaceBindings(entry.imports)])
+  ), exhausted = /* @__PURE__ */ new Set(), tracingFile, resolveImported = createImportedSymbolResolver(
+    importSymbolMap,
+    fileFunctionNames,
+    (file) => registry.getFileEntry(file)?.namedReExports,
+    (file) => registry.getFileEntry(file)?.defaultExportName,
+    (file) => exhausted.add(tracingFile ?? file)
+  ), instanceClasses = /* @__PURE__ */ new Map();
   for (let [path5, entry] of registry.entries())
     entry.instanceClasses && instanceClasses.set(path5, new Map(Object.entries(entry.instanceClasses)));
   let classMembers = /* @__PURE__ */ new Map();
@@ -29968,6 +30234,7 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
     importSymbolMap,
     aliasMap: effectiveAliasMap,
     fileFunctionNames,
+    resolveImported,
     classes: buildClassIndex([...registry.entries()].map(([, entry]) => entry)),
     hasMember: (file, classMember) => classMembers.get(file)?.has(classMember) ?? !1,
     returnTypes: (file) => registry.getFileEntry(file)?.returnTypes,
@@ -29976,29 +30243,28 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
   }, resolveReceiverCall = (call, filePath) => {
     if (!call.receiver) return;
     let receiverFile = importSymbolMap.get(filePath)?.get(call.receiver);
-    if (receiverFile) {
-      let target = memberTarget(
-        effectiveAliasMap.get(filePath)?.get(call.receiver) ?? call.receiver,
-        call.calledName,
-        receiverFile,
-        importSymbolMap,
-        fileFunctionNames,
-        instanceClasses,
-        (f, key) => registry.getFileEntry(f)?.functions.some((fn) => `${fn.className}.${fn.name}` === key)
+    if (!receiverFile) return;
+    let alias = effectiveAliasMap.get(filePath)?.get(call.receiver);
+    if (alias === "*" || namespaceNames.get(filePath)?.has(call.receiver) || isPythonModuleReceiver(receiverFile, alias ?? call.receiver, fileFunctionNames))
+      return resolvedFunctionUid(
+        repoName,
+        resolveImported(receiverFile, call.calledName),
+        fileFnClassNames
       );
-      if (target)
-        return buildFunctionUid(repoName, target.file, {
-          name: call.calledName,
-          className: target.className
-        });
-    }
-    let names = receiverFile ? fileFunctionNames.get(receiverFile) : void 0;
-    if (!receiverFile || !names) return;
-    let name = names.has(call.calledName) ? call.calledName : names.has(call.receiver) ? call.receiver : void 0;
-    return name ? buildFunctionUid(repoName, receiverFile, {
+    let name = alias ?? call.receiver, target = memberTarget(
       name,
-      className: fileFnClassNames.get(receiverFile)?.get(name)
-    }) : void 0;
+      call.calledName,
+      receiverFile,
+      importSymbolMap,
+      effectiveAliasMap,
+      resolveImported,
+      instanceClasses,
+      (f, key) => classMembers.get(f)?.has(key)
+    );
+    return target ? buildFunctionUid(repoName, target.file, {
+      name: call.calledName,
+      className: target.className
+    }) : pythonFactoryReceiverUid(repoName, typedContext.classes, receiverFile, name) ?? (functionReceiverMember(call.calledName) ? resolvedFunctionUid(repoName, resolveImported(receiverFile, name), fileFnClassNames) : void 0);
   };
   registry.resolvePendingDynamicImports();
   let registryDynamicImports = [], perFileDynImportCounts = /* @__PURE__ */ new Map();
@@ -30043,15 +30309,11 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
     }
     let viaReceiver = resolveReceiverCall(call, filePath);
     if (viaReceiver) return [viaReceiver];
+    if (call.receiver && importSymbolMap.get(filePath)?.has(call.receiver)) return [];
     let targetFile = !!call.receiver && isSelfReceiver(call.receiver) ? void 0 : importSymbolMap.get(filePath)?.get(calledName);
     if (targetFile) {
-      let originalName = effectiveAliasMap.get(filePath)?.get(calledName) ?? calledName, definingFile = fileFunctionNames.get(targetFile)?.has(originalName) ? targetFile : resolveReExport(originalName, targetFile, importSymbolMap, fileFunctionNames);
-      return definingFile ? [
-        buildFunctionUid(repoName, definingFile, {
-          name: originalName,
-          className: fileFnClassNames.get(definingFile)?.get(originalName)
-        })
-      ] : [];
+      let originalName = effectiveAliasMap.get(filePath)?.get(calledName) ?? calledName, target = resolveImported(targetFile, originalName), uid = resolvedFunctionUid(repoName, target, fileFnClassNames);
+      return uid ? [uid] : [];
     }
     return calledName !== callerName && fileFunctionNames.get(filePath)?.has(calledName) ? [
       buildFunctionUid(repoName, filePath, {
@@ -30073,8 +30335,10 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
         });
     callerName.startsWith("$module_init") && resolved.length > resolvedBefore && !topLevelCallerUids.includes(callerUid) && topLevelCallerUids.push(callerUid);
   };
-  for (let [filePath, entry] of registry.entries())
+  for (let [filePath, entry] of registry.entries()) {
+    tracingFile = filePath;
     for (let fn of entry.functions) resolveCallsOf(fn.uid, fn.name, filePath, fn.calls);
+  }
   for (let [callerUid, calls] of registry.getAllCallSites()) {
     let firstColon = callerUid.indexOf(":"), lastColon = callerUid.lastIndexOf(":");
     if (firstColon < 0 || lastColon <= firstColon) continue;
@@ -30088,8 +30352,8 @@ function traceCallChainsFromRegistry(registry, importSymbolMap, repoName, aliasM
     dynamicImports: registryDynamicImports,
     topLevelCallerUids,
     perFileDynImportCounts,
-    untraced: []
-    // it parses nothing: the chunked pipeline adds the files it couldn't trace
+    untraced: [...exhausted]
+    // the chunked pipeline adds files it could not parse or read
   };
 }
 function referenceSites(node2, callerName, skip) {
@@ -30421,8 +30685,8 @@ function declaredClass(ctx, typeName, filePath, reachable) {
     if (name = typeName.slice(dot + 1), !(module && pythonModuleName(module) === head && !ctx.fileFunctionNames.get(module)?.has(head)) || name.includes(".")) return;
     typeFile = module;
   }
-  let named = (ctx.classes.byName.get(name) ?? []).filter(reachable), importedFrom = ctx.fileFunctionNames.get(typeFile)?.has(name) ? typeFile : resolveReExport(name, typeFile, ctx.importSymbolMap, ctx.fileFunctionNames);
-  return named.find((c) => c.file === importedFrom) ?? (dot < 0 && named.length === 1 ? named[0] : void 0);
+  let target = typeFile === filePath ? { file: typeFile, name } : ctx.resolveImported(typeFile, name), named = (ctx.classes.byName.get(target?.name ?? name) ?? []).filter(reachable);
+  return named.find((c) => c.file === target?.file) ?? (dot < 0 && named.length === 1 ? named[0] : void 0);
 }
 function methodOrder(ctx, cls, fromTest) {
   let memo = fromTest ? ctx.methodOrders.test : ctx.methodOrders.production, reachable = (c) => fromTest || !c.test, ordering = /* @__PURE__ */ new Set(), external = (name) => {
@@ -30508,8 +30772,10 @@ function typedReceiverTargets(ctx, typeName, member, filePath, via = {}) {
   return targets.map((c) => ({ file: c.file, className: c.name }));
 }
 function returnedClass(ctx, fn, awaited, filePath) {
-  let name = ctx.aliasMap.get(filePath)?.get(fn) ?? fn, imported = ctx.importSymbolMap.get(filePath)?.get(fn), file = imported ? ctx.fileFunctionNames.get(imported)?.has(name) ? imported : resolveReExport(name, imported, ctx.importSymbolMap, ctx.fileFunctionNames) : filePath, declared = file ? ctx.returnTypes(file)?.get(name) : void 0;
-  if (!file || !declared || declared.promised && !awaited) return;
+  let name = ctx.aliasMap.get(filePath)?.get(fn) ?? fn, imported = ctx.importSymbolMap.get(filePath)?.get(fn), target = imported ? ctx.resolveImported(imported, name) : { file: filePath, name };
+  if (!target) return;
+  let { file } = target, declared = ctx.returnTypes(file)?.get(target.name);
+  if (!declared || declared.promised && !awaited) return;
   let fromTest = isTestFile(file);
   return declaredClass(ctx, declared.name, file, (c) => fromTest || !c.test) ? { name: declared.name, file } : void 0;
 }
@@ -30839,28 +31105,35 @@ function queryLocalBlastRadius(graph, request) {
 
 // src/analysis/local-analyzer.ts
 function analyzeSavedCallers(input2, request, parser3) {
-  let registry = new ExportRegistry(), files = [], dynamic = /* @__PURE__ */ new Map(), incomplete = input2.incomplete;
+  let registry = new ExportRegistry(), files = [], dynamic = /* @__PURE__ */ new Map(), knownFiles = new Set(input2.sources.keys()), resolver = createCapturedTypeScriptResolver(knownFiles, input2.configFiles), incomplete = input2.incomplete;
   for (let [filePath, bytes] of input2.sources)
     try {
-      let python = filePath.endsWith(".py"), parse2 = python ? parser3.parsePythonSource : parser3.parseTypeScriptSource, callFacts, pythonClasses, dynamicImports, parsed = parse2(bytes, filePath, (tree, file) => {
-        tree.hasError && (incomplete = !0), callFacts = readRegistryCallFacts(tree, file, input2.repoName), python ? pythonClasses = readPythonClasses(tree) : dynamicImports = readDynamicImportCandidates(tree);
+      let python = filePath.endsWith(".py"), parse2 = python ? parser3.parsePythonSource : parser3.parseTypeScriptSource, callFacts, pythonClasses, dynamicImports, namedReExports, parsed = parse2(bytes, filePath, (tree, file) => {
+        tree.hasError && (incomplete = !0), callFacts = readRegistryCallFacts(tree, file, input2.repoName), python ? pythonClasses = readPythonClasses(tree) : (dynamicImports = bindDynamicImportCandidates(
+          readDynamicImportCandidates(tree),
+          filePath,
+          resolver.resolveSpecifier
+        ), namedReExports = readNamedReExports(
+          tree,
+          filePath,
+          resolver.resolveSpecifier,
+          dynamicImports,
+          file.exports,
+          knownFiles
+        ));
       });
       if (files.push(parsed), registry.addFromParsed([parsed], input2.repoName), callFacts) {
         for (let [uid, sites] of callFacts.callSites)
           registry.addCallSites(uid, parsed.path, sites);
         registry.addReturnTypes(parsed.path, callFacts.returnTypes);
       }
-      pythonClasses && registry.addPythonClasses(parsed.path, pythonClasses), dynamicImports && dynamic.set(parsed.path, dynamicImports);
+      pythonClasses && registry.addPythonClasses(parsed.path, pythonClasses), namedReExports && registry.addNamedReExports(parsed.path, namedReExports), dynamicImports && dynamic.set(parsed.path, dynamicImports);
     } catch (error2) {
       if (isWasmAbort(error2)) throw error2;
       incomplete = !0;
     }
-  let resolver = createCapturedTypeScriptResolver(input2.sources.keys(), input2.configFiles);
-  for (let [filePath, candidates] of dynamic) {
-    if (candidates.length === 0) continue;
-    let sites = bindDynamicImportCandidates(candidates, filePath, resolver.resolveSpecifier);
-    registry.addDynamicImports(filePath, resolveDynamicImportSites(sites, filePath, files));
-  }
+  for (let [filePath, sites] of dynamic)
+    sites.length !== 0 && registry.addDynamicImports(filePath, resolveDynamicImportSites(sites, filePath, files));
   let stats = {
     resolvedCount: 0,
     unresolvedCount: 0,
@@ -30895,7 +31168,7 @@ function analyzeSavedCallers(input2, request, parser3) {
         functions: file.functions
       })),
       trace,
-      incomplete: incomplete || unresolvedDynamic || stats.unresolvedCount > 0
+      incomplete: incomplete || !!trace.untraced?.length || unresolvedDynamic || stats.unresolvedCount > 0
     },
     request
   );

package/package.json

@@ -1,8 +1,12 @@
 {
 	"name": "@pharaoh-so/local-analyzer",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Pharaoh-so/pharaoh.git"
+	},
 	"engines": {
 		"node": ">=18"
 	},