diff --git a/core/relinker/CMakeLists.txt b/core/relinker/CMakeLists.txt
index f8fd8039fe66..4660de2490ce 100644
--- a/core/relinker/CMakeLists.txt
+++ b/core/relinker/CMakeLists.txt
@@ -484,6 +484,9 @@ if(BUILD_TESTING)
             ${CMAKE_CURRENT_SOURCE_DIR}/relinker/tests/test_guest_symbol_names.py $<TARGET_FILE:relinker>)
         add_test(NAME guest_registry COMMAND ${Python3_EXECUTABLE}
             ${CMAKE_CURRENT_SOURCE_DIR}/relinker/tests/test_guest_registry.py $<TARGET_FILE:relinker>)
+        add_test(NAME needed_libraries COMMAND ${Python3_EXECUTABLE}
+            ${CMAKE_CURRENT_SOURCE_DIR}/relinker/tests/test_needed_libraries.py $<TARGET_FILE:relinker>)
+        set_tests_properties(needed_libraries PROPERTIES TIMEOUT 30)
         add_test(NAME macos_output COMMAND ${Python3_EXECUTABLE}
             ${CMAKE_CURRENT_SOURCE_DIR}/relinker/tests/test_macos_output.py $<TARGET_FILE:relinker>)
         add_test(NAME guest_host_libc COMMAND ${Python3_EXECUTABLE}
diff --git a/core/relinker/domain/include/domain/Types.hpp b/core/relinker/domain/include/domain/Types.hpp
index e488940a5fdc..f505333ec730 100644
--- a/core/relinker/domain/include/domain/Types.hpp
+++ b/core/relinker/domain/include/domain/Types.hpp
@@ -101,6 +101,7 @@ struct SysVDynamicSection {
     std::map<VirtualAddress, std::string> ImportModules;
     std::set<VirtualAddress> FunctionImports;
     std::set<std::string> UnmatchedImportModules;
+    std::vector<std::string> NeededLibraries;
 };
 
 struct CallRegistryEntry {
diff --git a/core/relinker/main.cpp b/core/relinker/main.cpp
index 07f448aefce5..d7ad6f68f669 100644
--- a/core/relinker/main.cpp
+++ b/core/relinker/main.cpp
@@ -265,6 +265,7 @@ int Run(const int argc, char* argv[]) {
             checkOutputInputs(std::filesystem::absolute("windows-diagnostics-imports.txt"), "Windows import diagnostics");
 
         std::vector<std::filesystem::path> registryPaths;
+        std::vector<std::filesystem::path> neededPaths;
         if (args.writeRegistry) {
             for (const auto& executable : executables) {
                 const std::filesystem::path outFsPath = Io::NativePath(executable.OutputPath);
@@ -274,6 +275,12 @@ int Run(const int argc, char* argv[]) {
             for (const auto& artifact : guestArtifacts)
                 registryPaths.push_back(outFsPath.parent_path() / Io::NativePath(Io::Utf8Path(outFsPath.stem()) + "." + Io::Utf8Path(artifact.Path.filename()) + ".registry.json"));
             for (const auto& path : registryPaths) checkOutputInputs(path, "Registry");
+            for (const auto& path : registryPaths) {
+                auto name = Io::Utf8Path(path.filename());
+                name.resize(name.size() - std::string(".registry.json").size());
+                neededPaths.push_back(path.parent_path() / Io::NativePath(name + ".needed.json"));
+            }
+            for (const auto& path : neededPaths) checkOutputInputs(path, "Needed libraries");
         }
 
         checkOutputInputs(Io::NativePath(absPath), "Executable");
@@ -312,10 +319,14 @@ int Run(const int argc, char* argv[]) {
         }
         if (args.writeRegistry) {
             const auto registryWriter = std::make_shared<Relinker::CallRegistryWriter>();
-            for (std::size_t index = 0; index < executables.size(); ++index)
+            for (std::size_t index = 0; index < executables.size(); ++index) {
                 fileWriter.Write(Io::Utf8Path(registryPaths[index]), registryWriter->WriteCallRegistry(executables[index].Result.RegistryEntries));
-            for (std::size_t index = 0; index < guestArtifacts.size(); ++index)
+                fileWriter.Write(Io::Utf8Path(neededPaths[index]), registryWriter->WriteNeededLibraries(executables[index].Result.DynamicSection.NeededLibraries));
+            }
+            for (std::size_t index = 0; index < guestArtifacts.size(); ++index) {
                 fileWriter.Write(Io::Utf8Path(registryPaths[executables.size() + index]), registryWriter->WriteModuleImports(guestArtifacts[index].Imports));
+                fileWriter.Write(Io::Utf8Path(neededPaths[executables.size() + index]), registryWriter->WriteNeededLibraries(guestArtifacts[index].NeededLibraries));
+            }
         }
         progress.Finish();
         if (desktopEntry) std::cout << "Desktop entry: " << Io::Utf8Path(desktopEntryWriter.Write(*desktopEntry)) << '\n';
diff --git a/core/relinker/relinker/include/relinker/domain/ICallRegistryWriter.hpp b/core/relinker/relinker/include/relinker/domain/ICallRegistryWriter.hpp
index d528667e9734..57f2e9c218dd 100644
--- a/core/relinker/relinker/include/relinker/domain/ICallRegistryWriter.hpp
+++ b/core/relinker/relinker/include/relinker/domain/ICallRegistryWriter.hpp
@@ -13,6 +13,7 @@ class ICallRegistryWriter {
 
     virtual std::string WriteCallRegistry(const std::vector<CallRegistryEntry>& entries) = 0;
     virtual std::string WriteModuleImports(const std::vector<CallRegistryEntry>& entries) = 0;
+    virtual std::string WriteNeededLibraries(const std::vector<std::string>& libraries) = 0;
 };
 
 }
diff --git a/core/relinker/relinker/include/relinker/guest/GuestImage.hpp b/core/relinker/relinker/include/relinker/guest/GuestImage.hpp
index bef96dbe10ed..31e5781a547f 100644
--- a/core/relinker/relinker/include/relinker/guest/GuestImage.hpp
+++ b/core/relinker/relinker/include/relinker/guest/GuestImage.hpp
@@ -66,6 +66,7 @@ struct GuestArtifact {
     std::vector<std::uint8_t> Bytes;
     std::vector<Domain::CallRegistryEntry> Imports;
     std::filesystem::path SourcePath;
+    std::vector<std::string> NeededLibraries;
 };
 
 struct GuestModuleInput {
diff --git a/core/relinker/relinker/include/relinker/output/CallRegistryWriter.hpp b/core/relinker/relinker/include/relinker/output/CallRegistryWriter.hpp
index 79b196f86932..5c16c9057b61 100644
--- a/core/relinker/relinker/include/relinker/output/CallRegistryWriter.hpp
+++ b/core/relinker/relinker/include/relinker/output/CallRegistryWriter.hpp
@@ -9,6 +9,7 @@ class CallRegistryWriter : public ICallRegistryWriter {
 public:
     std::string WriteCallRegistry(const std::vector<CallRegistryEntry>& entries) override;
     std::string WriteModuleImports(const std::vector<CallRegistryEntry>& entries) override;
+    std::string WriteNeededLibraries(const std::vector<std::string>& libraries) override;
 };
 
 }
diff --git a/core/relinker/relinker/src/guest/GuestModuleBuilder.cpp b/core/relinker/relinker/src/guest/GuestModuleBuilder.cpp
index d7598f0a26cd..b9844c22cf6a 100644
--- a/core/relinker/relinker/src/guest/GuestModuleBuilder.cpp
+++ b/core/relinker/relinker/src/guest/GuestModuleBuilder.cpp
@@ -277,6 +277,7 @@ std::vector<GuestArtifact> GuestModuleBuilder::Build(const std::filesystem::path
     for (const auto& name : neededNames) addHost(name);
     for (const auto& image : images) for (const auto& dependency : image.Dependencies) addHost(dependency);
     if (uniqueHosts.contains("libSceLibcInternal.prx") && uniqueHosts.insert("libc.prx").second) hostLibraries.push_back("libc.prx");
+    dynamic.NeededLibraries = hostLibraries;
     dynamic.DynamicSegmentData.clear();
     const auto addNeeded = [&](const std::string& name) {
         Io::AppendU64(dynamic.DynamicSegmentData, 1);
@@ -356,7 +357,10 @@ std::vector<GuestArtifact> GuestModuleBuilder::Build(const std::filesystem::path
             }
         }
         dynamic.GuestModules.push_back(std::move(runtime));
-        artifacts.push_back({target, std::move(output), std::move(imports), image.SourcePath});
+        std::vector<std::string> neededLibraries;
+        for (const auto& name : image.Dependencies)
+            if (findGuest(name) == guestNames.end()) neededLibraries.push_back(name);
+        artifacts.push_back({target, std::move(output), std::move(imports), image.SourcePath, std::move(neededLibraries)});
         progress.Report({Domain::ProgressStage::Modules, Io::Utf8Path(image.SourcePath), artifacts.size(), order.size()});
     }
     return artifacts;
diff --git a/core/relinker/relinker/src/output/CallRegistryWriter.cpp b/core/relinker/relinker/src/output/CallRegistryWriter.cpp
index 7c8c909e6306..8fbd461e8962 100644
--- a/core/relinker/relinker/src/output/CallRegistryWriter.cpp
+++ b/core/relinker/relinker/src/output/CallRegistryWriter.cpp
@@ -82,4 +82,16 @@ std::string CallRegistryWriter::WriteModuleImports(const std::vector<CallRegistr
     return out.str();
 }
 
+std::string CallRegistryWriter::WriteNeededLibraries(const std::vector<std::string>& libraries) {
+    std::ostringstream out;
+    out << "[\n";
+    for (std::size_t index = 0; index < libraries.size(); ++index) {
+        out << "  " << _jsonString(libraries[index]);
+        if (index + 1 < libraries.size()) out << ",";
+        out << "\n";
+    }
+    out << "]\n";
+    return out.str();
+}
+
 }
diff --git a/core/relinker/relinker/src/output/SysVDynamicSectionBuilder.cpp b/core/relinker/relinker/src/output/SysVDynamicSectionBuilder.cpp
index 32cb6523c4ee..0d8bdd763fef 100644
--- a/core/relinker/relinker/src/output/SysVDynamicSectionBuilder.cpp
+++ b/core/relinker/relinker/src/output/SysVDynamicSectionBuilder.cpp
@@ -68,6 +68,7 @@ SysVDynamicSection SysVDynamicSectionBuilder::BuildDynamicSection(
     std::uint32_t originalJmprelCount)
 {
     SysVDynamicSection result;
+    result.NeededLibraries = neededLibraries;
     result.DynStrData.push_back(0);
 
     std::vector<std::uint32_t> neededOffsets;
diff --git a/core/relinker/relinker/tests/test_call_registry.py b/core/relinker/relinker/tests/test_call_registry.py
index a3d02c7d2802..1bc1749afeb5 100644
--- a/core/relinker/relinker/tests/test_call_registry.py
+++ b/core/relinker/relinker/tests/test_call_registry.py
@@ -38,6 +38,9 @@ def main():
                              "callSites": ["0x200"], "callSitesResolved": True, "weak": False}]
                 if entries != expected:
                     raise AssertionError((name, options, entries))
+                needed = json.loads(output.with_suffix(".needed.json").read_text(encoding="utf-8"))
+                if needed != ["lib.so"]:
+                    raise AssertionError((name, options, needed))
         strings = b"\0lib.so\0" + names[0].encode("utf-8") + b"\0"
         image = fixture(str_size=len(strings), table_bytes=strings)
         struct.pack_into("<H", image, 56, 6)
diff --git a/core/relinker/relinker/tests/test_guest_registry.py b/core/relinker/relinker/tests/test_guest_registry.py
index 4699f65f7680..1e63a165ac80 100644
--- a/core/relinker/relinker/tests/test_guest_registry.py
+++ b/core/relinker/relinker/tests/test_guest_registry.py
@@ -59,6 +59,8 @@ def main():
             assert libc == [entry("CCCCCCCCCCC", "0x2388"), entry("CCCCCCCCCCC", "0x2390")], (name, libc)
             other = read(output.parent / "output.other.prx.guest.prx.registry.json")
             assert other == [], (name, other)
+            assert read(output.with_suffix(".needed.json")) == []
+            assert read(output.parent / "output.libc.prx.guest.prx.needed.json") == []
             main_nids = [item["nid"] for item in read(output.parent / "output.registry.json")]
             expected = [] if options else ["AAAAAAAAAAA#A#A", "DDDDDDDDDDD#D#D"]
             assert main_nids == expected, (name, main_nids)
@@ -70,6 +72,7 @@ def main():
             plain = convert(relinker, work / (name + "-plain"), options, registry=False)
             written = sorted(path.name for path in plain.parent.glob("*.registry.json"))
             assert written == [], (name, written)
+            assert list(plain.parent.glob("*.needed.json")) == [], name
     print("Guest module registry tests passed")
 
 
diff --git a/core/relinker/relinker/tests/test_input_preservation.py b/core/relinker/relinker/tests/test_input_preservation.py
index 10e7c5117882..5ea4db3367c4 100644
--- a/core/relinker/relinker/tests/test_input_preservation.py
+++ b/core/relinker/relinker/tests/test_input_preservation.py
@@ -74,21 +74,22 @@ def check_diagnostic_inputs(relinker, work):
             assert diagnostics.read_bytes() == (b"" if enabled else original)
 
 
-def check_registry_inputs(relinker, work, windows):
+def check_registry_inputs(relinker, work, windows, needed=False):
     options = ["--windows"] if windows else []
     for module_registry in (False, True):
         for bundled in (False, True):
             for alias in ("direct", "hardlink", "symlink"):
                 if bundled and alias == "direct":
                     continue
-                case = work / f"registry-{windows}-{module_registry}-{bundled}-{alias}"
+                case = work / f"registry-{windows}-{module_registry}-{bundled}-{alias}-{needed}"
                 modules = case / "sce_module"
                 modules.mkdir(parents=True)
                 module = modules / "sample.prx"
                 module_original = bytes(guest_fixture(PLAIN_SITE))
                 module.write_bytes(module_original)
                 output = case / ("output.exe" if windows else "output.elf")
-                registries = [case / "output.registry.json", case / "output.sample.prx.guest.prx.registry.json"]
+                suffix = ".needed.json" if needed else ".registry.json"
+                registries = [case / ("output" + suffix), case / ("output.sample.prx.guest.prx" + suffix)]
                 registry = registries[int(module_registry)]
                 source = registry if alias == "direct" else case / "input.elf"
                 original = bytes(main_fixture())
@@ -111,7 +112,8 @@ def check_registry_inputs(relinker, work, windows):
                 output.write_bytes(previous_output)
                 result = subprocess.run([str(relinker), *options, "--registry", str(source), str(output)],
                                         capture_output=True, text=True, timeout=20)
-                expected = "Registry output would overwrite an input module" if bundled else "Registry output would overwrite the input executable"
+                kind = "Needed libraries" if needed else "Registry"
+                expected = f"{kind} output would overwrite an input module" if bundled else f"{kind} output would overwrite the input executable"
                 assert result.returncode == 2 and expected in result.stderr, (result.returncode, result.stdout, result.stderr)
                 assert source.read_bytes() == original and module.read_bytes() == module_original
                 assert output.read_bytes() == previous_output and untouched.read_bytes() == previous_registry
@@ -130,7 +132,8 @@ def check_registry_after_failed_patch(relinker, work):
     output = case / "output.exe"
     previous_output = b"previous executable"
     output.write_bytes(previous_output)
-    registries = [case / "output.registry.json", case / "output.sample.prx.guest.prx.registry.json"]
+    registries = [case / "output.registry.json", case / "output.sample.prx.guest.prx.registry.json",
+                  case / "output.needed.json", case / "output.sample.prx.guest.prx.needed.json"]
     previous_registry = b"previous registry"
     for registry in registries:
         registry.write_bytes(previous_registry)
@@ -228,6 +231,7 @@ def main():
         for windows in (False, True):
             options = ["--windows"] if windows else []
             check_registry_inputs(relinker, work, windows)
+            check_registry_inputs(relinker, work, windows, needed=True)
             for bundled in (False, True):
                 for alias in ("direct", "normalized", "hardlink", "symlink"):
                     case = work / f"{windows}-{bundled}-{alias}"
diff --git a/core/relinker/relinker/tests/test_needed_libraries.py b/core/relinker/relinker/tests/test_needed_libraries.py
new file mode 100644
index 000000000000..9bf39efb8f57
--- /dev/null
+++ b/core/relinker/relinker/tests/test_needed_libraries.py
@@ -0,0 +1,92 @@
+import json
+from pathlib import Path
+import struct
+import subprocess
+import sys
+import tempfile
+
+from test_guest_intel_trampolines import PLAIN_SITE, guest_fixture
+from test_guest_symbol_names import importing_executable
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[4] / "tools"))
+import import_audit
+
+
+def named_module(tag):
+    image = guest_fixture(PLAIN_SITE)
+    strings = b"\0Party.prx\0"
+    image[0x800:0x800 + len(strings)] = strings
+    struct.pack_into("<Q", image, 0x618, len(strings))
+    struct.pack_into("<qQqQ", image, 0x680, tag, 1, 0, 0)
+    struct.pack_into("<QQ", image, 208, 10 * 16, 10 * 16)
+    return image
+
+
+def executable_with_dependencies(libraries):
+    image = importing_executable([], modules=libraries)
+    dynamic_size, = struct.unpack_from("<Q", image, 152)
+    struct.pack_into("<qQqQ", image, 0x4800 + dynamic_size - 16, 0x6100003F, 24, 0, 0)
+    struct.pack_into("<QQ", image, 152, dynamic_size + 16, dynamic_size + 16)
+    return image
+
+
+def main():
+    relinker = Path(sys.argv[1]).resolve()
+    with tempfile.TemporaryDirectory(prefix="anyps5-needed-libraries-") as directory:
+        work = Path(directory)
+        for windows in (False, True):
+            for bundled in (False, True):
+                case = work / f"{windows}-{bundled}"
+                modules = case / "sce_module"
+                modules.mkdir(parents=True)
+                source = case / "input.elf"
+                source.write_bytes(executable_with_dependencies([] if bundled else ["Party"]))
+                if bundled:
+                    (modules / "engine.prx").write_bytes(named_module(1))
+                output = case / ("output.exe" if windows else "output.elf")
+                result = subprocess.run([str(relinker), "--registry", "unused-filter=2",
+                                         *(["--windows"] if windows else []), str(source), str(output)],
+                                        capture_output=True, text=True, timeout=20)
+                assert result.returncode == 0, (windows, bundled, result.stdout, result.stderr)
+                registry = case / ("output.engine.prx.guest.prx.registry.json" if bundled else "output.registry.json")
+                assert json.loads(registry.read_text()) == [], (windows, bundled)
+                needed = import_audit.read_needed_registry(import_audit.needed_registry_path(registry))
+                assert needed == ["Party.prx"], (windows, bundled, needed)
+                records, missing = import_audit.audit(import_audit.read_registry(registry), {}, {}, set(), set(), needed_libraries=needed)
+                assert records == [] and missing == {"Party.prx": 0}, (records, missing)
+                (modules / "provider.prx").write_bytes(named_module(14))
+                result = subprocess.run([str(relinker), "--registry", *(["--windows"] if windows else []),
+                                         str(source), str(output)], capture_output=True, text=True, timeout=20)
+                assert result.returncode == 0, (windows, bundled, result.stdout, result.stderr)
+                needed = import_audit.read_needed_registry(import_audit.needed_registry_path(registry))
+                assert needed == [], (windows, bundled, needed)
+                assert import_audit.audit([], {}, {}, set(), set(), needed_libraries=needed) == ([], {})
+        for windows in (False, True):
+            case = work / f"executables-{windows}"
+            picker = case / "picker" / "picker.bin"
+            picker.parent.mkdir(parents=True)
+            modules = case / "sce_module"
+            modules.mkdir()
+            picker.write_bytes(executable_with_dependencies(["Party"]))
+            source = case / "input.elf"
+            source.write_bytes(executable_with_dependencies([]))
+            output = case / ("output.exe" if windows else "output.elf")
+            command = [str(relinker), "--registry", "--executable", "picker/picker.bin",
+                       *(["--windows"] if windows else []), str(source), str(output)]
+            result = subprocess.run(command, capture_output=True, text=True, timeout=20)
+            assert result.returncode == 0, (windows, result.stdout, result.stderr)
+            main_needed = case / "output.needed.json"
+            picker_needed = case / "picker.picker.bin.needed.json"
+            assert import_audit.read_needed_registry(main_needed) == []
+            assert import_audit.read_needed_registry(picker_needed) == ["Party.prx"]
+            (modules / "provider.prx").write_bytes(named_module(14))
+            result = subprocess.run(command, capture_output=True, text=True, timeout=20)
+            assert result.returncode == 0, (windows, result.stdout, result.stderr)
+            assert import_audit.read_needed_registry(main_needed) == []
+            assert import_audit.read_needed_registry(picker_needed) == []
+            assert import_audit.read_needed_registry(case / "output.provider.prx.guest.prx.needed.json") == []
+    print("Dependency-only library audit tests passed")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/user/USAGE.md b/docs/user/USAGE.md
index d21e304eb097..6f7391b4eb1e 100644
--- a/docs/user/USAGE.md
+++ b/docs/user/USAGE.md
@@ -215,7 +215,9 @@ python3 tools/import_audit.py app.registry.json app.libc.prx.guest.prx.registry.
 
 Each `--modules` file is also audited itself: its undefined symbols are classified against the built libraries and the other modules' exports, with the module file named in the report, and the libraries it needs must have a file in `--libs` or `--modules`. The audit reads dynamic tables from ELF section headers or, for sectionless files, from `PT_DYNAMIC` and a SysV or GNU hash table.
 
