Add FUSE external mapping support, BG3/Oblivion Remastered fixes, fomod-plus and NaK integration

FUSE VFS now deploys non-data-dir mod mappings (Paks, OBSE, UE4SS, etc.)
via real symlinks and injects file-level data-dir mappings (plugins.txt,
loadorder.txt) into the VFS tree. Fixes game launches for Oblivion
Remastered (Root Builder path resolution, script extender support) and
BG3 (Wine prefix documents directory, file mapper symlinks on Linux).

Vendors mo2-fomod-plus plugin and NaK crate for FOMOD installer and
game finder/runtime support.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

1 files changed, 146 insertions, 0 deletions

diff --git a/libs/installer_fomod_plus/share/FOMODData/FomodDB.h b/libs/installer_fomod_plus/share/FOMODData/FomodDB.h
new file mode 100644
index 0000000..d1a9aa2
--- /dev/null
+++ b/libs/installer_fomod_plus/share/FOMODData/FomodDB.h
@@ -0,0 +1,146 @@
+#pragma once
+
+#include <fstream>
+#include <stringutil.h>
+
+#include "FomodDBEntry.h"
+
+#include <xml/ModuleConfiguration.h>
+
+#include "PluginReader.h"
+
+using FOMODDBEntries = std::vector<std::shared_ptr<FomodDbEntry> >;
+
+constexpr std::string FOMOD_DB_FILE = "fomod.db";
+
+class FomodDB {
+public:
+  /**
+   *
+   * @param moBasePath The organizer instance's basePath() value
+   * @param dbName The filename of the db. Only settable for testing purposes.
+   */
+  explicit FomodDB(const std::string &moBasePath, const std::string &dbName = FOMOD_DB_FILE) {
+    dbFilePath = (std::filesystem::path(moBasePath) / dbName).string();
+    loadFromFile();
+  }
+
+  // TODO: Also pull from non install steps (requiredInstallFiles or whatever, and optional);
+  static std::shared_ptr<FomodDbEntry> getEntryFromFomod(ModuleConfiguration *fomod, std::vector<QString> pluginPaths,
+                                                  int modId) {
+    std::vector<FomodOption> options;
+    for (const auto &installStep: fomod->installSteps.installSteps) {
+      for (const auto &group: installStep.optionalFileGroups.groups) {
+        for (const auto &plugin: group.plugins.plugins) {
+          // Create a DB entry for the given plugin if it has an ESP
+          std::cout << "\nPlugin: " << plugin.name << std::endl;
+
+          for (auto file: plugin.files.files) {
+            if (file.isFolder || !isPluginFile(file.source)) {
+              continue;
+            }
+
+            // Find the path in pluginPaths that ends with this path
+            // PluginPaths is gathered from the archive contents.
+            auto it = std::ranges::find_if(pluginPaths, [&file](const QString &path) {
+              return path.endsWith(file.source.c_str());
+            });
+            if (it == pluginPaths.end()) {
+              continue;
+            }
+            const auto &pluginPath = *it;
+            const auto masters = PluginReader::readMasters(pluginPath.toStdString(), true);
+            options.emplace_back(
+              plugin.name,
+              file.source,
+              masters,
+              installStep.name,
+              group.name
+            );
+          }
+        }
+      }
+    }
+    return std::make_shared<FomodDbEntry>(modId, fomod->moduleName, options);
+  }
+
+  void addEntry(const std::shared_ptr<FomodDbEntry> &entry, const bool upsert = true) {
+    // TODO: Test this upsert.
+    if (upsert) {
+      const auto it = std::ranges::find_if(entries, [&entry](const std::shared_ptr<FomodDbEntry> &e) {
+        return e->getModId() == entry->getModId();
+      });
+      if (it != entries.end()) {
+        *it = entry;
+      } else {
+        entries.emplace_back(entry);
+      }
+    } else {
+      entries.emplace_back(entry);
+    }
+  }
+
+  [[nodiscard]] const FOMODDBEntries &getEntries() { return entries; }
+
+  void saveToFile() const {
+    try {
+      std::ofstream file(dbFilePath);
+      if (!file.is_open()) {
+        return;
+      }
+
+      file << toJson().dump(2); // Pretty-print with 2-space indentation
+      file.close();
+    } catch ([[maybe_unused]] const std::exception &e) {
+      // Handle saving errors
+    }
+  }
+
+  [[nodiscard]] nlohmann::json toJson() const {
+    nlohmann::json jsonArray = nlohmann::json::array();
+
+    for (const auto &entry: entries) {
+      jsonArray.push_back(entry->toJson());
+    }
+
+    return jsonArray;
+  }
+
+private:
+  FOMODDBEntries entries;
+  std::string dbFilePath;
+
+  void loadFromFile() {
+    entries.clear();
+
+    // Create empty file if it doesn't exist
+    if (!std::filesystem::exists(dbFilePath)) {
+      std::ofstream file(dbFilePath);
+      file << "[]"; // Empty JSON array
+      file.close();
+      return; // No entries to load
+    }
+
+    try {
+      // Read and parse the JSON file
+      std::ifstream file(dbFilePath);
+      if (!file.is_open()) {
+        return;
+      }
+
+      nlohmann::json jsonArray = nlohmann::json::parse(file);
+
+      // Ensure it's an array
+      if (!jsonArray.is_array()) {
+        return;
+      }
+
+      // Process each entry in the array
+      for (const auto &entryJson: jsonArray) {
+        entries.push_back(std::make_unique<FomodDbEntry>(entryJson));
+      }
+    } catch ([[maybe_unused]] const std::exception &e) {
+      // Handle parsing errors (leave entries empty)
+    }
+  }
+};