[qlaunch] pull eden github releases as news to news applet

src/core/CMakeLists.txt

@@ -563,8 +563,14 @@ add_library(core STATIC
     hle/service/bcat/delivery_cache_storage_service.h
     hle/service/bcat/news/newly_arrived_event_holder.cpp
     hle/service/bcat/news/newly_arrived_event_holder.h
+    hle/service/bcat/news/msgpack.cpp
+    hle/service/bcat/news/msgpack.h
     hle/service/bcat/news/news_data_service.cpp
     hle/service/bcat/news/news_data_service.h
+    hle/service/bcat/news/builtin_news.cpp
+    hle/service/bcat/news/builtin_news.h
+    hle/service/bcat/news/news_storage.cpp
+    hle/service/bcat/news/news_storage.h
     hle/service/bcat/news/news_database_service.cpp
     hle/service/bcat/news/news_database_service.h
     hle/service/bcat/news/news_service.cpp
@@ -1206,9 +1212,8 @@ else()
 endif()
 
 target_link_libraries(core PRIVATE fmt::fmt nlohmann_json::nlohmann_json RenderDoc::API MbedTLS::mbedcrypto${MBEDTLS_LIB_SUFFIX} MbedTLS::mbedtls${MBEDTLS_LIB_SUFFIX})
-# if (MINGW)
-#     target_link_libraries(core PRIVATE ws2_32 mswsock wlanapi)
-# endif()
+
+target_link_libraries(core PRIVATE httplib::httplib)
 
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PUBLIC ENABLE_WEB_SERVICE)

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -0,0 +1,455 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/builtin_news.h"
+#include "core/hle/service/bcat/news/msgpack.h"
+#include "core/hle/service/bcat/news/news_storage.h"
+
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+
+#include <fmt/format.h>
+#include <httplib.h>
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <mutex>
+#include <optional>
+#include <sstream>
+
+namespace Service::News {
+namespace {
+
+constexpr const char* GitHubAPI_EdenReleases = "/repos/eden-emulator/Releases/releases";
+
+// Cached logo data
+std::vector<u8> g_logo_cache;
+bool g_logo_loaded = false;
+
+std::filesystem::path GetCachePath() {
+    return Common::FS::GetEdenPath(Common::FS::EdenPath::CacheDir) / "news" / "github_releases.json";
+}
+
+std::filesystem::path GetLogoPath() {
+    return Common::FS::GetEdenPath(Common::FS::EdenPath::CacheDir) / "news" / "eden_logo.jpg";
+}
+
+u32 HashToNewsId(std::string_view key) {
+    return static_cast<u32>(std::hash<std::string_view>{}(key) & 0x7FFFFFFF);
+}
+
+u64 ParseIsoTimestamp(const std::string& iso) {
+    if (iso.empty()) return 0;
+
+    std::string buf = iso;
+    if (buf.back() == 'Z') buf.pop_back();
+
+    std::tm tm{};
+    std::istringstream ss(buf);
+    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+    if (ss.fail()) return 0;
+
+#ifdef _WIN32
+    return static_cast<u64>(_mkgmtime(&tm));
+#else
+    return static_cast<u64>(timegm(&tm));
+#endif
+}
+
+std::vector<u8> LoadLogo() {
+    if (g_logo_loaded) {
+        return g_logo_cache;
+    }
+    g_logo_loaded = true;
+
+    const auto logo_path = GetLogoPath();
+
+    // Try loading from cached disk
+    if (std::filesystem::exists(logo_path)) {
+        std::ifstream f(logo_path, std::ios::binary | std::ios::ate);
+        if (f) {
+            const auto file_size = static_cast<std::streamsize>(f.tellg());
+            if (file_size > 0 && file_size < 10 * 1024 * 1024) {
+                f.seekg(0);
+                g_logo_cache.resize(static_cast<size_t>(file_size));
+                if (f.read(reinterpret_cast<char*>(g_logo_cache.data()), file_size)) {
+                    return g_logo_cache;
+                }
+            }
+        }
+    }
+
+    // yes...i uploaded it to imgur
+    try {
+        httplib::Client cli("https://i.imgur.com");
+        cli.set_follow_location(true);
+        cli.set_connection_timeout(std::chrono::seconds(10));
+        cli.set_read_timeout(std::chrono::seconds(30));
+
+        if (auto res = cli.Get("/1OuqHlk.jpeg"); res && res->status == 200 && !res->body.empty()) {
+            g_logo_cache.assign(res->body.begin(), res->body.end());
+
+            std::error_code ec;
+            std::filesystem::create_directories(logo_path.parent_path(), ec);
+            if (std::ofstream out(logo_path, std::ios::binary); out) {
+                out.write(res->body.data(), static_cast<std::streamsize>(res->body.size()));
+            }
+            return g_logo_cache;
+        }
+    } catch (...) {
+        LOG_WARNING(Service_BCAT, "failed to download eden logo");
+    }
+
+    return {};
+}
+
+std::optional<std::string> ReadCachedJson() {
+    const auto path = GetCachePath();
+    if (!std::filesystem::exists(path)) return std::nullopt;
+
+    auto content = Common::FS::ReadStringFromFile(path, Common::FS::FileType::TextFile);
+    return content.empty() ? std::nullopt : std::optional{std::move(content)};
+}
+
+void WriteCachedJson(std::string_view json) {
+    const auto path = GetCachePath();
+    std::error_code ec;
+    std::filesystem::create_directories(path.parent_path(), ec);
+    (void)Common::FS::WriteStringToFile(path, Common::FS::FileType::TextFile, json);
+}
+
+std::optional<std::string> DownloadReleasesJson() {
+    try {
+        httplib::SSLClient cli{"api.github.com", 443};
+        cli.set_connection_timeout(10);
+        cli.set_read_timeout(10);
+
+        httplib::Headers headers{
+            {"User-Agent", "eden"},
+            {"Accept", "application/vnd.github+json"},
+        };
+
+        if (auto res = cli.Get(GitHubAPI_EdenReleases, headers); res && res->status < 400) {
+            return res->body;
+        }
+    } catch (...) {
+        LOG_WARNING(Service_BCAT, " failed to download releases");
+    }
+}
+
+// idk but News App does not render Markdown or HTML, so remove some formatting.
+std::string SanitizeMarkdown(std::string_view markdown) {
+    std::string result;
+    result.reserve(markdown.size());
+
+    // our current structure for markdown is after "# Packages" remove everything.
+    std::string text{markdown};
+    if (auto pos = text.find("# Packages"); pos != std::string::npos) {
+        text = text.substr(0, pos);
+    }
+
+    std::istringstream stream(text);
+    std::string line;
+    bool first_line = true;
+
+    while (std::getline(stream, line)) {
+        if (!line.empty() && line.back() == '\r') {
+            line.pop_back();
+        }
+
+        if (first_line && line.empty()) continue;
+
+        // Remove markdown headers
+        size_t start = 0;
+        while (start < line.size() && line[start] == '#') start++;
+        if (start > 0 && start < line.size() && line[start] == ' ') {
+            line = line.substr(start + 1);
+        }
+
+        // Remove bold/italic marker
+        std::string cleaned;
+        size_t i = 0;
+        while (i < line.size()) {
+            if (i + 1 < line.size() && line[i] == '*' && line[i + 1] == '*') {
+                i += 2;
+            } else if (line[i] == '*' || line[i] == '_') {
+                i++;
+            } else {
+                cleaned += line[i++];
+            }
+        }
+        line = cleaned;
+
+        // Remove links and convert it to text
+        std::string no_links;
+        i = 0;
+        while (i < line.size()) {
+            if (line[i] == '[') {
+                auto close = line.find(']', i);
+                if (close != std::string::npos && close + 1 < line.size() && line[close + 1] == '(') {
+                    no_links += line.substr(i + 1, close - i - 1);
+                    auto paren_close = line.find(')', close + 2);
+                    i = (paren_close != std::string::npos) ? paren_close + 1 : close + 1;
+                } else {
+                    no_links += line[i++];
+                }
+            } else {
+                no_links += line[i++];
+            }
+        }
+        line = no_links;
+
+        // Convert bullet points to something nicer
+        if (line.size() >= 2 && line[0] == '-' && line[1] == ' ') {
+            line = "• " + line.substr(2);
+        }
+
+        if (!first_line) {
+            result += '\n';
+        }
+        result += line;
+        first_line = false;
+    }
+
+    // Remove excessive newlines, we are heavy char limited...
+    while (result.find("\n\n\n") != std::string::npos) {
+        result.replace(result.find("\n\n\n"), 3, "\n\n");
+    }
+
+    // Trim trailing whitespace/newlines
+    while (!result.empty() && (result.back() == '\n' || result.back() == ' ')) {
+        result.pop_back();
+    }
+
+    return result;
+}
+
+std::string FormatBody(const nlohmann::json& release, std::string_view title) {
+    std::string body = release.value("body", std::string{});
+
+    if (body.empty()) {
+        return std::string(title);
+    }
+
+    // Sanitize markdown
+    body = SanitizeMarkdown(body);
+
+    // Limit body length - News app has character limits
+    size_t max_body_length = 4000;
+    if (body.size() > max_body_length) {
+        size_t cut_pos = body.rfind('\n', max_body_length);
+        if (cut_pos == std::string::npos || cut_pos < max_body_length / 2) {
+            cut_pos = body.rfind(". ", max_body_length);
+        }
+        if (cut_pos == std::string::npos || cut_pos < max_body_length / 2) {
+            cut_pos = max_body_length;
+        }
+        body = body.substr(0, cut_pos);
+
+        // Trim trailing whitespace
+        while (!body.empty() && (body.back() == '\n' || body.back() == ' ')) {
+            body.pop_back();
+        }
+
+        body += "\n\n... View more on GitHub";
+    }
+
+    return body;
+}
+
+void ImportReleases(std::string_view json_text) {
+    nlohmann::json root;
+    try {
+        root = nlohmann::json::parse(json_text);
+    } catch (...) {
+        LOG_WARNING(Service_BCAT, "failed to parse JSON");
+        return;
+    }
+
+    if (!root.is_array()) return;
+
+    for (const auto& rel : root) {
+        if (!rel.is_object()) continue;
+
+        std::string title = rel.value("name", rel.value("tag_name", std::string{}));
+        if (title.empty()) continue;
+
+        const u64 release_id = rel.value("id", 0);
+        const u32 news_id = release_id ? static_cast<u32>(release_id & 0x7FFFFFFF) : HashToNewsId(title);
+        const u64 published = ParseIsoTimestamp(rel.value("published_at", std::string{}));
+        const u64 pickup_limit = published + 600000000;
+        const u32 priority = rel.value("prerelease", false) ? 1500 : 2500;
+
+        std::string author = "eden";
+        if (rel.contains("author") && rel["author"].is_object()) {
+            author = rel["author"].value("login", "eden");
+        }
+
+        auto payload = BuildMsgpack(title, FormatBody(rel, title), title, published,
+                                    pickup_limit, priority, {"en"}, author, {},
+                                    rel.value("html_url", std::string{}), news_id);
+
+        const std::string news_id_str = fmt::format("LA{:020}", news_id);
+
+        GithubNewsMeta meta{
+            .news_id = news_id_str,
+            .topic_id = "1",
+            .published_at = published,
+            .pickup_limit = pickup_limit,
+            .essential_pickup_limit = pickup_limit,
+            .expire_at = 0,
+            .priority = priority,
+            .deletion_priority = 100,
+            .decoration_type = 1,
+            .opted_in = 1,
+            .essential_pickup_limit_flag = 1,
+            .category = 0,
+            .language_mask = 1,
+        };
+
+        NewsStorage::Instance().UpsertRaw(meta, std::move(payload));
+    }
+}
+
+} // anonymous namespace
+
+std::vector<u8> BuildMsgpack(std::string_view title, std::string_view body,
+                             std::string_view topic_name, u64 published_at,
+                             u64 pickup_limit, u32 priority,
+                             const std::vector<std::string>& languages,
+                             const std::string& author,
+                             const std::vector<std::pair<std::string, std::string>>& /*assets*/,
+                             const std::string& html_url,
+                             std::optional<u32> override_id) {
+    MsgPack::Writer w;
+
+    const u32 news_id = override_id.value_or(HashToNewsId(title.empty() ? "eden" : title));
+    const auto logo = LoadLogo();
+
+    w.WriteFixMap(23);
+
+    // Version infos, could exist a 2?
+    w.WriteKey("version");
+    w.WriteFixMap(2);
+    w.WriteKey("format");
+    w.WriteUInt(1);
+    w.WriteKey("semantics");
+    w.WriteUInt(1);
+
+    // Metadata
+    w.WriteKey("news_id");
+    w.WriteUInt(news_id);
+    w.WriteKey("published_at");
+    w.WriteUInt(published_at);
+    w.WriteKey("pickup_limit");
+    w.WriteUInt(pickup_limit);
+    w.WriteKey("priority");
+    w.WriteUInt(priority);
+    w.WriteKey("deletion_priority");
+    w.WriteUInt(100);
+
+    // Language
+    w.WriteKey("language");
+    w.WriteString(languages.empty() ? "en" : languages.front());
+    w.WriteKey("supported_languages");
+    w.WriteFixArray(languages.size());
+    for (const auto& lang : languages) w.WriteString(lang);
+
+    // Display settings
+    w.WriteKey("display_type");
+    w.WriteString("NORMAL");
+    w.WriteKey("topic_id");
+    w.WriteString("eden");
+
+    w.WriteKey("no_photography"); // still show image
+    w.WriteUInt(0);
+    w.WriteKey("surprise"); // no idea
+    w.WriteUInt(0);
+    w.WriteKey("bashotorya"); // no idea
+    w.WriteUInt(0);
+    w.WriteKey("movie");
+    w.WriteUInt(0); // 1 = has video, movie_url must be set but we don't support it yet
+
+    // News Subject (Title)
+    w.WriteKey("subject");
+    w.WriteFixMap(2);
+    w.WriteKey("caption");
+    w.WriteUInt(1);
+    w.WriteKey("text");
+    w.WriteString(title.empty() ? "No title" : title);
+
+    // Topic name = who wrote it
+    w.WriteKey("topic_name");
+    w.WriteString("Eden");
+
+    w.WriteKey("list_image");
+    w.WriteBinary(logo);
+
+    // Footer
+    w.WriteKey("footer");
+    w.WriteFixMap(1);
+    w.WriteKey("text");
+    w.WriteString("");
+
+    w.WriteKey("allow_domains");
+    w.WriteString("^https?://github.com(/|$)");
+
+    // More link
+    w.WriteKey("more");
+    w.WriteFixMap(1);
+    w.WriteKey("browser");
+    w.WriteFixMap(2);
+    w.WriteKey("url");
+    w.WriteString(html_url);
+    w.WriteKey("text");
+    w.WriteString("Open GitHub");
+
+    // Body
+    w.WriteKey("body");
+    w.WriteFixMap(4);
+    w.WriteKey("text");
+    w.WriteString(body);
+    w.WriteKey("main_image_height");
+    w.WriteUInt(450);
+    w.WriteKey("movie_url");
+    w.WriteString("");
+    w.WriteKey("main_image");
+    w.WriteBinary(logo);
+
+    // no clue
+    w.WriteKey("contents_descriptors");
+    w.WriteString("");
+    w.WriteKey("interactive_elements");
+    w.WriteString("");
+
+    return w.Take();
+}
+
+void EnsureBuiltinNewsLoaded() {
+    static std::once_flag once;
+    std::call_once(once, [] {
+        LoadLogo();
+
+        if (const auto fresh = DownloadReleasesJson()) {
+            WriteCachedJson(*fresh);
+            ImportReleases(*fresh);
+            LOG_DEBUG(Service_BCAT, ", {} entries, downloaded", NewsStorage::Instance().ListAll().size());
+            return;
+        }
+
+        // Fallback to cached JSON if download failed
+        if (const auto cached = ReadCachedJson()) {
+            ImportReleases(*cached);
+            LOG_DEBUG(Service_BCAT, ", {} entries, cached", NewsStorage::Instance().ListAll().size());
+            return;
+        }
+    });
+}
+
+} // namespace Service::News