-The report also lists needed libraries that have no file in `--libs` or `--modules`, and imports exported only by a library other than the one they name; those resolve on Linux and can fail on Windows.
+Each registry has a companion with the same prefix and the suffix `.needed.json`, listing its host library dependencies, including declared `DT_NEEDED` entries with no imports. Dependencies supplied by converted bundled modules, including their aliases, are omitted. The executable's companion includes host dependencies of its bundled modules. The audit reads these companions automatically; keep them beside the registries. Older registries without companions still work, but cannot report dependencies that have no imports; regenerate them with `--registry` to include those dependencies.
+
+The report also lists needed libraries that have no file in `--libs` or `--modules`, including dependencies with zero imports. These do not increase the import or reference counts. Windows can skip a missing dependency when no import needs it; Linux still needs the file. The audit also lists imports exported only by a library other than the one they name; those resolve on Linux and can fail on Windows.
 
 | Option | Effect |
 |--------|--------|
diff --git a/tools/import_audit.py b/tools/import_audit.py
index 0018387f28c2..4c1c8354984f 100644
--- a/tools/import_audit.py
+++ b/tools/import_audit.py
@@ -404,6 +404,20 @@ def read_registry(path):
     return imports
 
 
+def needed_registry_path(path):
+    return path.with_name(path.name.removesuffix(".registry.json") + ".needed.json")
+
+
+def read_needed_registry(path):
+    try:
+        libraries = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise AuditError(f"{path}: cannot read needed libraries: {error}") from error
+    if not isinstance(libraries, list) or any(not isinstance(library, str) or not library for library in libraries):
+        raise AuditError(f"{path}: needed libraries must be a JSON list of nonempty strings")
+    return libraries
+
+
 def check_conservation(references, records):
     classified = sum(record["references"] for record in records)
     unknown = sorted({record["class"] for record in records} - set(CLASSES))
@@ -421,7 +435,7 @@ def classify(nid, library, providers, stubs, modules):
     return "implemented"
 
 
-def audit(imports, exports, stubs, libraries, modules, module_imports=None, module_exports=None):
+def audit(imports, exports, stubs, libraries, modules, module_imports=None, module_exports=None, *, needed_libraries=()):
     records = {}
     for nid, library, weak in imports:
         record = records.setdefault((nid, library), {"nid": nid, "library": library, "references": 0, "weak": weak})
@@ -444,6 +458,9 @@ def audit(imports, exports, stubs, libraries, modules, module_imports=None, modu
     ordered = sorted(records.values(), key=lambda record: (record["class"], record["library"] or "", record.get("module") or "", record["nid"]))
     check_conservation(len(imports) + sum(len(symbols) for symbols, _ in (module_imports or {}).values()), ordered)
     missing = defaultdict(int)
+    for library in needed_libraries:
+        if library not in libraries and library not in modules:
+            missing[library] = 0
     for record in ordered:
         library = record["library"]
         if library and library not in libraries and library not in modules:
@@ -554,6 +571,8 @@ def render(summary, records, missing, stops):
         lines.append("")
         lines.append(f"Needed libraries with no file in --libs or --modules ({len(missing)})")
         lines.extend(f"  {library}: {count} imports" for library, count in missing.items())
+        if any(count == 0 for count in missing.values()):
+            lines.append("  Libraries with 0 imports are declared dependencies; Windows can skip them if no import needs them")
     if summary["library_mismatch"]:
         lines.append("")
         lines.append(f"{summary['library_mismatch']} imports are exported only by a library other than the one they name: they resolve on Linux and can fail on Windows")
@@ -571,8 +590,10 @@ def main(argv=None):
     parser.add_argument("--strict-providers", action="store_true", help="fail when a named import is provided only by another library; retains the existing libc and title-module rules")
     args = parser.parse_args(argv)
     try:
+        dependency_registries = [needed_registry_path(path) for path in args.registries if path.name.endswith(".registry.json")]
+        dependency_registries = [path for path in dependency_registries if path.exists()]
         if args.json:
-            inputs = args.registries + ([Path(args.names)] if args.names else [])
+            inputs = args.registries + dependency_registries + ([Path(args.names)] if args.names else [])
             inputs += [file for directory in args.libs for file in directory_files(directory, "*.prx")]
             inputs += [file for directory in args.modules for file in directory_files(directory, "*")]
             inputs += list(Path(args.source).rglob("*.cpp"))
@@ -581,9 +602,10 @@ def main(argv=None):
                 raise AuditError(f"{args.json}: JSON output would overwrite an input file")
         registries = [(registry, read_registry(registry)) for registry in args.registries]
         imports = [entry for _, entries in registries for entry in entries]
+        needed = sorted({library for path in dependency_registries for library in read_needed_registry(path)})
         exports, libraries = built_libraries(args.libs)
         module_imports, module_exports = read_modules(args.modules)
-        records, missing = audit(imports, exports, source_stubs(args.source), libraries, set(module_imports), module_imports, module_exports)
+        records, missing = audit(imports, exports, source_stubs(args.source), libraries, set(module_imports), module_imports, module_exports, needed_libraries=needed)
         if args.names:
             attach_names(records, load_names(args.names))
         summary = summarize(records, sum(record["references"] for record in records), missing)
@@ -594,7 +616,7 @@ def main(argv=None):
                            "nid": entry["stop"]["nid"] if entry["stop"] else None,
                            "library": entry["stop"]["library"] if entry["stop"] else None,
                            "name": entry["stop"]["name"] if entry["stop"] else None} for entry in stops]