src/core/hle/service/bcat/news/builtin_news.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include <mutex>
+#include <optional>
+#include <string_view>
+#include <vector>
+
+namespace Service::News {
+
+void EnsureBuiltinNewsLoaded();
+
+    std::vector<u8> BuildMsgpack(std::string_view title, std::string_view body,
+                                 std::string_view topic_name,
+                                 u64 published_at,
+                                 u64 pickup_limit,
+                                 u32 priority,
+                                 const std::vector<std::string>& languages,
+                                 const std::string& author_name,
+                                 const std::vector<std::pair<std::string, std::string>>& assets,
+                                 const std::string& html_url,
+                                 std::optional<u32> override_news_id = std::nullopt);
+
+} // namespace Service::News

src/core/hle/service/bcat/news/msgpack.cpp

@@ -0,0 +1,886 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/msgpack.h"
+
+#include <algorithm>
+#include <cstring>
+
+// This file is a partial MsgPack implementation, only implementing the features
+// needed for the News service. Can be extended but enough for the news use case.
+
+namespace Service::News {
+
+void MsgPack::Writer::WriteBytes(std::span<const u8> bytes) {
+    out.insert(out.end(), bytes.begin(), bytes.end());
+}
+
+void MsgPack::Writer::WriteFixMap(size_t count) {
+    if (count <= 15) {
+        out.push_back(static_cast<u8>(0x80 | count));
+    } else if (count <= 0xFFFF) {
+        out.push_back(0xDE);
+        out.push_back(static_cast<u8>((count >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(count & 0xFF));
+    } else {
+        WriteMap32(count);
+    }
+}
+
+void MsgPack::Writer::WriteMap32(size_t count) {
+    out.push_back(0xDF);
+    out.push_back(static_cast<u8>((count >> 24) & 0xFF));
+    out.push_back(static_cast<u8>((count >> 16) & 0xFF));
+    out.push_back(static_cast<u8>((count >> 8) & 0xFF));
+    out.push_back(static_cast<u8>(count & 0xFF));
+}
+
+void MsgPack::Writer::WriteKey(std::string_view s) {
+    WriteString(s);
+}
+
+void MsgPack::Writer::WriteString(std::string_view s) {
+    if (s.size() <= 31) {
+        out.push_back(static_cast<u8>(0xA0 | s.size()));
+    } else if (s.size() <= 0xFF) {
+        out.push_back(0xD9);
+        out.push_back(static_cast<u8>(s.size()));
+    } else if (s.size() <= 0xFFFF) {
+        out.push_back(0xDA);
+        out.push_back(static_cast<u8>((s.size() >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(s.size() & 0xFF));
+    } else {
+        out.push_back(0xDB);
+        out.push_back(static_cast<u8>((s.size() >> 24) & 0xFF));
+        out.push_back(static_cast<u8>((s.size() >> 16) & 0xFF));
+        out.push_back(static_cast<u8>((s.size() >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(s.size() & 0xFF));
+    }
+    WriteBytes({reinterpret_cast<const u8*>(s.data()), s.size()});
+}
+
+void MsgPack::Writer::WriteInt64(s64 v) {
+    if (v >= 0) {
+        WriteUInt(static_cast<u64>(v));
+        return;
+    }
+    if (v >= -32) {
+        out.push_back(static_cast<u8>(0xE0 | (v + 32)));
+    } else if (v >= -128) {
+        out.push_back(0xD0);
+        out.push_back(static_cast<u8>(v & 0xFF));
+    } else if (v >= -32768) {
+        out.push_back(0xD1);
+        out.push_back(static_cast<u8>((v >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(v & 0xFF));
+    } else if (v >= INT32_MIN) {
+        out.push_back(0xD2);
+        out.push_back(static_cast<u8>((v >> 24) & 0xFF));
+        out.push_back(static_cast<u8>((v >> 16) & 0xFF));
+        out.push_back(static_cast<u8>((v >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(v & 0xFF));
+    } else {
+        out.push_back(0xD3);
+        for (int i = 7; i >= 0; --i) {
+            out.push_back(static_cast<u8>((static_cast<u64>(v) >> (8 * i)) & 0xFF));
+        }
+    }
+}
+
+void MsgPack::Writer::WriteUInt(u64 v) {
+    if (v < 0x80) {
+        out.push_back(static_cast<u8>(v));
+    } else if (v <= 0xFF) {
+        out.push_back(0xCC);
+        out.push_back(static_cast<u8>(v));
+    } else if (v <= 0xFFFF) {
+        out.push_back(0xCD);
+        out.push_back(static_cast<u8>((v >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(v & 0xFF));
+    } else if (v <= 0xFFFFFFFFULL) {
+        out.push_back(0xCE);
+        out.push_back(static_cast<u8>((v >> 24) & 0xFF));
+        out.push_back(static_cast<u8>((v >> 16) & 0xFF));
+        out.push_back(static_cast<u8>((v >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(v & 0xFF));
+    } else {
+        out.push_back(0xCF);
+        for (int i = 7; i >= 0; --i) {
+            out.push_back(static_cast<u8>((v >> (8 * i)) & 0xFF));
+        }
+    }
+}
+
+void MsgPack::Writer::WriteNil() {
+    out.push_back(0xC0);
+}
+
+void MsgPack::Writer::WriteFixArray(size_t count) {
+    if (count <= 15) {
+        out.push_back(static_cast<u8>(0x90 | count));
+    } else if (count <= 0xFFFF) {
+        out.push_back(0xDC);
+        out.push_back(static_cast<u8>((count >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(count & 0xFF));
+    } else {
+        out.push_back(0xDD);
+        out.push_back(static_cast<u8>((count >> 24) & 0xFF));
+        out.push_back(static_cast<u8>((count >> 16) & 0xFF));
+        out.push_back(static_cast<u8>((count >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(count & 0xFF));
+    }
+}
+
+void MsgPack::Writer::WriteBinary(const std::vector<u8>& data) {
+    if (data.size() <= 0xFF) {
+        out.push_back(0xC4);
+        out.push_back(static_cast<u8>(data.size()));
+    } else if (data.size() <= 0xFFFF) {
+        out.push_back(0xC5);
+        out.push_back(static_cast<u8>((data.size() >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(data.size() & 0xFF));
+    } else {
+        out.push_back(0xC6);
+        out.push_back(static_cast<u8>((data.size() >> 24) & 0xFF));
+        out.push_back(static_cast<u8>((data.size() >> 16) & 0xFF));
+        out.push_back(static_cast<u8>((data.size() >> 8) & 0xFF));
+        out.push_back(static_cast<u8>(data.size() & 0xFF));
+    }
+    WriteBytes(data);
+}
+
+void MsgPack::Writer::WriteBool(bool v) {
+    out.push_back(v ? 0xC3 : 0xC2);
+}
+
+std::vector<u8> MsgPack::Writer::Take() {
+    return std::move(out);
+}
+
+MsgPack::Reader::Reader(std::span<const u8> buffer) : data(buffer) {}
+
+bool MsgPack::Reader::Fail(const char* msg) {
+    error = msg;
+    return false;
+}
+
+bool MsgPack::Reader::Ensure(size_t n) const {
+    return offset + n <= data.size();
+}
+
+u8 MsgPack::Reader::Peek() const {
+    return Ensure(1) ? data[offset] : 0;
+}
+
+u8 MsgPack::Reader::ReadByte() {
+    if (!Ensure(1)) {
+        return 0;
+    }
+    return data[offset++];
+}
+
+bool MsgPack::Reader::ReadSize(size_t byte_count, size_t& out_size) {
+    if (!Ensure(byte_count)) {
+        return Fail("size out of range");
+    }
+    size_t value = 0;
+    for (size_t i = 0; i < byte_count; ++i) {
+        value = (value << 8) | data[offset + i];
+    }
+    offset += byte_count;
+    out_size = value;
+    return true;
+}
+
+bool MsgPack::Reader::SkipBytes(size_t n) {
+    if (!Ensure(n)) {
+        return Fail("skip out of range");
+    }
+    offset += n;
+    return true;
+}
+
+bool MsgPack::Reader::SkipValue() {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = ReadByte();
+
+    if (byte <= 0x7F || (byte >= 0xE0)) {
+        return true;
+    }
+    if ((byte & 0xE0) == 0xA0) {
+        const size_t len = byte & 0x1F;
+        return SkipBytes(len);
+    }
+    if ((byte & 0xF0) == 0x80) {
+        const size_t count = byte & 0x0F;
+        return SkipContainer(count * 2, true);
+    }
+    if ((byte & 0xF0) == 0x90) {
+        const size_t count = byte & 0x0F;
+        return SkipContainer(count, false);
+    }
+
+    switch (byte) {
+    case 0xC0:
+    case 0xC2:
+    case 0xC3:
+        return true;
+    case 0xC4:
+    case 0xC5:
+    case 0xC6: {
+        size_t size = 0;
+        if (!ReadSize(static_cast<size_t>(1) << (byte - 0xC4), size)) {
+            return false;
+        }
+        return SkipBytes(size);
+    }
+    case 0xC7:
+    case 0xC8:
+    case 0xC9:
+        return Fail("ext not supported");
+    case 0xCA:
+        return SkipBytes(4);
+    case 0xCB:
+        return SkipBytes(8);
+    case 0xCC:
+        return SkipBytes(1);
+    case 0xCD:
+        return SkipBytes(2);
+    case 0xCE:
+        return SkipBytes(4);
+    case 0xCF:
+        return SkipBytes(8);
+    case 0xD0:
+        return SkipBytes(1);
+    case 0xD1:
+        return SkipBytes(2);
+    case 0xD2:
+        return SkipBytes(4);
+    case 0xD3:
+        return SkipBytes(8);
+    case 0xD4:
+    case 0xD5:
+    case 0xD6:
+    case 0xD7:
+    case 0xD8:
+        return Fail("fixext not supported");
+    case 0xD9: {
+        size_t size = 0;
+        if (!ReadSize(1, size)) {
+            return false;
+        }
+        return SkipBytes(size);
+    }
+    case 0xDA: {
+        size_t size = 0;
+        if (!ReadSize(2, size)) {
+            return false;
+        }
+        return SkipBytes(size);
+    }
+    case 0xDB: {
+        size_t size = 0;
+        if (!ReadSize(4, size)) {
+            return false;
+        }
+        return SkipBytes(size);
+    }
+    case 0xDC: {
+        size_t count = 0;
+        if (!ReadSize(2, count)) {
+            return false;
+        }
+        return SkipContainer(count, false);
+    }
+    case 0xDD: {
+        size_t count = 0;
+        if (!ReadSize(4, count)) {
+            return false;
+        }
+        return SkipContainer(count, false);
+    }
+    case 0xDE: {
+        size_t count = 0;
+        if (!ReadSize(2, count)) {
+            return false;
+        }
+        return SkipContainer(count * 2, true);
+    }
+    case 0xDF: {
+        size_t count = 0;
+        if (!ReadSize(4, count)) {
+            return false;
+        }
+        return SkipContainer(count * 2, true);
+    }
+    default:
+        return Fail("unknown type");
+    }
+}
+
+bool MsgPack::Reader::SkipContainer(size_t count, bool /*map_mode*/) {
+    for (size_t i = 0; i < count; ++i) {
+        if (!SkipValue()) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::SkipAll() {
+    while (!End()) {
+        if (!SkipValue()) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadMapHeader(size_t& count) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = Peek();
+    if ((byte & 0xF0) == 0x80) {
+        count = byte & 0x0F;
+        offset++;
+        return true;
+    }
+    if (byte == 0xDE) {
+        ReadByte();
+        return ReadSize(2, count);
+    }
+    if (byte == 0xDF) {
+        ReadByte();
+        return ReadSize(4, count);
+    }
+    return Fail("not a map");
+}
+
+bool MsgPack::Reader::ReadArrayHeader(size_t& count) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = Peek();
+    if ((byte & 0xF0) == 0x90) {
+        count = byte & 0x0F;
+        offset++;
+        return true;
+    }
+    if (byte == 0xDC) {
+        ReadByte();
+        return ReadSize(2, count);
+    }
+    if (byte == 0xDD) {
+        ReadByte();
+        return ReadSize(4, count);
+    }
+    return Fail("not an array");
+}
+
+bool MsgPack::Reader::ReadUInt(u64& value) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = Peek();
+    if (byte <= 0x7F) {
+        value = byte;
+        offset++;
+        return true;
+    }
+    if (byte == 0xCC) {
+        ReadByte();
+        if (!Ensure(1)) {
+            return Fail("uint8 truncated");
+        }
+        value = data[offset++];
+        return true;
+    }
+    if (byte == 0xCD) {
+        ReadByte();
+        size_t tmp = 0;
+        if (!ReadSize(2, tmp)) {
+            return false;
+        }
+        value = tmp;
+        return true;
+    }
+    if (byte == 0xCE) {
+        ReadByte();
+        size_t tmp = 0;
+        if (!ReadSize(4, tmp)) {
+            return false;
+        }
+        value = tmp;
+        return true;
+    }
+    if (byte == 0xCF) {
+        ReadByte();
+        if (!Ensure(8)) {
+            return Fail("uint64 truncated");
+        }
+        u64 tmp = 0;
+        for (int i = 0; i < 8; ++i) {
+            tmp = (tmp << 8) | data[offset + i];
+        }
+        offset += 8;
+        value = tmp;
+        return true;
+    }
+    return Fail("not uint");
+}
+
+bool MsgPack::Reader::ReadInt(s64& value) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = Peek();
+    if (byte <= 0x7F) {
+        value = byte;
+        offset++;
+        return true;
+    }
+    if (byte >= 0xE0) {
+        value = static_cast<int8_t>(byte);
+        offset++;
+        return true;
+    }
+    if (byte == 0xD0) {
+        ReadByte();
+        if (!Ensure(1)) {
+            return Fail("int8 truncated");
+        }
+        value = static_cast<int8_t>(data[offset]);
+        offset += 1;
+        return true;
+    }
+    if (byte == 0xD1) {
+        ReadByte();
+        if (!Ensure(2)) {
+            return Fail("int16 truncated");
+        }
+        value = static_cast<int16_t>((data[offset] << 8) | data[offset + 1]);
+        offset += 2;
+        return true;
+    }
+    if (byte == 0xD2) {
+        ReadByte();
+        if (!Ensure(4)) {
+            return Fail("int32 truncated");
+        }
+        const s32 tmp = static_cast<int32_t>((data[offset] << 24) | (data[offset + 1] << 16) |
+                                             (data[offset + 2] << 8) | data[offset + 3]);
+        offset += 4;
+        value = tmp;
+        return true;
+    }
+    if (byte == 0xD3) {
+        ReadByte();
+        if (!Ensure(8)) {
+            return Fail("int64 truncated");
+        }
+        s64 tmp = 0;
+        for (int i = 0; i < 8; ++i) {
+            tmp = (tmp << 8) | data[offset + i];
+        }
+        offset += 8;
+        value = tmp;
+        return true;
+    }
+    return Fail("not int");
+}
+
+bool MsgPack::Reader::ReadBool(bool& value) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = ReadByte();
+    if (byte == 0xC2) {
+        value = false;
+        return true;
+    }
+    if (byte == 0xC3) {
+        value = true;
+        return true;
+    }
+    return Fail("not bool");
+}
+
+bool MsgPack::Reader::ReadString(std::string& value) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = ReadByte();
+    size_t len = 0;
+    if ((byte & 0xE0) == 0xA0) {
+        len = byte & 0x1F;
+    } else if (byte == 0xD9) {
+        if (!ReadSize(1, len)) {
+            return false;
+        }
+    } else if (byte == 0xDA) {
+        if (!ReadSize(2, len)) {
+            return false;
+        }
+    } else if (byte == 0xDB) {
+        if (!ReadSize(4, len)) {
+            return false;
+        }
+    } else {
+        return Fail("not string");
+    }
+
+    if (!Ensure(len)) {
+        return Fail("string truncated");
+    }
+    value.assign(reinterpret_cast<const char*>(data.data() + offset), len);
+    offset += len;
+    return true;
+}
+
+bool MsgPack::Reader::ReadBinary(std::vector<u8>& value) {
+    if (End()) {
+        return Fail("unexpected end");
+    }
+    const u8 byte = ReadByte();
+    size_t len = 0;
+    if (byte == 0xC4) {
+        if (!ReadSize(1, len)) {
+            return false;
+        }
+    } else if (byte == 0xC5) {
+        if (!ReadSize(2, len)) {
+            return false;
+        }
+    } else if (byte == 0xC6) {
+        if (!ReadSize(4, len)) {
+            return false;
+        }
+    } else {
+        return Fail("not binary");
+    }
+    if (!Ensure(len)) {
+        return Fail("binary truncated");
+    }
+    value.assign(data.begin() + offset, data.begin() + offset + len);
+    offset += len;
+    return true;
+}
+
+bool MsgPack::Reader::ReadBinaryCompat(std::vector<u8>& value) {
+    if (!ReadBinary(value)) {
+        value.clear();
+        return false;
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadStringArray(std::vector<std::string>& out) {
+    size_t count = 0;
+    if (!ReadArrayHeader(count)) {
+        return false;
+    }
+    out.clear();
+    out.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+        std::string value;
+        if (!ReadString(value)) {
+            return false;
+        }
+        out.push_back(std::move(value));
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsVersion(NewsStruct::Version& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "format") {
+            if (!ReadUInt(out.format)) {
+                return false;
+            }
+        } else if (key == "semantics") {
+            if (!ReadUInt(out.semantics)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsSubject(NewsStruct::Subject& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "caption") {
+            if (!ReadUInt(out.caption)) {
+                return false;
+            }
+        } else if (key == "text") {
+            if (!ReadString(out.text)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsFooter(NewsStruct::Footer& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "text") {
+            if (!ReadString(out.text)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadByteArray(std::vector<u8>& out) {
+    if (!ReadBinary(out)) {
+        out.clear();
+        return false;
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsBody(NewsStruct::Body& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "text") {
+            if (!ReadString(out.text)) {
+                return false;
+            }
+        } else if (key == "main_image_height") {
+            if (!ReadUInt(out.main_image_height)) {
+                return false;
+            }
+        } else if (key == "movie_url") {
+            if (!ReadString(out.movie_url)) {
+                return false;
+            }
+        } else if (key == "main_image") {
+            if (!ReadByteArray(out.main_image)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsBrowser(NewsStruct::More::Browser& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    out.present = true;
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "url") {
+            if (!ReadString(out.url)) {
+                return false;
+            }
+        } else if (key == "text") {
+            if (!ReadString(out.text)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsMore(NewsStruct::More& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    out.has_browser = false;
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+        if (key == "browser") {
+            out.has_browser = true;
+            if (!ReadNewsBrowser(out.browser)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool MsgPack::Reader::ReadNewsStruct(NewsStruct& out) {
+    size_t count = 0;
+    if (!ReadMapHeader(count)) {
+        return false;
+    }
+    for (size_t i = 0; i < count; ++i) {
+        std::string key;
+        if (!ReadString(key)) {
+            return false;
+        }
+
+        auto read_u64 = [&](u64& target) -> bool {
+            return ReadUInt(target);
+        };
+
+        if (key == "version") {
+            if (!ReadNewsVersion(out.version)) {
+                return false;
+            }
+        } else if (key == "news_id") {
+            if (!read_u64(out.news_id)) {
+                return false;
+            }
+        } else if (key == "published_at") {
+            if (!read_u64(out.published_at)) {
+                return false;
+            }
+        } else if (key == "pickup_limit") {
+            if (!read_u64(out.pickup_limit)) {
+                return false;
+            }
+        } else if (key == "priority") {
+            if (!read_u64(out.priority)) {
+                return false;
+            }
+        } else if (key == "deletion_priority") {
+            if (!read_u64(out.deletion_priority)) {
+                return false;
+            }
+        } else if (key == "language") {
+            if (!ReadString(out.language)) {
+                return false;
+            }
+        } else if (key == "supported_languages") {
+            if (!ReadStringArray(out.supported_languages)) {
+                return false;
+            }
+        } else if (key == "display_type") {
+            if (!ReadString(out.display_type)) {
+                return false;
+            }
+        } else if (key == "topic_id") {
+            if (!ReadString(out.topic_id)) {
+                return false;
+            }
+        } else if (key == "no_photography") {
+            if (!read_u64(out.no_photography)) {
+                return false;
+            }
+        } else if (key == "surprise") {
+            if (!read_u64(out.surprise)) {
+                return false;
+            }
+        } else if (key == "bashotorya") {
+            if (!read_u64(out.bashotorya)) {
+                return false;
+            }
+        } else if (key == "movie") {
+            if (!read_u64(out.movie)) {
+                return false;
+            }
+        } else if (key == "subject") {
+            if (!ReadNewsSubject(out.subject)) {
+                return false;
+            }
+        } else if (key == "topic_name") {
+            if (!ReadString(out.topic_name)) {
+                return false;
+            }
+        } else if (key == "list_image") {
+            if (!ReadByteArray(out.list_image)) {
+                return false;
+            }
+        } else if (key == "footer") {
+            if (!ReadNewsFooter(out.footer)) {
+                return false;
+            }
+        } else if (key == "allow_domains") {
+            if (!ReadString(out.allow_domains)) {
+                return false;
+            }
+        } else if (key == "more") {
+            if (!ReadNewsMore(out.more)) {
+                return false;
+            }
+        } else if (key == "body") {
+            if (!ReadNewsBody(out.body)) {
+                return false;
+            }
+        } else if (key == "contents_descriptors") {
+            if (!ReadString(out.contents_descriptors)) {
+                return false;
+            }
+        } else if (key == "interactive_elements") {
+            if (!ReadString(out.interactive_elements)) {
+                return false;
+            }
+        } else {
+            if (!SkipValue()) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+} // namespace Service::News

src/core/hle/service/bcat/news/msgpack.h

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <span>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Service::News {
+
+struct NewsStruct {
+    struct Version {
+        u64 format{};
+        u64 semantics{};
+    };
+
+    struct Subject {
+        u64 caption{};
+        std::string text;
+    };
+
+    struct Footer {
+        std::string text;
+    };
+
+    struct Body {
+        std::string text;
+        u64 main_image_height{};
+        std::string movie_url;
+        std::vector<u8> main_image;
+    };
+
+    struct More {
+        struct Browser {
+            std::string url;
+            std::string text;
+            bool present{};
+        } browser;
+        bool has_browser{};
+    };
+
+    Version version;
+    u64 news_id{};
+    u64 published_at{};
+    u64 pickup_limit{};
+    u64 priority{};
+    u64 deletion_priority{};
+    std::string language;
+    std::vector<std::string> supported_languages;
+    std::string display_type;
+    std::string topic_id;
+    u64 no_photography{};
+    u64 surprise{};
+    u64 bashotorya{};
+    u64 movie{};
+    Subject subject;
+    std::string topic_name;
+    std::vector<u8> list_image;
+    Footer footer;
+    std::string allow_domains;
+    More more;
+    Body body;
+    std::string contents_descriptors;
+    std::string interactive_elements;
+};
+
+class MsgPack {
+public:
+    class Writer {
+    public:
+        void WriteFixMap(size_t count);
+        void WriteMap32(size_t count);
+        void WriteKey(std::string_view key);
+        void WriteString(std::string_view value);
+        void WriteInt64(s64 value);
+        void WriteUInt(u64 value);
+        void WriteNil();
+        void WriteFixArray(size_t count);
+        void WriteBinary(const std::vector<u8>& data);
+        void WriteBool(bool value);
+
+        std::vector<u8> Take();
+        const std::vector<u8>& Buffer() const { return out; }
+        void Clear() { out.clear(); }
+
+    private:
+        void WriteBytes(std::span<const u8> bytes);
+
+        std::vector<u8> out;
+    };
+
+    class Reader {
+    public:
+        explicit Reader(std::span<const u8> buffer);
+
+        template <typename T>
+        bool Read(T& out) {
+            if constexpr (std::is_same_v<T, NewsStruct>) {
+                return ReadNewsStruct(out);
+            } else {
+                static_assert(sizeof(T) == 0, "Unsupported MsgPack::Reader::Read type");
+            }
+        }
+
+        bool SkipValue();
+        bool SkipAll();
+
+        bool ReadMapHeader(size_t& count);
+        bool ReadArrayHeader(size_t& count);
+        bool ReadUInt(u64& value);
+        bool ReadInt(s64& value);
+        bool ReadBool(bool& value);
+        bool ReadString(std::string& value);
+        bool ReadBinary(std::vector<u8>& value);
+
+        bool End() const { return offset >= data.size(); }
+        std::string_view Error() const { return error; }
+
+    private:
+        bool Fail(const char* msg);
+        bool Ensure(size_t n) const;
+        u8 Peek() const;
+        u8 ReadByte();
+        bool ReadSize(size_t byte_count, size_t& out_size);
+        bool SkipBytes(size_t n);
+        bool SkipContainer(size_t count, bool map_mode);
+        bool ReadNewsStruct(NewsStruct& out);
+        bool ReadNewsVersion(NewsStruct::Version& out);
+        bool ReadNewsSubject(NewsStruct::Subject& out);
+        bool ReadNewsFooter(NewsStruct::Footer& out);
+        bool ReadNewsBody(NewsStruct::Body& out);
+        bool ReadNewsMore(NewsStruct::More& out);
+        bool ReadNewsBrowser(NewsStruct::More::Browser& out);
+        bool ReadStringArray(std::vector<std::string>& out);
+        bool ReadBinaryCompat(std::vector<u8>& out);
+        bool ReadByteArray(std::vector<u8>& out);
+
+        std::span<const u8> data;
+        size_t offset{0};
+        std::string error;
+    };
+};
+
+} // namespace Service::News

src/core/hle/service/bcat/news/news_data_service.cpp

@@ -1,25 +1,125 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/bcat/news/news_data_service.h"
+#include "core/hle/service/bcat/news/builtin_news.h"
+#include "core/hle/service/bcat/news/news_storage.h"
+#include "core/hle/service/cmif_serialization.h"
+
+#include "common/logging/log.h"
+
+#include <cstring>
 
 namespace Service::News {
+namespace {
+
+std::string_view ToStringView(std::span<const char> buf) {
+    const std::string_view sv{buf.data(), buf.size()};
+    const auto nul = sv.find('\0');
+    return nul == std::string_view::npos ? sv : sv.substr(0, nul);
+}
+
+} // namespace
 
 INewsDataService::INewsDataService(Core::System& system_)
     : ServiceFramework{system_, "INewsDataService"} {
-    // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "Open"},
-        {1, nullptr, "OpenWithNewsRecordV1"},
-        {2, nullptr, "Read"},
-        {3, nullptr, "GetSize"},
-        {1001, nullptr, "OpenWithNewsRecord"},
+        {0, D<&INewsDataService::Open>, "Open"},
+        {1, D<&INewsDataService::OpenWithNewsRecordV1>, "OpenWithNewsRecordV1"},
+        {2, D<&INewsDataService::Read>, "Read"},
+        {3, D<&INewsDataService::GetSize>, "GetSize"},
+        {1001, D<&INewsDataService::OpenWithNewsRecord>, "OpenWithNewsRecord"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
 INewsDataService::~INewsDataService() = default;
 
+bool INewsDataService::TryOpen(std::string_view key, std::string_view user) {
+    opened_payload.clear();
+
+    if (auto found = NewsStorage::Instance().FindByNewsId(key, user)) {
+        opened_payload = std::move(found->payload);
+        return true;
+    }
+
+    if (!user.empty()) {
+        if (auto found = NewsStorage::Instance().FindByNewsId(key)) {
+            opened_payload = std::move(found->payload);
+            return true;
+        }
+    }
+
+    const auto list = NewsStorage::Instance().ListAll();
+    if (!list.empty()) {
+        if (auto found = NewsStorage::Instance().FindByNewsId(ToStringView(list.front().news_id))) {
+            opened_payload = std::move(found->payload);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+Result INewsDataService::Open(InBuffer<BufferAttr_HipcMapAlias> name) {
+    EnsureBuiltinNewsLoaded();
+
+    const auto key = ToStringView({reinterpret_cast<const char*>(name.data()), name.size()});
+
+    if (TryOpen(key, {})) {
+        R_SUCCEED();
+    }
+
+    R_RETURN(ResultUnknown);
+}
+
+Result INewsDataService::OpenWithNewsRecordV1(NewsRecordV1 record) {
+    EnsureBuiltinNewsLoaded();
+
+    const auto key = ToStringView(record.news_id);
+    const auto user = ToStringView(record.user_id);
+
+    if (TryOpen(key, user)) {
+        R_SUCCEED();
+    }
+
+    R_RETURN(ResultUnknown);
+}
+
+Result INewsDataService::OpenWithNewsRecord(NewsRecord record) {
+    EnsureBuiltinNewsLoaded();
+
+    const auto key = ToStringView(record.news_id);
+    const auto user = ToStringView(record.user_id);
+
+    if (TryOpen(key, user)) {
+        R_SUCCEED();
+    }
+
+    R_RETURN(ResultUnknown);
+}
+
+Result INewsDataService::Read(Out<u64> out_size, s64 offset,
+                              OutBuffer<BufferAttr_HipcMapAlias> out_buffer) {
+    const auto off = static_cast<size_t>(std::max<s64>(0, offset));
+
+    if (off >= opened_payload.size()) {
+        *out_size = 0;
+        R_SUCCEED();
+    }
+
+    const size_t len = std::min(out_buffer.size(), opened_payload.size() - off);
+    std::memcpy(out_buffer.data(), opened_payload.data() + off, len);
+    *out_size = len;
+    R_SUCCEED();
+}
+
+Result INewsDataService::GetSize(Out<s64> out_size) {
+    *out_size = static_cast<s64>(opened_payload.size());
+    R_SUCCEED();
+}
+
 } // namespace Service::News

src/core/hle/service/bcat/news/news_data_service.h

@@ -1,10 +1,16 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once
 
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
+#include "core/hle/service/bcat/news/news_storage.h"
+
 namespace Core {
 class System;
 }
@@ -15,6 +21,17 @@ class INewsDataService final : public ServiceFramework<INewsDataService> {
 public:
     explicit INewsDataService(Core::System& system_);
     ~INewsDataService() override;
+
+private:
+    bool TryOpen(std::string_view key, std::string_view user);
+
+    Result Open(InBuffer<BufferAttr_HipcMapAlias> name);
+    Result OpenWithNewsRecordV1(NewsRecordV1 record_buffer);
+    Result OpenWithNewsRecord(NewsRecord record_buffer);
+    Result Read(Out<u64> out_size, s64 offset, OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
+    Result GetSize(Out<s64> out_size);
+
+    std::vector<u8> opened_payload;
 };
 
 } // namespace Service::News

src/core/hle/service/bcat/news/news_database_service.cpp

@@ -1,52 +1,194 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/bcat/news/news_database_service.h"
+#include "core/hle/service/bcat/news/builtin_news.h"
+#include "core/hle/service/bcat/news/news_storage.h"
 #include "core/hle/service/cmif_serialization.h"
 
+#include <algorithm>
+#include <cstring>
+
 namespace Service::News {
+namespace {
+
+std::string_view ToStringView(std::span<const u8> buf) {
+    if (buf.empty()) return {};
+    auto data = reinterpret_cast<const char*>(buf.data());
+    return {data, strnlen(data, buf.size())};
+}
+
+std::string_view ToStringView(std::span<const char> buf) {
+    if (buf.empty()) return {};
+    return {buf.data(), strnlen(buf.data(), buf.size())};
+}
+
+bool UpdateField(NewsRecord& rec, std::string_view column, s32 value, bool additive) {
+    auto apply = [&](s32& field) {
+        field = additive ? field + value : value;
+        return true;
+    };
+
+    if (column == "read") return apply(rec.read);
+    if (column == "newly") return apply(rec.newly);
+    if (column == "displayed") return apply(rec.displayed);
+    if (column == "extra1" || column == "extra_1") return apply(rec.extra1);
+    if (column == "extra2" || column == "extra_2") return apply(rec.extra2);
+
+    // Accept but ignore fields that don't exist in our struct
+    return column == "priority" || column == "decoration_type" ||
+           column == "feedback" || column == "category";
+}
+
+} // namespace
 
 INewsDatabaseService::INewsDatabaseService(Core::System& system_)
     : ServiceFramework{system_, "INewsDatabaseService"} {
-    // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "GetListV1"},
+        {0, D<&INewsDatabaseService::GetListV1>, "GetListV1"},
         {1, D<&INewsDatabaseService::Count>, "Count"},
-        {2, nullptr, "CountWithKey"},
-        {3, nullptr, "UpdateIntegerValue"},
+        {2, D<&INewsDatabaseService::CountWithKey>, "CountWithKey"},
+        {3, D<&INewsDatabaseService::UpdateIntegerValue>, "UpdateIntegerValue"},
         {4, D<&INewsDatabaseService::UpdateIntegerValueWithAddition>, "UpdateIntegerValueWithAddition"},
-        {5, nullptr, "UpdateStringValue"},
+        {5, D<&INewsDatabaseService::UpdateStringValue>, "UpdateStringValue"},
         {1000, D<&INewsDatabaseService::GetList>, "GetList"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
 INewsDatabaseService::~INewsDatabaseService() = default;
 
-Result INewsDatabaseService::Count(Out<s32> out_count,
-                                   InBuffer<BufferAttr_HipcPointer> buffer_data) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
-    *out_count = 0;
+Result INewsDatabaseService::Count(Out<s32> out_count, InBuffer<BufferAttr_HipcPointer> where) {
+    EnsureBuiltinNewsLoaded();
+    *out_count = static_cast<s32>(NewsStorage::Instance().ListAll().size());
+    R_SUCCEED();
+}
+
+Result INewsDatabaseService::CountWithKey(Out<s32> out_count,
+                                          InBuffer<BufferAttr_HipcPointer> key,
+                                          InBuffer<BufferAttr_HipcPointer> where) {
+    EnsureBuiltinNewsLoaded();
+    *out_count = static_cast<s32>(NewsStorage::Instance().ListAll().size());
     R_SUCCEED();
 }
 
-Result INewsDatabaseService::UpdateIntegerValueWithAddition(
-    u32 value, InBuffer<BufferAttr_HipcPointer> buffer_data_1,
-    InBuffer<BufferAttr_HipcPointer> buffer_data_2) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, value={}, buffer_size_1={}, buffer_data_2={}",
-                value, buffer_data_1.size(), buffer_data_2.size());
+Result INewsDatabaseService::UpdateIntegerValue(u32 value,
+                                                InBuffer<BufferAttr_HipcPointer> key,
+                                                InBuffer<BufferAttr_HipcPointer> where) {
+    const auto column = ToStringView(key);
+    for (const auto& rec : NewsStorage::Instance().ListAll()) {
+        NewsStorage::Instance().UpdateRecord(
+            ToStringView(rec.news_id), {},
+            [&](NewsRecord& r) { UpdateField(r, column, static_cast<s32>(value), false); });
+    }
     R_SUCCEED();
 }
 
-Result INewsDatabaseService::GetList(Out<s32> out_count, u32 value,
-                                     OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data,
-                                     InBuffer<BufferAttr_HipcPointer> buffer_data_1,
-                                     InBuffer<BufferAttr_HipcPointer> buffer_data_2) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, value={}, buffer_size_1={}, buffer_data_2={}",
-                value, buffer_data_1.size(), buffer_data_2.size());
-    *out_count = 0;
+Result INewsDatabaseService::UpdateIntegerValueWithAddition(u32 value,
+                                                            InBuffer<BufferAttr_HipcPointer> key,
+                                                            InBuffer<BufferAttr_HipcPointer> where) {
+    const auto column = ToStringView(key);
+    const auto where_str = ToStringView(where);
+
+    // Extract news_id from where clause like "N_SWITCH(news_id,'LA00000000000123456',1,0)=1"
+    auto extract_news_id = [](std::string_view w) -> std::string {
+        auto pos = w.find("'LA");
+        if (pos == std::string_view::npos) return {};
+        pos++; // skip the '
+        auto end = w.find("'", pos);
+        if (end == std::string_view::npos) return {};
+        return std::string(w.substr(pos, end - pos));
+    };
+
+    const auto news_id = extract_news_id(where_str);
+
+    if (column == "read" && value > 0 && !news_id.empty()) {
+        NewsStorage::Instance().MarkAsRead(news_id);
+    } else if (!news_id.empty()) {
+        NewsStorage::Instance().UpdateRecord(news_id, {},
+            [&](NewsRecord& r) { UpdateField(r, column, static_cast<s32>(value), true); });
+    }
+
+    R_SUCCEED();
+}
+
+Result INewsDatabaseService::UpdateStringValue(InBuffer<BufferAttr_HipcPointer> key,
+                                               InBuffer<BufferAttr_HipcPointer> value,
+                                               InBuffer<BufferAttr_HipcPointer> where) {
+    LOG_WARNING(Service_BCAT, "(STUBBED) UpdateStringValue");
+    R_SUCCEED();
+}
+
+Result INewsDatabaseService::GetListV1(Out<s32> out_count,
+                                       OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+                                       InBuffer<BufferAttr_HipcPointer> where,
+                                       InBuffer<BufferAttr_HipcPointer> order,
+                                       s32 offset) {
+    EnsureBuiltinNewsLoaded();
+
+    auto record_size = sizeof(NewsRecordV1);
+
+    if (out_buffer.size() < record_size) {
+        *out_count = 0;
+        R_SUCCEED();
+    }
+
+    std::memset(out_buffer.data(), 0, out_buffer.size());
+
+    const auto list = NewsStorage::Instance().ListAll();
+    const size_t start = static_cast<size_t>(std::max(0, offset));
+    const size_t max_records = out_buffer.size() / record_size;
+    const size_t available = start < list.size() ? list.size() - start : 0;
+    const size_t count = std::min(max_records, available);
+
+    for (size_t i = 0; i < count; ++i) {
+        const auto& src = list[start + i];
+        NewsRecordV1 dst{};
+        std::memcpy(dst.news_id.data(), src.news_id.data(), dst.news_id.size());
+        std::memcpy(dst.user_id.data(), src.user_id.data(), dst.user_id.size());
+        dst.received_time = src.received_time;
+        dst.read = src.read;
+        dst.newly = src.newly;
+        dst.displayed = src.displayed;
+        dst.extra1 = src.extra1;
+        std::memcpy(out_buffer.data() + i * record_size, &dst, record_size);
+    }
+
+    *out_count = static_cast<s32>(count);
+    R_SUCCEED();
+}
+
+Result INewsDatabaseService::GetList(Out<s32> out_count,
+                                     OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+                                     InBuffer<BufferAttr_HipcPointer> where,
+                                     InBuffer<BufferAttr_HipcPointer> order,
+                                     s32 offset) {
+    EnsureBuiltinNewsLoaded();
+    NewsStorage::Instance().ResetOpenCounter();
+
+    auto record_size = sizeof(NewsRecord);
+
+    if (out_buffer.size() < record_size) {
+        *out_count = 0;
+        R_SUCCEED();
+    }
+
+    std::memset(out_buffer.data(), 0, out_buffer.size());
+
+    const auto list = NewsStorage::Instance().ListAll();
+    const size_t start = static_cast<size_t>(std::max(0, offset));
+    const size_t max_records = out_buffer.size() / record_size;
+    const size_t available = start < list.size() ? list.size() - start : 0;
+    const size_t count = std::min(max_records, available);
+
+    if (count > 0) {
+        std::memcpy(out_buffer.data(), list.data() + start, count * record_size);
+    }
+
+    *out_count = static_cast<s32>(count);
     R_SUCCEED();
 }
 

src/core/hle/service/bcat/news/news_database_service.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,6 +9,8 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
+#include "core/hle/service/bcat/news/news_storage.h"
+
 namespace Core {
 class System;
 }
@@ -20,13 +25,30 @@ public:
 private:
     Result Count(Out<s32> out_count, InBuffer<BufferAttr_HipcPointer> buffer_data);
 
+    Result CountWithKey(Out<s32> out_count, InBuffer<BufferAttr_HipcPointer> key,
+                        InBuffer<BufferAttr_HipcPointer> where);
+
+    Result UpdateIntegerValue(u32 value, InBuffer<BufferAttr_HipcPointer> key,
+                              InBuffer<BufferAttr_HipcPointer> where);
+
     Result UpdateIntegerValueWithAddition(u32 value, InBuffer<BufferAttr_HipcPointer> buffer_data_1,
                                           InBuffer<BufferAttr_HipcPointer> buffer_data_2);
 
-    Result GetList(Out<s32> out_count, u32 value,
+    Result UpdateStringValue(InBuffer<BufferAttr_HipcPointer> key,
+                             InBuffer<BufferAttr_HipcPointer> value,
+                             InBuffer<BufferAttr_HipcPointer> where);
+
+    Result GetListV1(Out<s32> out_count,
+                     OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data,
+                     InBuffer<BufferAttr_HipcPointer> where_phrase,
+                     InBuffer<BufferAttr_HipcPointer> order_by_phrase,
+                     s32 offset);
+
+    Result GetList(Out<s32> out_count,
                    OutBuffer<BufferAttr_HipcMapAlias> out_buffer_data,
-                   InBuffer<BufferAttr_HipcPointer> buffer_data_1,
-                   InBuffer<BufferAttr_HipcPointer> buffer_data_2);
+                   InBuffer<BufferAttr_HipcPointer> where_phrase,
+                   InBuffer<BufferAttr_HipcPointer> order_by_phrase,
+                   s32 offset);
 };
 
 } // namespace Service::News

src/core/hle/service/bcat/news/news_service.cpp

@@ -5,32 +5,35 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/bcat/news/news_service.h"
+#include "core/hle/service/bcat/news/news_storage.h"
 #include "core/hle/service/cmif_serialization.h"
 
+#include <cstring>
+
 namespace Service::News {
 
 INewsService::INewsService(Core::System& system_) : ServiceFramework{system_, "INewsService"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {10100, D<&INewsService::PostLocalNews>, "PostLocalNews"},
-        {20100, nullptr, "SetPassphrase"},
+        {20100, D<&INewsService::SetPassphrase>, "SetPassphrase"},
         {30100, D<&INewsService::GetSubscriptionStatus>, "GetSubscriptionStatus"},
-        {30101, nullptr, "GetTopicList"}, //3.0.0+
-        {30110, nullptr, "Unknown30110"}, //6.0.0+
+        {30101, D<&INewsService::GetTopicList>, "GetTopicList"}, //3.0.0+
+        {30110, D<&INewsService::GetTopicList>, "Unknown30110"}, //6.0.0+ (stub)
         {30200, D<&INewsService::IsSystemUpdateRequired>, "IsSystemUpdateRequired"},
-        {30201, nullptr, "Unknown30201"}, //8.0.0+
-        {30210, nullptr, "Unknown30210"}, //10.0.0+
-        {30300, nullptr, "RequestImmediateReception"},
-        {30400, nullptr, "DecodeArchiveFile"}, //3.0.0-18.1.0
-        {30500, nullptr, "Unknown30500"}, //8.0.0+
-        {30900, nullptr, "Unknown30900"}, //1.0.0
-        {30901, nullptr, "Unknown30901"}, //1.0.0
-        {30902, nullptr, "Unknown30902"}, //1.0.0
-        {40100, nullptr, "SetSubscriptionStatus"},
+        {30201, D<&INewsService::IsSystemUpdateRequired>, "Unknown30201"}, //8.0.0+ (stub)
+        {30210, D<&INewsService::IsSystemUpdateRequired>, "Unknown30210"}, //10.0.0+ (stub)
+        {30300, D<&INewsService::GetNewsDatabaseDump>, "RequestImmediateReception"},
+        {30400, D<&INewsService::GetNewsDatabaseDump>, "DecodeArchiveFile"}, //3.0.0-18.1.0 (stub)
+        {30500, D<&INewsService::GetNewsDatabaseDump>, "Unknown30500"}, //8.0.0+ (stub)
+        {30900, D<&INewsService::GetNewsDatabaseDump>, "Unknown30900"}, //1.0.0 (stub)
+        {30901, D<&INewsService::GetNewsDatabaseDump>, "Unknown30901"}, //1.0.0 (stub)
+        {30902, D<&INewsService::GetNewsDatabaseDump>, "Unknown30902"}, //1.0.0 (stub)
+        {40100, D<&INewsService::GetNewsDatabaseDump>, "SetSubscriptionStatus"},
         {40101, D<&INewsService::RequestAutoSubscription>, "RequestAutoSubscription"}, //3.0.0+
-        {40200, nullptr, "ClearStorage"},
-        {40201, nullptr, "ClearSubscriptionStatusAll"},
-        {90100, nullptr, "GetNewsDatabaseDump"},
+        {40200, D<&INewsService::ClearStorage>, "ClearStorage"},
+        {40201, D<&INewsService::ClearSubscriptionStatusAll>, "ClearSubscriptionStatusAll"},
+        {90100, D<&INewsService::GetNewsDatabaseDump>, "GetNewsDatabaseDump"},
     };
     // clang-format on
 
@@ -40,8 +43,7 @@ INewsService::INewsService(Core::System& system_) : ServiceFramework{system_, "I
 INewsService::~INewsService() = default;
 
 Result INewsService::PostLocalNews(InBuffer<BufferAttr_HipcAutoSelect> buffer_data) {
-    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
-
+    LOG_WARNING(Service_BCAT, "(STUBBED) PostLocalNews size={}", buffer_data.size());
     R_SUCCEED();
 }
 
@@ -63,4 +65,44 @@ Result INewsService::RequestAutoSubscription(u64 value) {
     R_SUCCEED();
 }
 
+Result INewsService::SetPassphrase(InBuffer<BufferAttr_HipcPointer> buffer_data) {
+    LOG_WARNING(Service_BCAT, "(STUBBED) SetPassphrase called size={}", buffer_data.size());
+    R_SUCCEED();
+}
+
+Result INewsService::GetTopicList(Out<s32> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_topics, s32 filter) {
+    constexpr size_t TopicIdSize = 32;
+    constexpr auto EdenTopicId = "eden";
+
+    const size_t max_topics = out_topics.size() / TopicIdSize;
+
+    if (max_topics == 0) {
+        *out_count = 0;
+        R_SUCCEED();
+    }
+
+    std::memset(out_topics.data(), 0, out_topics.size());
+
+    std::memcpy(out_topics.data(), EdenTopicId, std::strlen(EdenTopicId));
+    *out_count = 1;
+
+    R_SUCCEED();
+}
+
+Result INewsService::ClearStorage() {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called");
+    NewsStorage::Instance().Clear();
+    R_SUCCEED();
+}
+
+Result INewsService::ClearSubscriptionStatusAll() {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called");
+    R_SUCCEED();
+}
+
+Result INewsService::GetNewsDatabaseDump() {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called");
+    R_SUCCEED();
+}
+
 } // namespace Service::News

src/core/hle/service/bcat/news/news_service.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -20,11 +23,21 @@ public:
 private:
     Result PostLocalNews(InBuffer<BufferAttr_HipcAutoSelect> buffer_data);
 
+    Result SetPassphrase(InBuffer<BufferAttr_HipcPointer> buffer_data);
+
     Result GetSubscriptionStatus(Out<u32> out_status, InBuffer<BufferAttr_HipcPointer> buffer_data);
 
+    Result GetTopicList(Out<s32> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_topics, s32 filter);
+
     Result IsSystemUpdateRequired(Out<bool> out_is_system_update_required);
 
     Result RequestAutoSubscription(u64 value);
+
+    Result ClearStorage();
+
+    Result ClearSubscriptionStatusAll();
+
+    Result GetNewsDatabaseDump();
 };
 
 } // namespace Service::News

src/core/hle/service/bcat/news/news_storage.cpp

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/news_storage.h"
+
+#include "common/fs/path_util.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <set>
+
+namespace Service::News {
+namespace {
+
+std::filesystem::path GetReadCachePath() {
+    return Common::FS::GetEdenPath(Common::FS::EdenPath::CacheDir) / "news" / "news_read";
+}
+
+std::set<std::string> LoadReadIds() {
+    std::set<std::string> ids;
+    std::ifstream f(GetReadCachePath());
+    std::string line;
+    while (std::getline(f, line)) {
+        if (!line.empty()) ids.insert(line);
+    }
+    return ids;
+}
+
+void SaveReadIds(const std::set<std::string>& ids) {
+    const auto path = GetReadCachePath();
+    std::error_code ec;
+    std::filesystem::create_directories(path.parent_path(), ec);
+    std::ofstream f(path);
+    for (const auto& id : ids) {
+        f << id << '\n';
+    }
+}
+
+} // namespace
+
+NewsStorage& NewsStorage::Instance() {
+    static NewsStorage s;
+    return s;
+}
+
+void NewsStorage::Clear() {
+    std::scoped_lock lk{mtx};
+    items.clear();
+}
+
+void NewsStorage::CopyZ(std::span<char> dst, std::string_view src) {
+    std::memset(dst.data(), 0, dst.size());
+    std::memcpy(dst.data(), src.data(), std::min(dst.size() - 1, src.size()));
+}
+
+std::string NewsStorage::MakeKey(std::string_view news_id, std::string_view user_id) {
+    return std::string(news_id) + "|" + std::string(user_id);
+}
+
+s64 NewsStorage::Now() {
+    using namespace std::chrono;
+    return duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
+}
+
+StoredNews& NewsStorage::Upsert(std::string_view news_id, std::string_view user_id,
+                                std::string_view topic_id, s64 time, std::vector<u8> payload) {
+    std::scoped_lock lk{mtx};
+
+    const auto key = MakeKey(news_id, user_id);
+    auto it = items.find(key);
+    const bool exists = it != items.end();
+
+    // implemented a little "read" file. All in cache.
+    const auto read_ids = LoadReadIds();
+    const bool was_read = read_ids.contains(std::string(news_id));
+
+    NewsRecord rec{};
+    CopyZ(rec.news_id, news_id);
+    CopyZ(rec.user_id, user_id);
+    // there is nx_notice and nx_promotion for tags pre-existing
+    CopyZ(rec.topic_id, topic_id.empty() ? "nx_notice" : topic_id);
+
+    rec.received_time = exists ? it->second.record.received_time : (time ? time : Now());
+    rec.read = was_read ? 1 : (exists ? it->second.record.read : 0);
+    rec.newly = was_read ? 0 : 1;
+    rec.displayed = exists ? it->second.record.displayed : 0;
+    rec.extra1 = exists ? it->second.record.extra1 : 0;
+    rec.extra2 = exists ? it->second.record.extra2 : 0;
+
+    auto& entry = items[key];
+    entry.record = rec;
+    entry.payload = std::move(payload);
+    return entry;
+}
+
+StoredNews& NewsStorage::UpsertRaw(const GithubNewsMeta& meta, std::vector<u8> payload) {
+    return Upsert(meta.news_id, "", meta.topic_id, static_cast<s64>(meta.published_at), std::move(payload));
+}
+
+std::vector<NewsRecord> NewsStorage::ListAll() const {
+    std::scoped_lock lk{mtx};
+
+    std::vector<NewsRecord> out;
+    out.reserve(items.size());
+    for (const auto& [_, v] : items) {
+        out.push_back(v.record);
+    }
+
+    std::sort(out.begin(), out.end(), [](const auto& a, const auto& b) {
+        return a.received_time > b.received_time;
+    });
+    return out;
+}
+
+std::optional<StoredNews> NewsStorage::FindByNewsId(std::string_view news_id,
+                                                    std::string_view user_id) const {
+    std::scoped_lock lk{mtx};
+
+    if (auto it = items.find(MakeKey(news_id, user_id)); it != items.end()) {
+        return it->second;
+    }
+    if (!user_id.empty()) {
+        if (auto it = items.find(MakeKey(news_id, "")); it != items.end()) {
+            return it->second;
+        }
+    }
+    return std::nullopt;
+}
+
+bool NewsStorage::UpdateRecord(std::string_view news_id, std::string_view user_id,
+                               const std::function<void(NewsRecord&)>& updater) {
+    std::scoped_lock lk{mtx};
+
+    if (auto it = items.find(MakeKey(news_id, user_id)); it != items.end()) {
+        updater(it->second.record);
+        return true;
+    }
+    return false;
+}
+
+void NewsStorage::MarkAsRead(std::string_view news_id) {
+    std::scoped_lock lk{mtx};
+    for (auto& [_, entry] : items) {
+        if (std::string_view(entry.record.news_id.data()) == news_id) {
+            entry.record.read = 1;
+            entry.record.newly = 0;
+            break;
+        }
+    }
+    auto ids = LoadReadIds();
+    ids.insert(std::string(news_id));
+    SaveReadIds(ids);
+}
+
+size_t NewsStorage::GetAndIncrementOpenCounter() {
+    std::scoped_lock lk{mtx};
+    return open_counter++;
+}
+
+void NewsStorage::ResetOpenCounter() {
+    std::scoped_lock lk{mtx};
+    open_counter = 0;
+}
+
+
+} // namespace Service::News

src/core/hle/service/bcat/news/news_storage.h

@@ -0,0 +1,100 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <span>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Service::News {
+
+struct GithubNewsMeta {
+    std::string news_id;
+    std::string topic_id;
+    u64 published_at{};
+    u64 pickup_limit{};
+    u64 essential_pickup_limit{};
+    u64 expire_at{};
+    u32 priority{};
+    u32 deletion_priority{100};
+    u32 decoration_type{1};
+    u32 opted_in{1};
+    u32 essential_pickup_limit_flag{1};
+    u32 category{};
+    u32 language_mask{1};
+};
+
+struct NewsRecordV1 {
+    std::array<char, 24> news_id{};
+    std::array<char, 24> user_id{};
+    s64 received_time{};
+    s32 read{};
+    s32 newly{};
+    s32 displayed{};
+    s32 extra1{};
+};
+static_assert(sizeof(NewsRecordV1) == 72);
+
+struct NewsRecord {
+    std::array<char, 24> news_id{};
+    std::array<char, 24> user_id{};
+    std::array<char, 32> topic_id{};
+    s64 received_time{};
+    std::array<u8, 12> _pad1{};
+    s32 read{};
+    s32 newly{};
+    s32 displayed{};
+    std::array<u8, 8> _pad2{};
+    s32 extra1{};
+    s32 extra2{};
+};
+static_assert(sizeof(NewsRecord) == 128);
+
+struct StoredNews {
+    NewsRecord record{};
+    std::vector<u8> payload;
+};
+
+class NewsStorage {
+public:
+    static NewsStorage& Instance();
+
+    void Clear();
+    StoredNews& Upsert(std::string_view news_id, std::string_view user_id,
+                       std::string_view topic_id, s64 time, std::vector<u8> payload);
+    StoredNews& UpsertRaw(const GithubNewsMeta& meta, std::vector<u8> payload);
+
+    std::vector<NewsRecord> ListAll() const;
+    std::optional<StoredNews> FindByNewsId(std::string_view news_id,
+                                           std::string_view user_id = {}) const;
+    bool UpdateRecord(std::string_view news_id, std::string_view user_id,
+                      const std::function<void(NewsRecord&)>& updater);
+    void MarkAsRead(std::string_view news_id);
+
+    size_t GetAndIncrementOpenCounter();
+    void ResetOpenCounter();
+
+private:
+    NewsStorage() = default;
+
+    static std::string MakeKey(std::string_view news_id, std::string_view user_id);
+    static void CopyZ(std::span<char> dst, std::string_view src);
+    static s64 Now();
+
+    mutable std::mutex mtx;
+    std::unordered_map<std::string, StoredNews> items;
+    size_t open_counter{};
+};
+
+} // namespace Service::News