-            result = {"source_commit": commit, "source_dirty": dirty, "registries": [str(path) for path in args.registries], **summary, "stops": json_stops, "imports": records}
+            result = {"source_commit": commit, "source_dirty": dirty, "registries": [str(path) for path in args.registries], "dependency_registries": [str(path) for path in dependency_registries], "needed_libraries": needed, **summary, "stops": json_stops, "imports": records}
             write_json(args.json, result)
     except AuditError as error:
         print(f"FAIL: {error}", file=sys.stderr)
diff --git a/tools/tests/test_import_audit.py b/tools/tests/test_import_audit.py
index aa8393cde517..a1f66df1fb75 100644
--- a/tools/tests/test_import_audit.py
+++ b/tools/tests/test_import_audit.py
@@ -165,9 +165,9 @@ def __init__(self):
     def close(self):
         self._directory.cleanup()
 
-    def run(self, registry, *extra):
+    def run(self, registry, *extra, registries=()):
         out, err = io.StringIO(), io.StringIO()
-        arguments = [str(registry), "--libs", str(self.libs), "--modules", str(self.modules), "--source", str(self.source), *extra]
+        arguments = [str(registry), *map(str, registries), "--libs", str(self.libs), "--modules", str(self.modules), "--source", str(self.source), *extra]
         with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
             code = import_audit.main(arguments)
         return code, out.getvalue(), err.getvalue()
@@ -598,6 +598,73 @@ def test_removing_an_export_flips_the_class(self):
         self.assertEqual(code, 1)
         self.assertIn("AAAAAAAAAAA", out)
 
+    def test_needed_library_without_imports_is_reported(self):
+        work = self.work
+        (work.libs / "libSceA.prx").write_bytes(exporting("AAAAAAAAAAA"))
+        registry = work.root / "game.registry.json"
+        write_registry(registry, [("AAAAAAAAAAA", "libSceA.prx")])
+        needed = work.root / "game.needed.json"
+        needed.write_text(json.dumps(["libSceA.prx", "Party.prx", "Party.prx"]))
+        result = work.root / "audit.json"
+        code, out, err = work.run(registry, "--json", str(result))
+        self.assertEqual((code, err), (1, ""))
+        data = json.loads(result.read_text())
+        self.assertEqual(data["missing_libraries"], {"Party.prx": 0})
+        self.assertEqual((data["references"], data["unique_imports"]), (1, 1))
+        self.assertIn("Party.prx: 0 imports", out)
+        self.assertEqual(data["needed_libraries"], ["Party.prx", "libSceA.prx"])
+        (work.modules / "Party.prx").write_bytes(exporting())
+        self.assertEqual(work.run(registry)[0], 0)
+        (work.modules / "Party.prx").unlink()
+        (work.libs / "Party.prx").write_bytes(exporting())
+        self.assertEqual(work.run(registry)[0], 0)
+
+    def test_needed_libraries_from_empty_and_module_registries(self):
+        work = self.work
+        (work.libs / "libSceA.prx").write_bytes(exporting())
+        registry = work.root / "game.registry.json"
+        module_registry = work.root / "game.engine.prx.guest.prx.registry.json"
+        write_registry(registry, [])
+        write_registry(module_registry, [])
+        (work.root / "game.needed.json").write_text('["Party.prx"]')
+        (work.root / "game.engine.prx.guest.prx.needed.json").write_text('["Party.prx", "libSceOther.prx"]')
+        result = work.root / "audit.json"
+        code, out, err = work.run(registry, "--json", str(result), registries=[module_registry])
+        self.assertEqual((code, err), (1, ""))
+        data = json.loads(result.read_text())
+        self.assertEqual(data["missing_libraries"], {"Party.prx": 0, "libSceOther.prx": 0})
+        self.assertEqual((data["references"], data["unique_imports"], data["imports"]), (0, 0, []))
+        self.assertIn("0 references, 0 unique imports", out)
+
+    def test_invalid_needed_registry_fails_instead_of_ignoring_it(self):
+        work = self.work
+        (work.libs / "libSceA.prx").write_bytes(exporting())
+        registry = work.root / "game.registry.json"
+        write_registry(registry, [])
+        needed = work.root / "game.needed.json"
+        for text in ('{', '{}', '[42]', '[""]'):
+            with self.subTest(text=text):
+                needed.write_text(text)
+                code, out, err = work.run(registry)
+                self.assertEqual((code, out), (2, ""))
+                self.assertIn(str(needed), err)
+
+    def test_json_output_cannot_overwrite_needed_registry(self):
+        work = self.work
+        (work.libs / "libSceA.prx").write_bytes(exporting())
+        registry = work.root / "game.registry.json"
+        write_registry(registry, [])
+        needed = work.root / "game.needed.json"
+        needed.write_text('["Party.prx"]')
+        alias = work.root / "needed-alias.json"
+        os.link(needed, alias)
+        for output in (needed, alias):
+            with self.subTest(output=output):
+                code, out, err = work.run(registry, "--json", str(output))
+                self.assertEqual((code, out), (2, ""))
+                self.assertIn("overwrite an input", err)
+                self.assertEqual(needed.read_text(), '["Party.prx"]')
+
     def test_source_stubs(self):
         source = self.work.source
         write_source(source, "libSceTwin", STUB_SOURCE.format(name="sceTwinCall") + STUB_SOURCE.format(name="printf_nid_postfix"))