2026-09-27 04:32:34

Signed-off-by: lizzie <lizzie@eden-emu.dev>

cpmfile.json

@@ -333,11 +333,6 @@
         "repo": "herumi/xbyak",
         "version": "v7.40.1"
     },
-    "zbic": {
-        "hash": "fbe2f37986377d7f0d96ae3224c80b5971df6e8b6961f68061f1975ebb2e8cb78f07b90f014b007be4023dbf5513581504e7f7d61a5237cb2a8a7a61ae11e482",
-        "repo": "kinnay/zbic",
-        "version": "11b08f2712264bbed731545085cbd9702096ceb7"
-    },
     "zlib": {
         "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
         "min_version": "1.2",

docs/DesignOverview.md

@@ -1,6 +1,6 @@
 # Design Overview
 
-Modern game consoles require heavy power to be emulated appropriately. This is why the emulator uses an approach known as HLE (High-Level-Emulation), in a nutshell: Instead of accurately emulating every subsystem that forms part of a component, emulate the resulting visible I/O interface instead.
+Modern game consoles require heavy power to emulate. This is why the emulator uses an approach known as HLE (High-Level-Emulation), in a nutshell: Instead of accurately emulating every subsystem that forms part of a component, emulate the resulting visible output of said interface instead.
 
 For example, take a disk write, instead of emulating a proper SD card we instead use the C++ standard library for I/O. Additionally we use the abstractions provided by the `fs` service to "lie" to programs about certain SD card properties. Notably this includes making up sizes for the fake SD card, giving "realistic" values or expected outputs for a given card, and so on. And instead of writing to an actual SD card, the emulator simply writes to a file.
 

docs/README.md

@@ -21,7 +21,7 @@ This contains documentation created by developers, build instructions, guideline
 - Subsystems:
   - **[Design Overview](./DesignOverview.md)**
   - **[Dynarmic](./dynarmic/README.md)**
-  - **[HOS Kernel](./HosKernel.md)**
+  - **[Subsystem: HLE](./SubsystemHLE.md)**
   - **[Settings](./Settings.md)**
 
 ## Policies

docs/SubsystemHLE.md

@@ -1,4 +1,6 @@
-# HOS Kernel
+# Subsystem: HLE
+
+## HOS Kernel
 
 In brief, the HOS kernel is a microkernel, all services and programs run in userspace, the primary way to do communication between these is via `HIPC` (not covered here); otherwise most of the primitives reside in the forms of syscalls invoked via `svc #imm`. The kernel supports both 32-bit and 64-bit programs, and has the capacity to use 32, 36 and 39 bits of address space for spawned processes. Most of the networking stack is based off FreeBSD's network stack.
 
@@ -29,3 +31,52 @@ Every process keeps it's own tracking of the following structures:
 The emulator willingly restricts itself to only use 4 threads (to emulate 4 cores), this is because most existing applications do not benefit greatly from the added core count, and in fact can be detrimental due to extra contention. This translates equitatively to about 4 `ArmInterface` slots for each process, these are then redirected to whatever is the last `pc` of the last thread running on the core is meant to be; proceed to run it, then when returning (due to halt or interruption), proceed to reschedule the thread.
 
 The scheduler as-is isn't 100% faithful to the original (for example the original is cooperative and not preemptive), and has great timing variance (especially due to the fact the emulator can run in systems with wildly different timings).
+
+## Services
+
+Consult [SwitchBrew](https://switchbrew.org/) for per-service methods, and implementation details.
+
+All services are instatiated implicitly using `ServiceFramework`. To register a new interface or service, you can inherit from said class, providing additionally a template parameter that references `Self`, for example:
+
+```c++
+// Follows as:
+// class MyInterface [final] : public ServiceFramework<MyInterface> { ... };
+// [final] is optional, but should be used whenever there is no intention of this class itself being inherited.
+class IFloatingRegistrationRequest final : public ServiceFramework<IFloatingRegistrationRequest> {
+public:
+    // ctor, you can pass extra parameters here (if so required)
+    explicit IFloatingRegistrationRequest(Core::System& system_)
+        : ServiceFramework{system_, "IFloatingRegistrationRequest"}
+    {}
+
+    // Must be placed after all methods are defined (or declared).
+    // Define here your functions and methods, please order them.
+    // Use FindRequestTipc for TIPC handlers.
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, nullptr, "GetSessionId"},
+        FunctionInfo{12, nullptr, "GetAccountId"},
+        FunctionInfo{13, nullptr, "GetLinkedNintendoAccountId"},
+        FunctionInfo{14, nullptr, "GetNickname"},
+        FunctionInfo{15, nullptr, "GetProfileImage"},
+        FunctionInfo{16, nullptr, "GetProfileLargeImage", MakeVersionGate({18,0,0})},
+        FunctionInfo{21, nullptr, "LoadIdTokenCache"},
+        FunctionInfo{100, nullptr, "RegisterUser"},
+        FunctionInfo{101, nullptr, "RegisterUserWithUid"},
+        FunctionInfo{102, nullptr, "RegisterNetworkServiceAccountAsync", MakeVersionGate({4,0,0})},
+        FunctionInfo{103, nullptr, "RegisterNetworkServiceAccountWithUidAsync", MakeVersionGate({4,0,0})},
+        FunctionInfo{110, nullptr, "SetSystemProgramIdentification"},
+        FunctionInfo{111, nullptr, "EnsureIdTokenCacheAsync"}
+    );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+};
+```
+
+Try to keep service structures local, that is, don't place them on header files if they're only going to be used by a specific service.
+
+In each `.cpp` file that uses `D<...>/C<...>` CMIF wrapper helpers, remember to include the corresponding instancer, so you don't face linker errors:
+```c++
+#include "core/hle/service/cmif_serialization.h"
+```
+This will properly instatiate the corresponding wrappers and decompose the provided arguments in the wiring order.

externals/CMakeLists.txt

@@ -48,11 +48,6 @@ if (NOT TARGET stb::headers)
     add_library(stb::headers ALIAS stb)
 endif()
 
-AddJsonPackage(NAME zbic DOWNLOAD_ONLY)
-set(ZBIC_INCLUDE_DIR
-    "${zbic_SOURCE_DIR}/src"
-    PARENT_SCOPE)
-
 # ItaniumDemangle (Windows only)
 if (WIN32 AND NOT TARGET LLVM::Demangle)
     add_library(demangle demangle/ItaniumDemangle.cpp)

src/common/CMakeLists.txt

@@ -62,6 +62,7 @@ add_library(
     fs/fs_util.h
     fs/path_util.cpp
     fs/path_util.h
+    hash.h
     heap_tracker.cpp
     heap_tracker.h
     hex_util.cpp
@@ -136,8 +137,6 @@ add_library(
     uuid.cpp
     uuid.h
     vector_math.h
-    zbic_compression.cpp
-    zbic_compression.h
     zstd_compression.cpp
     zstd_compression.h
     fs/ryujinx_compat.h fs/ryujinx_compat.cpp
@@ -148,10 +147,6 @@ add_library(
     net/net.h net/net.cpp
     container/unordered_map.h container/unordered_set.h)
 
-set_source_files_properties(zbic_compression.cpp PROPERTIES
-    INCLUDE_DIRECTORIES "${ZBIC_INCLUDE_DIR}"
-    COMPILE_OPTIONS "$<$<CXX_COMPILER_ID:Clang,GNU>:-Wno-unused-function;-Wno-missing-declarations;-Wno-shadow>")
-
 if(WIN32)
     target_sources(common PRIVATE windows/timer_resolution.cpp
         windows/timer_resolution.h)

src/common/android/id_cache.cpp

@@ -12,94 +12,93 @@
 #include "common/android/multiplayer/multiplayer.h"
 #include <network/network.h>
 
-static struct {
-    JavaVM *java_vm;
-    jclass native_library_class;
-    jclass disk_cache_progress_class;
-    jclass load_callback_stage_class;
-    jclass game_dir_class;
-    jmethodID game_dir_constructor;
-    jmethodID exit_emulation_activity;
-    jmethodID disk_cache_load_progress;
-    jmethodID on_emulation_started;
-    jmethodID on_emulation_stopped;
-    jmethodID on_program_changed;
-    jmethodID copy_to_storage;
-    jmethodID file_exists;
-    jmethodID file_extension;
 
-    jclass game_class;
-    jmethodID game_constructor;
-    jfieldID game_title_field;
-    jfieldID game_path_field;
-    jfieldID game_program_id_field;
-    jfieldID game_developer_field;
-    jfieldID game_version_field;
-    jfieldID game_is_homebrew_field;
+static JavaVM *s_java_vm;
+static jclass s_native_library_class;
+static jclass s_disk_cache_progress_class;
+static jclass s_load_callback_stage_class;
+static jclass s_game_dir_class;
+static jmethodID s_game_dir_constructor;
+static jmethodID s_exit_emulation_activity;
+static jmethodID s_disk_cache_load_progress;
+static jmethodID s_on_emulation_started;
+static jmethodID s_on_emulation_stopped;
+static jmethodID s_on_program_changed;
+static jmethodID s_copy_to_storage;
+static jmethodID s_file_exists;
+static jmethodID s_file_extension;
 
-    jclass string_class;
-    jclass pair_class;
-    jmethodID pair_constructor;
-    jfieldID pair_first_field;
-    jfieldID pair_second_field;
+static jclass s_game_class;
+static jmethodID s_game_constructor;
+static jfieldID s_game_title_field;
+static jfieldID s_game_path_field;
+static jfieldID s_game_program_id_field;
+static jfieldID s_game_developer_field;
+static jfieldID s_game_version_field;
+static jfieldID s_game_is_homebrew_field;
 
-    jclass overlay_control_data_class;
-    jmethodID overlay_control_data_constructor;
-    jfieldID overlay_control_data_id_field;
-    jfieldID overlay_control_data_enabled_field;
-    jfieldID overlay_control_data_individual_scale_field;
-    jfieldID overlay_control_data_landscape_position_field;
-    jfieldID overlay_control_data_portrait_position_field;
-    jfieldID overlay_control_data_foldable_position_field;
+static jclass s_string_class;
+static jclass s_pair_class;
+static jmethodID s_pair_constructor;
+static jfieldID s_pair_first_field;
+static jfieldID s_pair_second_field;
 
-    jclass patch_class;
-    jmethodID patch_constructor;
-    jfieldID patch_enabled_field;
-    jfieldID patch_name_field;
-    jfieldID patch_version_field;
-    jfieldID patch_type_field;
-    jfieldID patch_program_id_field;
-    jfieldID patch_title_id_field;
+static jclass s_overlay_control_data_class;
+static jmethodID s_overlay_control_data_constructor;
+static jfieldID s_overlay_control_data_id_field;
+static jfieldID s_overlay_control_data_enabled_field;
+static jfieldID s_overlay_control_data_individual_scale_field;
+static jfieldID s_overlay_control_data_landscape_position_field;
+static jfieldID s_overlay_control_data_portrait_position_field;
+static jfieldID s_overlay_control_data_foldable_position_field;
 
-    jclass double_class;
-    jmethodID double_constructor;
-    jmethodID double_value_method;
+static jclass s_patch_class;
+static jmethodID s_patch_constructor;
+static jfieldID s_patch_enabled_field;
+static jfieldID s_patch_name_field;
+static jfieldID s_patch_version_field;
+static jfieldID s_patch_type_field;
+static jfieldID s_patch_program_id_field;
+static jfieldID s_patch_title_id_field;
 
-    jclass integer_class;
-    jmethodID integer_constructor;
-    jmethodID integer_value_method;
+static jclass s_double_class;
+static jmethodID s_double_constructor;
+static jmethodID s_double_value_method;
 
-    jclass boolean_class;
-    jmethodID boolean_constructor;
-    jmethodID boolean_value_method;
+static jclass s_integer_class;
+static jmethodID s_integer_constructor;
+static jmethodID s_integer_value_method;
 
-    jclass player_input_class;
-    jmethodID player_input_constructor;
-    jfieldID player_input_connected_field;
-    jfieldID player_input_buttons_field;
-    jfieldID player_input_analogs_field;
-    jfieldID player_input_motions_field;
-    jfieldID player_input_vibration_enabled_field;
-    jfieldID player_input_vibration_strength_field;
-    jfieldID player_input_body_color_left_field;
-    jfieldID player_input_body_color_right_field;
-    jfieldID player_input_button_color_left_field;
-    jfieldID player_input_button_color_right_field;
-    jfieldID player_input_profile_name_field;
-    jfieldID player_input_use_system_vibrator_field;
+static jclass s_boolean_class;
+static jmethodID s_boolean_constructor;
+static jmethodID s_boolean_value_method;
 
-    jclass yuzu_input_device_interface;
-    jmethodID yuzu_input_device_get_name;
-    jmethodID yuzu_input_device_get_guid;
-    jmethodID yuzu_input_device_get_port;
-    jmethodID yuzu_input_device_get_supports_vibration;
-    jmethodID yuzu_input_device_vibrate;
-    jmethodID yuzu_input_device_get_axes;
-    jmethodID yuzu_input_device_has_keys;
+static jclass s_player_input_class;
+static jmethodID s_player_input_constructor;
+static jfieldID s_player_input_connected_field;
+static jfieldID s_player_input_buttons_field;
+static jfieldID s_player_input_analogs_field;
+static jfieldID s_player_input_motions_field;
+static jfieldID s_player_input_vibration_enabled_field;
+static jfieldID s_player_input_vibration_strength_field;
+static jfieldID s_player_input_body_color_left_field;
+static jfieldID s_player_input_body_color_right_field;
+static jfieldID s_player_input_button_color_left_field;
+static jfieldID s_player_input_button_color_right_field;
+static jfieldID s_player_input_profile_name_field;
+static jfieldID s_player_input_use_system_vibrator_field;
 
-    jmethodID add_netplay_message;
-    jmethodID clear_chat;
-} state;
+static jclass s_yuzu_input_device_interface;
+static jmethodID s_yuzu_input_device_get_name;
+static jmethodID s_yuzu_input_device_get_guid;
+static jmethodID s_yuzu_input_device_get_port;
+static jmethodID s_yuzu_input_device_get_supports_vibration;
+static jmethodID s_yuzu_input_device_vibrate;
+static jmethodID s_yuzu_input_device_get_axes;
+static jmethodID s_yuzu_input_device_has_keys;
+
+static jmethodID s_add_netplay_message;
+static jmethodID s_clear_chat;
 
 static constexpr jint JNI_VERSION = JNI_VERSION_1_6;
 
@@ -107,14 +106,14 @@ namespace Common::Android {
     JNIEnv *GetEnvForThread() {
         thread_local static struct OwnedEnv {
             OwnedEnv() {
-                status = state.java_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);
+                status = s_java_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);
                 if (status == JNI_EDETACHED)
-                    state.java_vm->AttachCurrentThread(&env, nullptr);
+                    s_java_vm->AttachCurrentThread(&env, nullptr);
             }
 
             ~OwnedEnv() {
                 if (status == JNI_EDETACHED)
-                    state.java_vm->DetachCurrentThread();
+                    s_java_vm->DetachCurrentThread();
             }
 
             int status;
@@ -124,303 +123,303 @@ namespace Common::Android {
     }
 
     jclass GetNativeLibraryClass() {
-        return state.native_library_class;
+        return s_native_library_class;
     }
 
     jclass GetDiskCacheProgressClass() {
-        return state.disk_cache_progress_class;
+        return s_disk_cache_progress_class;
     }
 
     jclass GetDiskCacheLoadCallbackStageClass() {
-        return state.load_callback_stage_class;
+        return s_load_callback_stage_class;
     }
 
     jclass GetGameDirClass() {
-        return state.game_dir_class;
+        return s_game_dir_class;
     }
 
     jmethodID GetGameDirConstructor() {
-        return state.game_dir_constructor;
+        return s_game_dir_constructor;
     }
 
     jmethodID GetExitEmulationActivity() {
-        return state.exit_emulation_activity;
+        return s_exit_emulation_activity;
     }
 
     jmethodID GetDiskCacheLoadProgress() {
-        return state.disk_cache_load_progress;
+        return s_disk_cache_load_progress;
     }
 
     jmethodID GetCopyToStorage() {
-        return state.copy_to_storage;
+        return s_copy_to_storage;
     }
 
     jmethodID GetFileExists() {
-        return state.file_exists;
+        return s_file_exists;
     }
 
     jmethodID GetFileExtension() {
-        return state.file_extension;
+        return s_file_extension;
     }
 
     jmethodID GetOnEmulationStarted() {
-        return state.on_emulation_started;
+        return s_on_emulation_started;
     }
 
     jmethodID GetOnEmulationStopped() {
-        return state.on_emulation_stopped;
+        return s_on_emulation_stopped;
     }
 
     jmethodID GetOnProgramChanged() {
-        return state.on_program_changed;
+        return s_on_program_changed;
     }
 
     jclass GetGameClass() {
-        return state.game_class;
+        return s_game_class;
     }
 
     jmethodID GetGameConstructor() {
-        return state.game_constructor;
+        return s_game_constructor;
     }
 
     jfieldID GetGameTitleField() {
-        return state.game_title_field;
+        return s_game_title_field;
     }
 
     jfieldID GetGamePathField() {
-        return state.game_path_field;
+        return s_game_path_field;
     }
 
     jfieldID GetGameProgramIdField() {
-        return state.game_program_id_field;
+        return s_game_program_id_field;
     }
 
     jfieldID GetGameDeveloperField() {
-        return state.game_developer_field;
+        return s_game_developer_field;
     }
 
     jfieldID GetGameVersionField() {
-        return state.game_version_field;
+        return s_game_version_field;
     }
 
     jfieldID GetGameIsHomebrewField() {
-        return state.game_is_homebrew_field;
+        return s_game_is_homebrew_field;
     }
 
     jclass GetStringClass() {
-        return state.string_class;
+        return s_string_class;
     }
 
     jclass GetPairClass() {
-        return state.pair_class;
+        return s_pair_class;
     }
 
     jmethodID GetPairConstructor() {
-        return state.pair_constructor;
+        return s_pair_constructor;
     }
 
     jfieldID GetPairFirstField() {
-        return state.pair_first_field;
+        return s_pair_first_field;
     }
 
     jfieldID GetPairSecondField() {
-        return state.pair_second_field;
+        return s_pair_second_field;
     }
 
     jclass GetOverlayControlDataClass() {
-        return state.overlay_control_data_class;
+        return s_overlay_control_data_class;
     }
 
     jmethodID GetOverlayControlDataConstructor() {
-        return state.overlay_control_data_constructor;
+        return s_overlay_control_data_constructor;
     }
 
     jfieldID GetOverlayControlDataIdField() {
-        return state.overlay_control_data_id_field;
+        return s_overlay_control_data_id_field;
     }
 
     jfieldID GetOverlayControlDataEnabledField() {
-        return state.overlay_control_data_enabled_field;
+        return s_overlay_control_data_enabled_field;
     }
 
     jfieldID GetOverlayControlDataIndividualScaleField() {
-        return state.overlay_control_data_individual_scale_field;
+        return s_overlay_control_data_individual_scale_field;
     }
 
     jfieldID GetOverlayControlDataLandscapePositionField() {
-        return state.overlay_control_data_landscape_position_field;
+        return s_overlay_control_data_landscape_position_field;
     }
 
     jfieldID GetOverlayControlDataPortraitPositionField() {
-        return state.overlay_control_data_portrait_position_field;
+        return s_overlay_control_data_portrait_position_field;
     }
 
     jfieldID GetOverlayControlDataFoldablePositionField() {
-        return state.overlay_control_data_foldable_position_field;
+        return s_overlay_control_data_foldable_position_field;
     }
 
     jclass GetPatchClass() {
-        return state.patch_class;
+        return s_patch_class;
     }
 
     jmethodID GetPatchConstructor() {
-        return state.patch_constructor;
+        return s_patch_constructor;
     }
 
     jfieldID GetPatchEnabledField() {
-        return state.patch_enabled_field;
+        return s_patch_enabled_field;
     }
 
     jfieldID GetPatchNameField() {
-        return state.patch_name_field;
+        return s_patch_name_field;
     }
 
     jfieldID GetPatchVersionField() {
-        return state.patch_version_field;
+        return s_patch_version_field;
     }
 
     jfieldID GetPatchTypeField() {
-        return state.patch_type_field;
+        return s_patch_type_field;
     }
 
     jfieldID GetPatchProgramIdField() {
-        return state.patch_program_id_field;
+        return s_patch_program_id_field;
     }
 
     jfieldID GetPatchTitleIdField() {
-        return state.patch_title_id_field;
+        return s_patch_title_id_field;
     }
 
     jclass GetDoubleClass() {
-        return state.double_class;
+        return s_double_class;
     }
 
     jmethodID GetDoubleConstructor() {
-        return state.double_constructor;
+        return s_double_constructor;
     }
 
     jmethodID GetDoubleValueMethod() {
-        return state.double_value_method;
+        return s_double_value_method;
     }
 
     jclass GetIntegerClass() {
-        return state.integer_class;
+        return s_integer_class;
     }
 
     jmethodID GetIntegerConstructor() {
-        return state.integer_constructor;
+        return s_integer_constructor;
     }
 
     jmethodID GetIntegerValueMethod() {
-        return state.integer_value_method;
+        return s_integer_value_method;
     }
 
     jclass GetBooleanClass() {
-        return state.boolean_class;
+        return s_boolean_class;
     }
 
     jmethodID GetBooleanConstructor() {
-        return state.boolean_constructor;
+        return s_boolean_constructor;
     }
 
     jmethodID GetBooleanValueMethod() {
-        return state.boolean_value_method;
+        return s_boolean_value_method;
     }
 
     jclass GetPlayerInputClass() {
-        return state.player_input_class;
+        return s_player_input_class;
     }
 
     jmethodID GetPlayerInputConstructor() {
-        return state.player_input_constructor;
+        return s_player_input_constructor;
     }
 
     jfieldID GetPlayerInputConnectedField() {
-        return state.player_input_connected_field;
+        return s_player_input_connected_field;
     }
 
     jfieldID GetPlayerInputButtonsField() {
-        return state.player_input_buttons_field;
+        return s_player_input_buttons_field;
     }
 
     jfieldID GetPlayerInputAnalogsField() {
-        return state.player_input_analogs_field;
+        return s_player_input_analogs_field;
     }
 
     jfieldID GetPlayerInputMotionsField() {
-        return state.player_input_motions_field;
+        return s_player_input_motions_field;
     }
 
     jfieldID GetPlayerInputVibrationEnabledField() {
-        return state.player_input_vibration_enabled_field;
+        return s_player_input_vibration_enabled_field;
     }
 
     jfieldID GetPlayerInputVibrationStrengthField() {
-        return state.player_input_vibration_strength_field;
+        return s_player_input_vibration_strength_field;
     }
 
     jfieldID GetPlayerInputBodyColorLeftField() {
-        return state.player_input_body_color_left_field;
+        return s_player_input_body_color_left_field;
     }
 
     jfieldID GetPlayerInputBodyColorRightField() {
-        return state.player_input_body_color_right_field;
+        return s_player_input_body_color_right_field;
     }
 
     jfieldID GetPlayerInputButtonColorLeftField() {
-        return state.player_input_button_color_left_field;
+        return s_player_input_button_color_left_field;
     }
 
     jfieldID GetPlayerInputButtonColorRightField() {
-        return state.player_input_button_color_right_field;
+        return s_player_input_button_color_right_field;
     }
 
     jfieldID GetPlayerInputProfileNameField() {
-        return state.player_input_profile_name_field;
+        return s_player_input_profile_name_field;
     }
 
     jfieldID GetPlayerInputUseSystemVibratorField() {
-        return state.player_input_use_system_vibrator_field;
+        return s_player_input_use_system_vibrator_field;
     }
 
     jclass GetYuzuInputDeviceInterface() {
-        return state.yuzu_input_device_interface;
+        return s_yuzu_input_device_interface;
     }
 
     jmethodID GetYuzuDeviceGetName() {
-        return state.yuzu_input_device_get_name;
+        return s_yuzu_input_device_get_name;
     }
 
     jmethodID GetYuzuDeviceGetGUID() {
-        return state.yuzu_input_device_get_guid;
+        return s_yuzu_input_device_get_guid;
     }
 
     jmethodID GetYuzuDeviceGetPort() {
-        return state.yuzu_input_device_get_port;
+        return s_yuzu_input_device_get_port;
     }
 
     jmethodID GetYuzuDeviceGetSupportsVibration() {
-        return state.yuzu_input_device_get_supports_vibration;
+        return s_yuzu_input_device_get_supports_vibration;
     }
 
     jmethodID GetYuzuDeviceVibrate() {
-        return state.yuzu_input_device_vibrate;
+        return s_yuzu_input_device_vibrate;
     }
 
     jmethodID GetYuzuDeviceGetAxes() {
-        return state.yuzu_input_device_get_axes;
+        return s_yuzu_input_device_get_axes;
     }
 
     jmethodID GetYuzuDeviceHasKeys() {
-        return state.yuzu_input_device_has_keys;
+        return s_yuzu_input_device_has_keys;
     }
 
     jmethodID GetAddNetPlayMessage() {
-        return state.add_netplay_message;
+        return s_add_netplay_message;
     }
 
     jmethodID ClearChat() {
-        return state.clear_chat;
+        return s_clear_chat;
     }
 
 #ifdef __cplusplus
@@ -437,20 +436,20 @@ namespace Common::Android {
 
         // UnInitialize Android Storage
         Common::FS::Android::UnRegisterCallbacks();
-        env->DeleteGlobalRef(state.native_library_class);
-        env->DeleteGlobalRef(state.disk_cache_progress_class);
-        env->DeleteGlobalRef(state.load_callback_stage_class);
-        env->DeleteGlobalRef(state.game_dir_class);
-        env->DeleteGlobalRef(state.game_class);
-        env->DeleteGlobalRef(state.string_class);
-        env->DeleteGlobalRef(state.pair_class);
-        env->DeleteGlobalRef(state.overlay_control_data_class);
-        env->DeleteGlobalRef(state.patch_class);
-        env->DeleteGlobalRef(state.double_class);
-        env->DeleteGlobalRef(state.integer_class);
-        env->DeleteGlobalRef(state.boolean_class);
-        env->DeleteGlobalRef(state.player_input_class);
-        env->DeleteGlobalRef(state.yuzu_input_device_interface);
+        env->DeleteGlobalRef(s_native_library_class);
+        env->DeleteGlobalRef(s_disk_cache_progress_class);
+        env->DeleteGlobalRef(s_load_callback_stage_class);
+        env->DeleteGlobalRef(s_game_dir_class);
+        env->DeleteGlobalRef(s_game_class);
+        env->DeleteGlobalRef(s_string_class);
+        env->DeleteGlobalRef(s_pair_class);
+        env->DeleteGlobalRef(s_overlay_control_data_class);
+        env->DeleteGlobalRef(s_patch_class);
+        env->DeleteGlobalRef(s_double_class);
+        env->DeleteGlobalRef(s_integer_class);
+        env->DeleteGlobalRef(s_boolean_class);
+        env->DeleteGlobalRef(s_player_input_class);
+        env->DeleteGlobalRef(s_yuzu_input_device_interface);
 
         // UnInitialize applets
         SoftwareKeyboard::CleanupJNI(env);
@@ -464,7 +463,7 @@ namespace Common::Android {
 #endif
 
 void Initialize(JavaVM* vm, JNIEnv *env) {
-    state.java_vm = vm;
+    s_java_vm = vm;
     InitFFmpegOnLoad(vm);
 
     if (env->ExceptionCheck()) {
@@ -473,169 +472,169 @@ void Initialize(JavaVM* vm, JNIEnv *env) {
 
     // Initialize Java classes
     const jclass native_library_class = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary");
-    state.native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
-    state.disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
+    s_native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
+    s_disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
         env->FindClass("org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress")));
-    state.load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
+    s_load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
         "org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress$LoadCallbackStage")));
 
     const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir");
-    state.game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
-    state.game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
+    s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
+    s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
                                               "(Ljava/lang/String;Z)V");
     env->DeleteLocalRef(game_dir_class);
 
     // Initialize methods
-    state.exit_emulation_activity =
-        env->GetStaticMethodID(state.native_library_class, "exitEmulationActivity", "(I)V");
-    state.disk_cache_load_progress =
-        env->GetStaticMethodID(state.disk_cache_progress_class, "loadProgress", "(III)V");
-    state.copy_to_storage = env->GetStaticMethodID(state.native_library_class, "copyFileToStorage",
+    s_exit_emulation_activity =
+        env->GetStaticMethodID(s_native_library_class, "exitEmulationActivity", "(I)V");
+    s_disk_cache_load_progress =
+        env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V");
+    s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage",
                                                "(Ljava/lang/String;Ljava/lang/String;)Z");
-    state.file_exists = env->GetStaticMethodID(state.native_library_class, "exists",
+    s_file_exists = env->GetStaticMethodID(s_native_library_class, "exists",
                                            "(Ljava/lang/String;)Z");
-    state.file_extension = env->GetStaticMethodID(state.native_library_class, "getFileExtension",
+    s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension",
                                               "(Ljava/lang/String;)Ljava/lang/String;");
-    state.on_emulation_started =
-        env->GetStaticMethodID(state.native_library_class, "onEmulationStarted", "()V");
-    state.on_emulation_stopped =
-        env->GetStaticMethodID(state.native_library_class, "onEmulationStopped", "(I)V");
-    state.on_program_changed =
-        env->GetStaticMethodID(state.native_library_class, "onProgramChanged", "(I)V");
+    s_on_emulation_started =
+        env->GetStaticMethodID(s_native_library_class, "onEmulationStarted", "()V");
+    s_on_emulation_stopped =
+        env->GetStaticMethodID(s_native_library_class, "onEmulationStopped", "(I)V");
+    s_on_program_changed =
+        env->GetStaticMethodID(s_native_library_class, "onProgramChanged", "(I)V");
 
     const jclass game_class = env->FindClass("org/yuzu/yuzu_emu/model/Game");
-    state.game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
-    state.game_constructor = env->GetMethodID(game_class, "<init>",
+    s_game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
+    s_game_constructor = env->GetMethodID(game_class, "<init>",
                                           "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
                                           "String;Ljava/lang/String;Ljava/lang/String;Z)V");
-    state.game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
-    state.game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
-    state.game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
-    state.game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
-    state.game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
-    state.game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
+    s_game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
+    s_game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
+    s_game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
+    s_game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
+    s_game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
+    s_game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
     env->DeleteLocalRef(game_class);
 
     const jclass string_class = env->FindClass("java/lang/String");
-    state.string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
+    s_string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
     env->DeleteLocalRef(string_class);
 
     const jclass pair_class = env->FindClass("kotlin/Pair");
-    state.pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
-    state.pair_constructor =
+    s_pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
+    s_pair_constructor =
         env->GetMethodID(pair_class, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
-    state.pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
-    state.pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
+    s_pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
+    s_pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
     env->DeleteLocalRef(pair_class);
 
     const jclass overlay_control_data_class =
         env->FindClass("org/yuzu/yuzu_emu/overlay/model/OverlayControlData");
-    state.overlay_control_data_class =
+    s_overlay_control_data_class =
         reinterpret_cast<jclass>(env->NewGlobalRef(overlay_control_data_class));
-    state.overlay_control_data_constructor =
+    s_overlay_control_data_constructor =
         env->GetMethodID(overlay_control_data_class, "<init>",
                          "(Ljava/lang/String;ZLkotlin/Pair;Lkotlin/Pair;Lkotlin/Pair;F)V");
-    state.overlay_control_data_id_field =
+    s_overlay_control_data_id_field =
         env->GetFieldID(overlay_control_data_class, "id", "Ljava/lang/String;");
-    state.overlay_control_data_enabled_field =
+    s_overlay_control_data_enabled_field =
         env->GetFieldID(overlay_control_data_class, "enabled", "Z");
-    state.overlay_control_data_landscape_position_field =
+    s_overlay_control_data_landscape_position_field =
         env->GetFieldID(overlay_control_data_class, "landscapePosition", "Lkotlin/Pair;");
-    state.overlay_control_data_portrait_position_field =
+    s_overlay_control_data_portrait_position_field =
         env->GetFieldID(overlay_control_data_class, "portraitPosition", "Lkotlin/Pair;");
-    state.overlay_control_data_foldable_position_field =
+    s_overlay_control_data_foldable_position_field =
         env->GetFieldID(overlay_control_data_class, "foldablePosition", "Lkotlin/Pair;");
-    state.overlay_control_data_individual_scale_field =
+    s_overlay_control_data_individual_scale_field =
         env->GetFieldID(overlay_control_data_class, "individualScale", "F");
     env->DeleteLocalRef(overlay_control_data_class);
 
     const jclass patch_class = env->FindClass("org/yuzu/yuzu_emu/model/Patch");
-    state.patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
-    state.patch_constructor = env->GetMethodID(
+    s_patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
+    s_patch_constructor = env->GetMethodID(
         patch_class, "<init>",
         "(ZLjava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;JI)V");
-    state.patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
-    state.patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
-    state.patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
-    state.patch_type_field = env->GetFieldID(patch_class, "type", "I");
-    state.patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
-    state.patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
+    s_patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
+    s_patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
+    s_patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
+    s_patch_type_field = env->GetFieldID(patch_class, "type", "I");
+    s_patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
+    s_patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
     env->DeleteLocalRef(patch_class);
 
     const jclass double_class = env->FindClass("java/lang/Double");
-    state.double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
-    state.double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
-    state.double_value_method = env->GetMethodID(double_class, "doubleValue", "()D");
+    s_double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
+    s_double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
+    s_double_value_method = env->GetMethodID(double_class, "doubleValue", "()D");
     env->DeleteLocalRef(double_class);
 
     const jclass int_class = env->FindClass("java/lang/Integer");
-    state.integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
-    state.integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
-    state.integer_value_method = env->GetMethodID(int_class, "intValue", "()I");
+    s_integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
+    s_integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
+    s_integer_value_method = env->GetMethodID(int_class, "intValue", "()I");
     env->DeleteLocalRef(int_class);
 
     const jclass boolean_class = env->FindClass("java/lang/Boolean");
-    state.boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
-    state.boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
-    state.boolean_value_method = env->GetMethodID(boolean_class, "booleanValue", "()Z");
+    s_boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
+    s_boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
+    s_boolean_value_method = env->GetMethodID(boolean_class, "booleanValue", "()Z");
     env->DeleteLocalRef(boolean_class);
 
     const jclass player_input_class =
         env->FindClass("org/yuzu/yuzu_emu/features/input/model/PlayerInput");
-    state.player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
-    state.player_input_constructor = env->GetMethodID(
+    s_player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
+    s_player_input_constructor = env->GetMethodID(
         player_input_class, "<init>",
         "(Z[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;ZIJJJJLjava/lang/String;Z)V");
-    state.player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
-    state.player_input_buttons_field =
+    s_player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
+    s_player_input_buttons_field =
         env->GetFieldID(player_input_class, "buttons", "[Ljava/lang/String;");
-    state.player_input_analogs_field =
+    s_player_input_analogs_field =
         env->GetFieldID(player_input_class, "analogs", "[Ljava/lang/String;");
-    state.player_input_motions_field =
+    s_player_input_motions_field =
         env->GetFieldID(player_input_class, "motions", "[Ljava/lang/String;");
-    state.player_input_vibration_enabled_field =
+    s_player_input_vibration_enabled_field =
         env->GetFieldID(player_input_class, "vibrationEnabled", "Z");
-    state.player_input_vibration_strength_field =
+    s_player_input_vibration_strength_field =
         env->GetFieldID(player_input_class, "vibrationStrength", "I");
-    state.player_input_body_color_left_field =
+    s_player_input_body_color_left_field =
         env->GetFieldID(player_input_class, "bodyColorLeft", "J");
-    state.player_input_body_color_right_field =
+    s_player_input_body_color_right_field =
         env->GetFieldID(player_input_class, "bodyColorRight", "J");
-    state.player_input_button_color_left_field =
+    s_player_input_button_color_left_field =
         env->GetFieldID(player_input_class, "buttonColorLeft", "J");
-    state.player_input_button_color_right_field =
+    s_player_input_button_color_right_field =
         env->GetFieldID(player_input_class, "buttonColorRight", "J");
-    state.player_input_profile_name_field =
+    s_player_input_profile_name_field =
         env->GetFieldID(player_input_class, "profileName", "Ljava/lang/String;");
-    state.player_input_use_system_vibrator_field =
+    s_player_input_use_system_vibrator_field =
         env->GetFieldID(player_input_class, "useSystemVibrator", "Z");
     env->DeleteLocalRef(player_input_class);
 
     const jclass yuzu_input_device_interface =
         env->FindClass("org/yuzu/yuzu_emu/features/input/YuzuInputDevice");
-    state.yuzu_input_device_interface =
+    s_yuzu_input_device_interface =
         reinterpret_cast<jclass>(env->NewGlobalRef(yuzu_input_device_interface));
-    state.yuzu_input_device_get_name =
+    s_yuzu_input_device_get_name =
         env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;");
-    state.yuzu_input_device_get_guid =
+    s_yuzu_input_device_get_guid =
         env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;");
-    state.yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
+    s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
                                                     "()I");
-    state.yuzu_input_device_get_supports_vibration =
+    s_yuzu_input_device_get_supports_vibration =
         env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z");
-    state.yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
+    s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
                                                    "(F)V");
-    state.yuzu_input_device_get_axes =
+    s_yuzu_input_device_get_axes =
         env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;");
-    state.yuzu_input_device_has_keys =
+    s_yuzu_input_device_has_keys =
         env->GetMethodID(yuzu_input_device_interface, "hasKeys", "([I)[Z");
     env->DeleteLocalRef(yuzu_input_device_interface);
-    state.add_netplay_message = env->GetStaticMethodID(state.native_library_class, "addNetPlayMessage",
+    s_add_netplay_message = env->GetStaticMethodID(s_native_library_class, "addNetPlayMessage",
                                                    "(ILjava/lang/String;)V");
-    state.clear_chat = env->GetStaticMethodID(state.native_library_class, "clearChat", "()V");
+    s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V");
 
     // Initialize Android Storage
-    Common::FS::Android::RegisterCallbacks(env, state.native_library_class);
+    Common::FS::Android::RegisterCallbacks(env, s_native_library_class);
 
     // Initialize applets
     Common::Android::SoftwareKeyboard::InitJNI(env);

src/common/bit_util.h

@@ -22,22 +22,36 @@ template <typename T>
     return std::size_t(sizeof(T) * CHAR_BIT);
 }
 
+template<typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] constexpr u32 MostSignificantBit(const T value) {
+    return u32(sizeof(T) * CHAR_BIT - 1 - std::countl_zero(value));
+}
+
 template<typename T>
     requires std::is_integral_v<T>
 [[nodiscard]] constexpr T Log2Floor(const T value) {
-    return std::bit_width(value) - 1;
+    return T(MostSignificantBit<T>(value));
 }
 
 template<typename T>
     requires std::is_integral_v<T>
 [[nodiscard]] constexpr T Log2Ceil(const T value) {
-    return std::bit_width(value - 1);
+    const T log2_f = Log2Floor<T>(value);
+    return T(log2_f + T((value ^ (T(1ULL) << log2_f)) != T(0ULL)));
+}
+
+template <typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] T NextPow2(T value) {
+    return T(1ULL << (sizeof(T) * CHAR_BIT - std::countl_zero(value - 1U)));
 }
 
 template <size_t bit_index, typename T>
-    requires (std::is_integral_v<T> && bit_index < BitSize<T>())
+    requires std::is_integral_v<T>
 [[nodiscard]] constexpr bool Bit(const T value) {
-    return (T(value >> bit_index) & T(1)) == T(1);
+    static_assert(bit_index < BitSize<T>(), "bit_index must be smaller than size of T");
+    return ((value >> bit_index) & T(1)) == T(1);
 }
 
 } // namespace Common

src/common/container_hash.h

@@ -25,18 +25,26 @@ template <typename T>
     requires std::is_unsigned_v<T>
 inline std::size_t HashValue(T val) {
     const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
-    const unsigned int length = (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
+    const unsigned int length =
+        (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
+
     std::size_t seed = 0;
-    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
-        seed ^= std::size_t(val >> i) + (seed << 6) + (seed >> 2);
-    return seed ^= std::size_t(val) + (seed << 6) + (seed >> 2);
+
+    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) {
+        seed ^= static_cast<size_t>(val >> i) + (seed << 6) + (seed >> 2);
+    }
+
+    seed ^= static_cast<size_t>(val) + (seed << 6) + (seed >> 2);
+
+    return seed;
 }
 
 template <size_t Bits>
 struct HashCombineImpl {
     template <typename T>
     static inline T fn(T seed, T value) {
-        return seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        return seed;
     }
 };
 

src/common/div_ceil.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,14 +12,14 @@ namespace Common {
 template <typename N, typename D>
     requires std::is_integral_v<N> && std::is_unsigned_v<D>
 [[nodiscard]] constexpr N DivCeil(N number, D divisor) {
-    return N((D(number) + divisor - 1) / divisor);
+    return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }
 
 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
     requires std::is_integral_v<N> && std::is_unsigned_v<D>
 [[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
-    return N((D(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
+    return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }
 
 } // namespace Common

src/common/hash.h

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: 2015 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <cstddef>
+#include <utility>
+#include <boost/functional/hash.hpp>
+
+namespace Common {
+
+struct PairHash {
+    template <class T1, class T2>
+    std::size_t operator()(const std::pair<T1, T2>& pair) const noexcept {
+        std::size_t seed = std::hash<T1>()(pair.first);
+        boost::hash_combine(seed, std::hash<T2>()(pair.second));
+        return seed;
+    }
+};
+
+template <typename T>
+struct IdentityHash {
+    [[nodiscard]] size_t operator()(T value) const noexcept {
+        return static_cast<size_t>(value);
+    }
+};
+
+} // namespace Common

src/common/hex_util.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -19,12 +16,14 @@ namespace Common {
 
 [[nodiscard]] constexpr u8 ToHexNibble(char c) {
     if (c >= 65 && c <= 70) {
-        return u8(c - 55);
+        return static_cast<u8>(c - 55);
     }
+
     if (c >= 97 && c <= 102) {
-        return u8(c - 87);
+        return static_cast<u8>(c - 87);
     }
-    return u8(c - 48);
+
+    return static_cast<u8>(c - 48);
 }
 
 [[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
@@ -32,28 +31,35 @@ namespace Common {
 template <std::size_t Size, bool le = false>
 [[nodiscard]] constexpr std::array<u8, Size> HexStringToArray(std::string_view str) {
     ASSERT_MSG(Size * 2 <= str.size(), "Invalid string size");
+
     std::array<u8, Size> out{};
     if constexpr (le) {
         for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) {
-            out[i / 2] = u8((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
         }
     } else {
         for (std::size_t i = 0; i < 2 * Size; i += 2) {
-            out[i / 2] = u8((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
         }
     }
     return out;
 }
 
 template <typename ContiguousContainer>
-    requires std::is_same_v<typename ContiguousContainer::value_type, u8>
 [[nodiscard]] std::string HexToString(const ContiguousContainer& data, bool upper = true) {
+    static_assert(std::is_same_v<typename ContiguousContainer::value_type, u8>,
+                  "Underlying type within the contiguous container must be u8.");
+
     constexpr std::size_t pad_width = 2;
+
     std::string out;
     out.reserve(std::size(data) * pad_width);
+
     const auto format_str = fmt::runtime(upper ? "{:02X}" : "{:02x}");
-    for (const u8 c : data)
+    for (const u8 c : data) {
         out += fmt::format(format_str, c);
+    }
+
     return out;
 }
 

src/common/logging.cpp

@@ -10,7 +10,6 @@
 #include <cstdlib>
 #include <regex>
 #include <thread>
-#include <boost/algorithm/string/predicate.hpp>
 
 #if defined(__ANDROID__)
 #include <android/log.h>
@@ -96,10 +95,9 @@ std::string FormatLogMessage(const Entry& entry) noexcept {
 
 template <typename It>
 Level GetLevelByName(const It begin, const It end) {
-    std::string_view const sv{begin, end};
     for (u32 i = 0; i < u32(Level::Count); ++i) {
-        auto const level_name = GetLevelName(Level(i));
-        if (boost::iequals(sv, level_name))
+        const char* level_name = GetLevelName(Level(i));
+        if (Common::ComparePartialString(begin, end, level_name))
             return Level(i);
     }
     return Level::Count;
@@ -107,10 +105,9 @@ Level GetLevelByName(const It begin, const It end) {
 
 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    std::string_view const sv{begin, end};
     for (u32 i = 0; i < u32(Class::Count); ++i) {
-        auto const level_name = GetLogClassName(Class(i));
-        if (boost::iequals(sv, level_name))
+        const char* level_name = GetLogClassName(Class(i));
+        if (Common::ComparePartialString(begin, end, level_name))
             return Class(i);
     }
     return Class::Count;
@@ -123,13 +120,12 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
         LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}", std::string(begin, end));
         return false;
     }
-    auto const sv = std::string_view{begin, level_separator};
-    auto const level = GetLevelByName(level_separator + 1, end);
+    const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
         LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
         return false;
     }
-    if (boost::iequals(sv, "*")) {
+    if (Common::ComparePartialString(begin, level_separator, "*")) {
         instance.class_levels.fill(level);
         return true;
     }

src/common/param_package.cpp

@@ -8,9 +8,6 @@
 #include <stdexcept>
 #include <utility>
 #include <vector>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/split.hpp>
 
 #include "common/logging.h"
 #include "common/param_package.h"
@@ -18,16 +15,17 @@
 
 namespace Common {
 
-constexpr auto KEY_VALUE_SEPARATOR = ":";
-constexpr auto PARAM_SEPARATOR = ",";
-constexpr auto ESCAPE_CHARACTER = "$";
-constexpr auto KEY_VALUE_SEPARATOR_ESCAPE = "$0";
-constexpr auto PARAM_SEPARATOR_ESCAPE = "$1";
-constexpr auto ESCAPE_CHARACTER_ESCAPE = "$2";
+constexpr char KEY_VALUE_SEPARATOR = ':';
+constexpr char PARAM_SEPARATOR = ',';
+
+constexpr char ESCAPE_CHARACTER = '$';
+constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
+constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
+constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
 /// A placeholder for empty param packages to avoid empty strings
 /// (they may be recognized as "not set" by some frontend libraries like qt)
-constexpr auto EMPTY_PLACEHOLDER = "[empty]";
+constexpr char EMPTY_PLACEHOLDER[] = "[empty]";
 
 ParamPackage::ParamPackage(const std::string& serialized) {
     if (serialized == EMPTY_PLACEHOLDER) {
@@ -35,20 +33,20 @@ ParamPackage::ParamPackage(const std::string& serialized) {
     }
 
     std::vector<std::string> pairs;
-    boost::split(pairs, serialized, boost::is_any_of(PARAM_SEPARATOR));
+    Common::SplitString(serialized, PARAM_SEPARATOR, pairs);
 
     for (const std::string& pair : pairs) {
         std::vector<std::string> key_value;
-        boost::split(key_value, pair, boost::is_any_of(KEY_VALUE_SEPARATOR));
+        Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value);
         if (key_value.size() != 2) {
             LOG_ERROR(Common, "invalid key pair {}", pair);
             continue;
         }
 
-        for (auto& part : key_value) {
-            boost::replace_all(part, KEY_VALUE_SEPARATOR_ESCAPE, KEY_VALUE_SEPARATOR);
-            boost::replace_all(part, PARAM_SEPARATOR_ESCAPE, PARAM_SEPARATOR);
-            boost::replace_all(part, ESCAPE_CHARACTER_ESCAPE, ESCAPE_CHARACTER);
+        for (std::string& part : key_value) {
+            part = Common::ReplaceAll(part, KEY_VALUE_SEPARATOR_ESCAPE, {KEY_VALUE_SEPARATOR});
+            part = Common::ReplaceAll(part, PARAM_SEPARATOR_ESCAPE, {PARAM_SEPARATOR});
+            part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER});
         }
 
         Set(key_value[0], std::move(key_value[1]));
@@ -65,10 +63,10 @@ std::string ParamPackage::Serialize() const {
 
     for (const auto& pair : data) {
         std::array<std::string, 2> key_value{{pair.first, pair.second}};
-        for (auto& part : key_value) {
-            boost::replace_all(part, ESCAPE_CHARACTER, ESCAPE_CHARACTER_ESCAPE);
-            boost::replace_all(part, PARAM_SEPARATOR, PARAM_SEPARATOR_ESCAPE);
-            boost::replace_all(part, KEY_VALUE_SEPARATOR, KEY_VALUE_SEPARATOR_ESCAPE);
+        for (std::string& part : key_value) {
+            part = Common::ReplaceAll(part, {ESCAPE_CHARACTER}, ESCAPE_CHARACTER_ESCAPE);
+            part = Common::ReplaceAll(part, {PARAM_SEPARATOR}, PARAM_SEPARATOR_ESCAPE);
+            part = Common::ReplaceAll(part, {KEY_VALUE_SEPARATOR}, KEY_VALUE_SEPARATOR_ESCAPE);
         }
         result += key_value[0] + KEY_VALUE_SEPARATOR + key_value[1] + PARAM_SEPARATOR;
     }

src/common/string_util.cpp

@@ -24,6 +24,22 @@
 
 namespace Common {
 
+/// Make a string lowercase
+std::string ToLower(const std::string_view sv) {
+    std::string str{sv};
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](auto const c) { return char(std::tolower(c)); });
+    return str;
+}
+
+/// Make a string uppercase
+std::string ToUpper(const std::string_view sv) {
+    std::string str{sv};
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](auto const c) { return char(std::toupper(c)); });
+    return str;
+}
+
 bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
                std::string* _pExtension) {
     if (full_path.empty())
@@ -64,6 +80,41 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     return true;
 }
 
+void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
+    std::istringstream iss(str);
+    output.resize(1);
+
+    while (std::getline(iss, *output.rbegin(), delim)) {
+        output.emplace_back();
+    }
+
+    output.pop_back();
+}
+
+std::string TabsToSpaces(int tab_size, std::string in) {
+    std::size_t i = 0;
+
+    while ((i = in.find('\t')) != std::string::npos) {
+        in.replace(i, 1, tab_size, ' ');
+    }
+
+    return in;
+}
+
+std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
+    std::size_t pos = 0;
+
+    if (src == dest)
+        return result;
+
+    while ((pos = result.find(src, pos)) != std::string::npos) {
+        result.replace(pos, src.size(), dest);
+        pos += dest.length();
+    }
+
+    return result;
+}
+
 std::string UTF16ToUTF8(std::u16string_view input) {
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.to_bytes(input.data(), input.data() + input.size());

src/common/string_util.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
@@ -16,6 +16,12 @@
 
 namespace Common {
 
+/// Make a string lowercase
+[[nodiscard]] std::string ToLower(const std::string_view sv);
+
+/// Make a string uppercase
+[[nodiscard]] std::string ToUpper(const std::string_view sv);
+
 [[nodiscard]] inline std::string StringFromBuffer(std::span<const u8> data) noexcept {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
@@ -23,8 +29,37 @@ namespace Common {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
 
+/// Turns "  hej " into "hej". Also handles tabs.
+[[nodiscard]] inline std::string StripSpaces(const std::string_view str) noexcept {
+    const std::size_t s = str.find_first_not_of(" \t\r\n");
+    if (str.npos != s)
+        return std::string{str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1)};
+    return {};
+}
+
+/// "\"hello\"" is turned to "hello"
+/// This one assumes that the string has already been space stripped in both
+/// ends, as done by StripSpaces above, for example.
+[[nodiscard]] inline std::string StripQuotes(const std::string_view s) noexcept {
+    if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
+        return std::string{s.substr(1, s.size() - 2)};
+    return std::string{s};
+}
+
+[[nodiscard]] inline std::string StringFromBool(bool value) noexcept {
+    return value ? "True" : "False";
+}
+
+[[nodiscard]] std::string TabsToSpaces(int tab_size, std::string in);
+
+void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
+
 // "C:/Windows/winhelp.exe" to "C:/Windows/", "winhelp", ".exe"
-bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension);
+bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
+               std::string* _pExtension);
+
+[[nodiscard]] std::string ReplaceAll(std::string result, const std::string& src,
+                                     const std::string& dest);
 
 [[nodiscard]] std::string UTF16ToUTF8(std::u16string_view input);
 [[nodiscard]] std::u16string UTF8ToUTF16(std::string_view input);
@@ -38,13 +73,30 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
 
 [[nodiscard]] std::u16string U16StringFromBuffer(const u16* input, std::size_t length);
 
+/**
+ * Compares the string defined by the range [`begin`, `end`) to the null-terminated C-string
+ * `other` for equality.
+ */
+template <typename InIt>
+[[nodiscard]] inline bool ComparePartialString(InIt begin, InIt end, const char* other) noexcept {
+    for (; begin != end && *other != '\0'; ++begin, ++other) {
+        if (*begin != *other) {
+            return false;
+        }
+    }
+    // Only return true if both strings finished at the same point
+    return (begin == end) == (*other == '\0');
+}
+
 /// Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
 /// NUL-terminated then the string ends at max_len characters.
-[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer, std::size_t max_len);
+[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer,
+                                                              std::size_t max_len);
 
 /// Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
 /// null-terminated, then the string ends at the greatest multiple of two less then or equal to
 /// max_len_bytes.
-[[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer, std::size_t max_len);
+[[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
+                                                                      std::size_t max_len);
 
 } // namespace Common

src/common/zbic_compression.cpp

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <cstring>
-
-#include "common/zbic_compression.h"
-
-#define ZSTD_ZBIC_SUPPORT 1
-#define ZSTDLIB_VISIBLE static
-#define ZSTDLIB_HIDDEN static
-#define ZSTDERRORLIB_VISIBLE static
-#define ZSTDERRORLIB_HIDDEN static
-#undef ZSTD_MULTITHREAD
-
-#if defined(__ANDROID__)
-#undef _GNU_SOURCE
-#endif
-
-#include "zstd.h"
-#define g_ZSTD_threading_useless_symbol g_ZSTD_zbic_threading_useless_symbol
-#include "zstd.c"
-#undef g_ZSTD_threading_useless_symbol
-
-namespace Common::Compression {
-
-bool IsZBIC(std::span<const u8> src) {
-    if (src.size() < sizeof(u32)) {
-        return false;
-    }
-    u32 magic = 0;
-    std::memcpy(&magic, src.data(), sizeof(u32));
-    return magic == ZSTD_MAGICNUMBER; // 0x4349425A ("ZBIC")
-}
-
-int DecompressDataZBIC(std::span<u8> dst, std::span<const u8> src) {
-    if (dst.empty() || src.empty()) {
-        return -1;
-    }
-    const size_t res = ZSTD_decompress(dst.data(), dst.size(), src.data(), src.size());
-    if (ZSTD_isError(res)) {
-        return -1;
-    }
-    return static_cast<int>(res);
-}
-
-} // namespace Common::Compression

src/common/zbic_compression.h

@@ -1,15 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <span>
-#include "common/common_types.h"
-
-namespace Common::Compression {
-
-[[nodiscard]] bool IsZBIC(std::span<const u8> src);
-
-[[nodiscard]] int DecompressDataZBIC(std::span<u8> dst, std::span<const u8> src);
-
-} // namespace Common::Compression

src/core/CMakeLists.txt

@@ -444,28 +444,18 @@ add_library(core STATIC
     hle/service/am/process_creation.h
     hle/service/am/process_holder.cpp
     hle/service/am/process_holder.h
-    hle/service/am/service/all_system_applet_proxies_service.cpp
-    hle/service/am/service/all_system_applet_proxies_service.h
-    hle/service/am/service/applet_common_functions.cpp
-    hle/service/am/service/applet_common_functions.h
     hle/service/am/service/application_accessor.cpp
     hle/service/am/service/application_accessor.h
     hle/service/am/service/application_creator.cpp
     hle/service/am/service/application_creator.h
     hle/service/am/service/application_functions.cpp
     hle/service/am/service/application_functions.h
-    hle/service/am/service/application_proxy.cpp
-    hle/service/am/service/application_proxy.h
-    hle/service/am/service/application_proxy_service.cpp
-    hle/service/am/service/application_proxy_service.h
     hle/service/am/service/audio_controller.cpp
     hle/service/am/service/audio_controller.h
     hle/service/am/service/common_state_getter.cpp
     hle/service/am/service/common_state_getter.h
     hle/service/am/service/cradle_firmware_updater.cpp
     hle/service/am/service/cradle_firmware_updater.h
-    hle/service/am/service/debug_functions.cpp
-    hle/service/am/service/debug_functions.h
     hle/service/am/service/display_controller.cpp
     hle/service/am/service/display_controller.h
     hle/service/am/service/global_state_controller.cpp
@@ -474,28 +464,14 @@ add_library(core STATIC
     hle/service/am/service/home_menu_functions.h
     hle/service/am/service/library_applet_accessor.cpp
     hle/service/am/service/library_applet_accessor.h
-    hle/service/am/service/library_applet_creator.cpp
-    hle/service/am/service/library_applet_creator.h
-    hle/service/am/service/library_applet_proxy.cpp
-    hle/service/am/service/library_applet_proxy.h
-    hle/service/am/service/library_applet_self_accessor.cpp
-    hle/service/am/service/library_applet_self_accessor.h
-    hle/service/am/service/lock_accessor.cpp
-    hle/service/am/service/lock_accessor.h
     hle/service/am/service/overlay_functions.cpp
     hle/service/am/service/overlay_functions.h
-    hle/service/am/service/overlay_applet_proxy.cpp
-    hle/service/am/service/overlay_applet_proxy.h
     hle/service/am/service/process_winding_controller.cpp
     hle/service/am/service/process_winding_controller.h
     hle/service/am/service/self_controller.cpp
     hle/service/am/service/self_controller.h
     hle/service/am/service/storage.cpp
     hle/service/am/service/storage.h
-    hle/service/am/service/storage_accessor.cpp
-    hle/service/am/service/storage_accessor.h
-    hle/service/am/service/system_applet_proxy.cpp
-    hle/service/am/service/system_applet_proxy.h
     hle/service/am/service/window_controller.cpp
     hle/service/am/service/window_controller.h
     hle/service/am/window_system.cpp
@@ -580,20 +556,8 @@ add_library(core STATIC
     hle/service/btdrv/btdrv.h
     hle/service/btm/btm.cpp
     hle/service/btm/btm.h
-    hle/service/btm/btm_debug.cpp
-    hle/service/btm/btm_debug.h
-    hle/service/btm/btm_system.cpp
-    hle/service/btm/btm_system.h
-    hle/service/btm/btm_system_core.cpp
-    hle/service/btm/btm_system_core.h
-    hle/service/btm/btm_user.cpp
-    hle/service/btm/btm_user.h
-    hle/service/btm/btm_user_core.cpp
-    hle/service/btm/btm_user_core.h
     hle/service/caps/caps.cpp
     hle/service/caps/caps.h
-    hle/service/caps/caps_a.cpp
-    hle/service/caps/caps_a.h
     hle/service/caps/caps_c.cpp
     hle/service/caps/caps_c.h
     hle/service/caps/caps_manager.cpp
@@ -618,10 +582,6 @@ add_library(core STATIC
     hle/service/eupld/eupld.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
-    hle/service/fatal/fatal_p.cpp
-    hle/service/fatal/fatal_p.h
-    hle/service/fatal/fatal_u.cpp
-    hle/service/fatal/fatal_u.h
     hle/service/fgm/fgm.cpp
     hle/service/fgm/fgm.h
     hle/service/filesystem/filesystem.cpp
@@ -653,8 +613,6 @@ add_library(core STATIC
     hle/service/filesystem/save_data_controller.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
-    hle/service/friend/friend_interface.cpp
-    hle/service/friend/friend_interface.h
     hle/service/glue/arp.cpp
     hle/service/glue/arp.h
     hle/service/glue/bgtc.cpp
@@ -723,8 +681,6 @@ add_library(core STATIC
     hle/service/ldn/monitor_service.h
     hle/service/ldn/sf_monitor_service.cpp
     hle/service/ldn/sf_monitor_service.h
-    hle/service/ldn/sf_service.cpp
-    hle/service/ldn/sf_service.h
     hle/service/ldn/sf_service_monitor.cpp
     hle/service/ldn/sf_service_monitor.h
     hle/service/ldn/system_local_communication_service.cpp
@@ -913,8 +869,6 @@ add_library(core STATIC
     hle/service/olsc/native_handle_holder.h
     hle/service/olsc/olsc_service_for_application.cpp
     hle/service/olsc/olsc_service_for_application.h
-    hle/service/olsc/olsc_service_for_system_service.cpp
-    hle/service/olsc/olsc_service_for_system_service.h
     hle/service/olsc/olsc.cpp
     hle/service/olsc/olsc.h
     hle/service/olsc/remote_storage_controller.cpp
@@ -944,14 +898,8 @@ add_library(core STATIC
     hle/service/os/process.h
     hle/service/pcie/pcie.cpp
     hle/service/pcie/pcie.h
-    hle/service/pctl/parental_control_service_factory.cpp
-    hle/service/pctl/parental_control_service_factory.h
-    hle/service/pctl/parental_control_service.cpp
-    hle/service/pctl/parental_control_service.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
-    hle/service/pctl/pctl_results.h
-    hle/service/pctl/pctl_types.h
     hle/service/pcv/pcv.cpp
     hle/service/pcv/pcv.h
     hle/service/pm/pm.cpp
@@ -961,18 +909,8 @@ add_library(core STATIC
     hle/service/psc/ovln/ovln_types.h
     hle/service/psc/ovln/receiver_service.cpp
     hle/service/psc/ovln/receiver_service.h
-    hle/service/psc/ovln/receiver.cpp
-    hle/service/psc/ovln/receiver.h
     hle/service/psc/ovln/sender_service.cpp
     hle/service/psc/ovln/sender_service.h
-    hle/service/psc/ovln/sender.cpp
-    hle/service/psc/ovln/sender.h
-    hle/service/psc/pm_control.cpp
-    hle/service/psc/pm_control.h
-    hle/service/psc/pm_module.cpp
-    hle/service/psc/pm_module.h
-    hle/service/psc/pm_service.cpp
-    hle/service/psc/pm_service.h
     hle/service/psc/psc.cpp
     hle/service/psc/psc.h
     hle/service/psc/time/alarms.cpp
@@ -1023,10 +961,6 @@ add_library(core STATIC
     hle/service/ptm/ts.h
     hle/service/ro/ro.cpp
     hle/service/ro/ro.h
-    hle/service/ro/ro_nro_utils.cpp
-    hle/service/ro/ro_nro_utils.h
-    hle/service/ro/ro_results.h
-    hle/service/ro/ro_types.h
     hle/service/server_manager.cpp
     hle/service/server_manager.h
     hle/service/service.cpp
@@ -1055,8 +989,6 @@ add_library(core STATIC
     hle/service/set/system_settings_server.h
     hle/service/sm/sm.cpp
     hle/service/sm/sm.h
-    hle/service/sm/sm_controller.cpp
-    hle/service/sm/sm_controller.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
     hle/service/sockets/nsd.cpp
@@ -1222,7 +1154,7 @@ target_link_libraries(core PRIVATE
     RenderDoc::API
     ZLIB::ZLIB)
 
-target_link_libraries(core PUBLIC httplib::httplib zstd::zstd)
+target_link_libraries(core PUBLIC httplib::httplib zstd::zstd frozen::frozen-headers)
 
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PUBLIC ENABLE_WEB_SERVICE)

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -13,6 +13,7 @@
 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/code_page.h>
 #include "common/common_types.h"
+#include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "dynarmic/interface/A64/config.h"

src/core/cpu_manager.cpp

@@ -168,7 +168,7 @@ void CpuManager::ShutdownThread(Kernel::KernelCore& kernel) {
     UNREACHABLE();
 }
 
-void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"};
@@ -178,19 +178,26 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
 
+    // Cleanup
+    SCOPE_EXIT {
+        data.host_context->Exit();
+    };
+
     // Running
-    gpu_barrier->arrive_and_wait();
-    if (!stop_token.stop_requested()) {
-        if (!is_async_gpu && !is_multicore) {
-            system.GPU().ObtainContext();
-        }
-        auto& kernel = system.Kernel();
-        auto& scheduler = *kernel.CurrentScheduler();
-        auto* thread = scheduler.GetSchedulerCurrentThread();
-        Kernel::SetCurrentThread(kernel, thread);
-        Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext());
+    if (!gpu_barrier->Sync(token)) {
+        return;
     }
-    data.host_context->Exit();
+
+    if (!is_async_gpu && !is_multicore) {
+        system.GPU().ObtainContext();
+    }
+
+    auto& kernel = system.Kernel();
+    auto& scheduler = *kernel.CurrentScheduler();
+    auto* thread = scheduler.GetSchedulerCurrentThread();
+    Kernel::SetCurrentThread(kernel, thread);
+
+    Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext());
 }
 
 } // namespace Core

src/core/cpu_manager.h

@@ -8,7 +8,6 @@
 
 #include <array>
 #include <atomic>
-#include <barrier>
 #include <functional>
 #include <memory>
 #include <thread>
@@ -53,7 +52,7 @@ public:
     }
 
     void OnGpuReady() {
-        gpu_barrier->arrive_and_wait();
+        gpu_barrier->Sync();
     }
 
     void Initialize();
@@ -96,7 +95,7 @@ private:
 
     static constexpr std::size_t max_cycle_runs = 5;
 
-    std::optional<std::barrier<>> gpu_barrier{};
+    std::optional<Common::Barrier> gpu_barrier{};
     struct CoreData {
         std::shared_ptr<Common::Fiber> host_context;
         std::jthread host_thread;

src/core/crypto/key_manager.cpp

@@ -14,7 +14,6 @@
 #include <tuple>
 #include <vector>
 
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/evp.h>
 
 #include "common/fs/file.h"
@@ -623,7 +622,7 @@ void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_ti
                 Key128 key = Common::HexStringToArray<16>(out[1]);
                 s128_keys[{S128KeyType::Titlekey, rights_id[1], rights_id[0]}] = key;
             } else {
-                boost::algorithm::to_lower(out[0]);
+                out[0] = Common::ToLower(out[0]);
                 if (const auto iter128 = Find128ByName(out[0]); iter128 != s128_file_id.end()) {
                     const auto& index = iter128->second;
                     const Key128 key = Common::HexStringToArray<16>(out[1]);

src/core/crypto/partition_data_manager.cpp

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <cstring>
-#include <boost/algorithm/string/case_conv.hpp>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/hex_util.h"
@@ -42,13 +41,16 @@ static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect siz
 
 const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = 32;
 
-static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir, const std::string& name) {
-    const auto upper = boost::algorithm::to_upper_copy(name);
+static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
+                                                   const std::string& name) {
+    const auto upper = Common::ToUpper(name);
+
     for (const auto& fname : {name, name + ".bin", upper, upper + ".BIN"}) {
         if (dir->GetFile(fname) != nullptr) {
             return dir->GetFile(fname);
         }
     }
+
     return nullptr;
 }
 

src/core/file_sys/patch_manager.cpp

@@ -8,7 +8,6 @@
 #include <array>
 #include <cstddef>
 #include <cstring>
-#include <boost/algorithm/string/case_conv.hpp>
 
 #include "common/assert.h"
 #include "common/hex_util.h"
@@ -74,10 +73,12 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
 #else
     const auto subdirs = dir->GetSubdirectories();
     for (const auto& subdir : subdirs) {
-        if (name == boost::algorithm::to_lower_copy(subdir->GetName())) {
+        std::string dir_name = Common::ToLower(subdir->GetName());
+        if (dir_name == name) {
             return subdir;
         }
     }
+
     return nullptr;
 #endif
 }

src/core/file_sys/registered_cache.cpp

@@ -8,7 +8,6 @@
 #include <limits>
 #include <random>
 #include <regex>
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/evp.h>
 #include "common/assert.h"
 #include "common/fs/path_util.h"
@@ -1415,10 +1414,11 @@ void ExternalContentProvider::ScanDirectory(const VirtualDir& dir) {
             continue;
         }
 
-        const auto ext = boost::to_lower_copy(filename.substr(dot_pos + 1));
-        if (ext == "nsp") {
+        const auto extension = Common::ToLower(filename.substr(dot_pos + 1));
+
+        if (extension == "nsp") {
             ProcessNSP(file);
-        } else if (ext == "xci") {
+        } else if (extension == "xci") {
             ProcessXCI(file);
         }
     }

src/core/file_sys/xts_archive.cpp

@@ -9,7 +9,6 @@
 #include <regex>
 #include <string>
 
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 
@@ -64,8 +63,8 @@ NAX::NAX(VirtualFile file_)
         return;
     }
 
-    const std::string two_dir = boost::algorithm::to_upper_copy(std::string{match[1]});
-    const std::string nca_id = boost::algorithm::to_lower_copy(std::string{match[2]});
+    const std::string two_dir = Common::ToUpper(std::string{match[1]});
+    const std::string nca_id = Common::ToLower(std::string{match[2]});
     status = Parse(fmt::format("/registered/{}/{}.nca", two_dir, nca_id));
 }
 

src/core/hardware_properties.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -22,14 +19,8 @@ constexpr u32 NUM_CPU_CORES = 4;               // Number of CPU Cores - sync wit
 
 // Virtual to Physical core map.
 constexpr std::array<s32, Common::BitSize<u64>()> VirtualToPhysicalCoreMap{
-    0, 1, 2, 3, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 3,
+    0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
 };
 
 static constexpr inline size_t NumVirtualCores = Common::BitSize<u64>();

src/core/hle/service/acc/acc.h

@@ -14,70 +14,6 @@ namespace Service::Account {
 
 class ProfileManager;
 
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(std::shared_ptr<Module> module_,
-                           std::shared_ptr<ProfileManager> profile_manager_, Core::System& system_,
-                           const char* name);
-        ~Interface() override;
-
-        void GetUserCount(HLERequestContext& ctx);
-        void GetUserExistence(HLERequestContext& ctx);
-        void ListAllUsers(HLERequestContext& ctx);
-        void ListOpenUsers(HLERequestContext& ctx);
-        void GetLastOpenedUser(HLERequestContext& ctx);
-        void GetProfile(HLERequestContext& ctx);
-        void InitializeApplicationInfo(HLERequestContext& ctx);
-        void InitializeApplicationInfoRestricted(HLERequestContext& ctx);
-        void GetBaasAccountManagerForApplication(HLERequestContext& ctx);
-        void IsUserRegistrationRequestPermitted(HLERequestContext& ctx);
-        void TrySelectUserWithoutInteractionDeprecated(HLERequestContext& ctx);
-        void TrySelectUserWithoutInteraction(HLERequestContext& ctx);
-        void IsUserAccountSwitchLocked(HLERequestContext& ctx);
-        void InitializeApplicationInfoV2(HLERequestContext& ctx);
-        void BeginUserRegistration(HLERequestContext& ctx);
-        void CompleteUserRegistration(HLERequestContext& ctx);
-        void DeleteUser(HLERequestContext& ctx);
-        void SetUserPosition(HLERequestContext& ctx);
-        void GetProfileEditor(HLERequestContext& ctx);
-        void GetBaasAccountAdministrator(HLERequestContext &ctx);
-        void ListQualifiedUsers(HLERequestContext& ctx);
-        void ListOpenContextStoredUsers(HLERequestContext& ctx);
-        void StoreSaveDataThumbnailApplication(HLERequestContext& ctx);
-        void GetBaasAccountManagerForSystemService(HLERequestContext& ctx);
-        void StoreSaveDataThumbnailSystem(HLERequestContext& ctx);
-        void GetPinCodeLength(HLERequestContext& ctx);
-
-    private:
-        Result InitializeApplicationInfoBase();
-        void StoreSaveDataThumbnail(HLERequestContext& ctx, const Common::UUID& uuid,
-                                    const u64 tid);
-
-        enum class ApplicationType : u32_le {
-            GameCard = 0,
-            Digital = 1,
-            Unknown = 3,
-        };
-
-        struct ApplicationInfo {
-            Service::Glue::ApplicationLaunchProperty launch_property;
-            ApplicationType application_type;
-
-            constexpr explicit operator bool() const {
-                return launch_property.title_id != 0x0;
-            }
-        };
-
-        ApplicationInfo application_info{};
-
-    protected:
-        std::shared_ptr<Module> module;
-        std::shared_ptr<ProfileManager> profile_manager;
-    };
-};
-
 void LoopProcess(Core::System& system);
 
 } // namespace Service::Account

src/core/hle/service/acc/async_context.cpp

@@ -12,17 +12,6 @@
 namespace Service::Account {
 IAsyncContext::IAsyncContext(Core::System& system_)
     : ServiceFramework{system_, "IAsyncContext"}, service_context{system_, "IAsyncContext"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, &IAsyncContext::GetSystemEvent, "GetSystemEvent"},
-        {1, &IAsyncContext::Cancel, "Cancel"},
-        {2, &IAsyncContext::HasDone, "HasDone"},
-        {3, &IAsyncContext::GetResult, "GetResult"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
     completion_event = service_context.CreateEvent("IAsyncContext:CompletionEvent");
 }
 

src/core/hle/service/acc/async_context.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -30,6 +33,16 @@ protected:
 
     void MarkComplete();
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, &IAsyncContext::GetSystemEvent, "GetSystemEvent"},
+        FunctionInfo{1, &IAsyncContext::Cancel, "Cancel"},
+        FunctionInfo{2, &IAsyncContext::HasDone, "HasDone"},
+        FunctionInfo{3, &IAsyncContext::GetResult, "GetResult"}
+    );
+
     KernelHelpers::ServiceContext service_context;
 
     std::atomic<bool> is_complete{false};

src/core/hle/service/am/service/all_system_applet_proxies_service.cpp

@@ -1,135 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/am/service/all_system_applet_proxies_service.h"
-#include "core/hle/service/am/service/application_proxy.h"
-#include "core/hle/service/am/service/library_applet_proxy.h"
-#include "core/hle/service/am/service/system_applet_proxy.h"
-#include "core/hle/service/am/service/overlay_applet_proxy.h"
-#include "core/hle/service/am/window_system.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-IAllSystemAppletProxiesService::IAllSystemAppletProxiesService(Core::System& system_,
-                                                               WindowSystem& window_system)
-    : ServiceFramework{system_, "appletAE"}, m_window_system{window_system} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {100, D<&IAllSystemAppletProxiesService::OpenSystemAppletProxy>, "OpenSystemAppletProxy"},
-        {110, D<&IAllSystemAppletProxiesService::OpenSystemAppletProxy>, "OpenSystemAppletProxyEx"},
-        {200, D<&IAllSystemAppletProxiesService::OpenLibraryAppletProxyOld>, "OpenLibraryAppletProxyOld"},
-        {201, D<&IAllSystemAppletProxiesService::OpenLibraryAppletProxy>, "OpenLibraryAppletProxy"},
-        {300, D<&IAllSystemAppletProxiesService::OpenOverlayAppletProxy>, "OpenOverlayAppletProxy"},
-        {350, D<&IAllSystemAppletProxiesService::OpenSystemApplicationProxy>, "OpenSystemApplicationProxy"},
-        {400, nullptr, "CreateSelfLibraryAppletCreatorForDevelop"},
-        {410, nullptr, "GetSystemAppletControllerForDebug"},
-        {450, D<&IAllSystemAppletProxiesService::GetSystemProcessCommonFunctions>, "GetSystemProcessCommonFunctions"}, // 19.0.0+
-        {460, D<&IAllSystemAppletProxiesService::GetAppletAlternativeFunctions>, "GetAppletAlternativeFunctions"}, // 20.0.0+
-        {1000, nullptr, "GetDebugFunctions"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IAllSystemAppletProxiesService::~IAllSystemAppletProxiesService() = default;
-
-Result IAllSystemAppletProxiesService::OpenSystemAppletProxy(
-    Out<SharedPointer<ISystemAppletProxy>> out_system_applet_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
-    LOG_DEBUG(Service_AM, "called");
-
-    if (const auto applet = this->GetAppletFromProcessId(pid); applet) {
-        *out_system_applet_proxy = std::make_shared<ISystemAppletProxy>(
-            system, applet, process_handle.Get(), m_window_system);
-        R_SUCCEED();
-    } else {
-        UNIMPLEMENTED();
-        R_THROW(ResultUnknown);
-    }
-}
-
-Result IAllSystemAppletProxiesService::OpenLibraryAppletProxy(
-    Out<SharedPointer<ILibraryAppletProxy>> out_library_applet_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle,
-    InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute) {
-    LOG_DEBUG(Service_AM, "called");
-
-    if (const auto applet = this->GetAppletFromProcessId(pid); applet) {
-        *out_library_applet_proxy = std::make_shared<ILibraryAppletProxy>(
-            system, applet, process_handle.Get(), m_window_system);
-        R_SUCCEED();
-    } else {
-        UNIMPLEMENTED();
-        R_THROW(ResultUnknown);
-    }
-}
-
-Result IAllSystemAppletProxiesService::OpenOverlayAppletProxy(
-    Out<SharedPointer<IOverlayAppletProxy>> out_overlay_applet_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
-    LOG_WARNING(Service_AM, "called");
-
-    if (const auto applet = this->GetAppletFromProcessId(pid); applet) {
-        *out_overlay_applet_proxy = std::make_shared<IOverlayAppletProxy>(
-            system, applet, process_handle.Get(), m_window_system);
-        R_SUCCEED();
-    } else {
-        UNIMPLEMENTED();
-        R_THROW(ResultUnknown);
-    }
-}
-
-Result IAllSystemAppletProxiesService::OpenSystemApplicationProxy(
-    Out<SharedPointer<IApplicationProxy>> out_system_application_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
-    LOG_DEBUG(Service_AM, "called");
-
-    if (const auto applet = this->GetAppletFromProcessId(pid); applet) {
-        *out_system_application_proxy = std::make_shared<IApplicationProxy>(
-            system, applet, process_handle.Get(), m_window_system);
-        R_SUCCEED();
-    } else {
-        UNIMPLEMENTED();
-        R_THROW(ResultUnknown);
-    }
-}
-
-Result IAllSystemAppletProxiesService::OpenLibraryAppletProxyOld(
-    Out<SharedPointer<ILibraryAppletProxy>> out_library_applet_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
-    LOG_DEBUG(Service_AM, "called");
-
-    AppletAttribute attribute{};
-    R_RETURN(
-        this->OpenLibraryAppletProxy(out_library_applet_proxy, pid, process_handle, attribute));
-}
-
-Result IAllSystemAppletProxiesService::GetSystemProcessCommonFunctions() {
-    LOG_DEBUG(Service_AM, "(STUBBED) called.");
-
-    // TODO (jarrodnorwell)
-
-    R_SUCCEED();
-}
-
-Result IAllSystemAppletProxiesService::GetAppletAlternativeFunctions() {
-    LOG_DEBUG(Service_AM, "(STUBBED) called.");
-
-    // TODO (maufeat)
-
-    R_SUCCEED();
-}
-
-std::shared_ptr<Applet> IAllSystemAppletProxiesService::GetAppletFromProcessId(
-    ProcessId process_id) {
-    return m_window_system.GetByAppletResourceUserId(process_id.pid);
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/all_system_applet_proxies_service.h

@@ -1,56 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-#include "core/hle/service/am/service/overlay_applet_proxy.h"
-
-namespace Service {
-
-namespace AM {
-
-struct Applet;
-struct AppletAttribute;
-class IApplicationProxy;
-class ILibraryAppletProxy;
-class ISystemAppletProxy;
-class WindowSystem;
-
-class IAllSystemAppletProxiesService final
-    : public ServiceFramework<IAllSystemAppletProxiesService> {
-public:
-    explicit IAllSystemAppletProxiesService(Core::System& system_, WindowSystem& window_system);
-    ~IAllSystemAppletProxiesService() override;
-
-private:
-    Result OpenSystemAppletProxy(Out<SharedPointer<ISystemAppletProxy>> out_system_applet_proxy,
-                                 ClientProcessId pid,
-                                 InCopyHandle<Kernel::KProcess> process_handle);
-    Result OpenLibraryAppletProxy(Out<SharedPointer<ILibraryAppletProxy>> out_library_applet_proxy,
-                                  ClientProcessId pid,
-                                  InCopyHandle<Kernel::KProcess> process_handle,
-                                  InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute);
-    Result OpenOverlayAppletProxy(Out<SharedPointer<IOverlayAppletProxy>> out_overlay_applet_proxy,
-                           ClientProcessId pid, InCopyHandle<Kernel::KProcess> process_handle);
-    Result OpenLibraryAppletProxyOld(
-        Out<SharedPointer<ILibraryAppletProxy>> out_library_applet_proxy, ClientProcessId pid,
-        InCopyHandle<Kernel::KProcess> process_handle);
-    Result OpenSystemApplicationProxy(
-        Out<SharedPointer<IApplicationProxy>> out_system_application_proxy, ClientProcessId pid,
-        InCopyHandle<Kernel::KProcess> process_handle);
-    Result GetSystemProcessCommonFunctions();
-    Result GetAppletAlternativeFunctions();
-
-private:
-    std::shared_ptr<Applet> GetAppletFromProcessId(ProcessId pid);
-
-    WindowSystem& m_window_system;
-};
-
-} // namespace AM
-} // namespace Service

src/core/hle/service/am/service/applet_common_functions.cpp

@@ -1,98 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/file_sys/common_funcs.h"
-#include "core/hle/service/am/applet.h"
-#include "core/hle/service/am/service/applet_common_functions.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-IAppletCommonFunctions::IAppletCommonFunctions(Core::System& system_,
-                                               std::shared_ptr<Applet> applet_)
-    : ServiceFramework{system_, "IAppletCommonFunctions"}, applet{std::move(applet_)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "SetTerminateResult"},
-        {10, nullptr, "ReadThemeStorage"},
-        {11, nullptr, "WriteThemeStorage"},
-        {20, nullptr, "PushToAppletBoundChannel"},
-        {21, nullptr, "TryPopFromAppletBoundChannel"},
-        {40, nullptr, "GetDisplayLogicalResolution"},
-        {42, D<&IAppletCommonFunctions::SetDisplayMagnification>, "SetDisplayMagnification"},
-        {50, D<&IAppletCommonFunctions::SetHomeButtonDoubleClickEnabled>, "SetHomeButtonDoubleClickEnabled"},
-        {51, D<&IAppletCommonFunctions::GetHomeButtonDoubleClickEnabled>, "GetHomeButtonDoubleClickEnabled"},
-        {52, nullptr, "IsHomeButtonShortPressedBlocked"},
-        {60, nullptr, "IsVrModeCurtainRequired"},
-        {61, nullptr, "IsSleepRequiredByHighTemperature"},
-        {62, nullptr, "IsSleepRequiredByLowBattery"},
-        {70, D<&IAppletCommonFunctions::SetCpuBoostRequestPriority>, "SetCpuBoostRequestPriority"},
-        {80, nullptr, "SetHandlingCaptureButtonShortPressedMessageEnabledForApplet"},
-        {81, nullptr, "SetHandlingCaptureButtonLongPressedMessageEnabledForApplet"},
-        {90, nullptr, "OpenNamedChannelAsParent"},
-        {91, nullptr, "OpenNamedChannelAsChild"},
-        {100, nullptr, "SetApplicationCoreUsageMode"},
-        {300, D<&IAppletCommonFunctions::GetCurrentApplicationId>, "GetCurrentApplicationId"},
-        {310, nullptr, "IsSystemAppletHomeMenu"}, //19.0.0+
-        {320, D<&IAppletCommonFunctions::SetGpuTimeSliceBoost>, "SetGpuTimeSliceBoost"}, //19.0.0+
-        {321, nullptr, "SetGpuTimeSliceBoostDueToApplication"}, //19.0.0+
-        {350, D<&IAppletCommonFunctions::Unknown350>, "Unknown350"} //20.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IAppletCommonFunctions::~IAppletCommonFunctions() = default;
-
-Result IAppletCommonFunctions::SetHomeButtonDoubleClickEnabled(
-    bool home_button_double_click_enabled) {
-    LOG_WARNING(Service_AM, "(STUBBED) called, home_button_double_click_enabled={}",
-                home_button_double_click_enabled);
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::GetHomeButtonDoubleClickEnabled(
-    Out<bool> out_home_button_double_click_enabled) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_home_button_double_click_enabled = false;
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::SetDisplayMagnification(f32 x, f32 y, f32 width, f32 height) {
-    LOG_DEBUG(Service_AM, "(STUBBED) called, x={}, y={}, width={}, height={}", x, y, width,
-                height);
-    std::scoped_lock lk{applet->lock};
-    applet->display_magnification = Common::Rectangle<f32>{x, y, x + width, y + height};
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::SetCpuBoostRequestPriority(s32 priority) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    std::scoped_lock lk{applet->lock};
-    applet->cpu_boost_request_priority = priority;
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::GetCurrentApplicationId(Out<u64> out_application_id) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_application_id = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::SetGpuTimeSliceBoost(s64 time_span) {
-    LOG_WARNING(Service_AM, "(STUBBED) called, time_span={}", time_span);
-    R_SUCCEED();
-}
-
-Result IAppletCommonFunctions::Unknown350(Out<u16> out_unknown) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_unknown = 0;
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/applet_common_functions.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-struct Applet;
-
-class IAppletCommonFunctions final : public ServiceFramework<IAppletCommonFunctions> {
-public:
-    explicit IAppletCommonFunctions(Core::System& system_, std::shared_ptr<Applet> applet_);
-    ~IAppletCommonFunctions() override;
-
-private:
-    Result SetHomeButtonDoubleClickEnabled(bool home_button_double_click_enabled);
-    Result GetHomeButtonDoubleClickEnabled(Out<bool> out_home_button_double_click_enabled);
-    Result SetDisplayMagnification(f32 x, f32 y, f32 width, f32 height);
-    Result SetCpuBoostRequestPriority(s32 priority);
-    Result GetCurrentApplicationId(Out<u64> out_application_id);
-    Result SetGpuTimeSliceBoost(s64 time_span);
-    Result Unknown350(Out<u16> out_unknown);
-
-    const std::shared_ptr<Applet> applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/application_accessor.cpp

@@ -18,42 +18,42 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IApplicationAccessor::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IApplicationAccessor::GetAppletStateChangedEvent>, "GetAppletStateChangedEvent"},
+        FunctionInfo{1, nullptr, "IsCompleted"},
+        FunctionInfo{10, D<&IApplicationAccessor::Start>, "Start"},
+        FunctionInfo{20, D<&IApplicationAccessor::RequestExit>, "RequestExit"},
+        FunctionInfo{25, D<&IApplicationAccessor::Terminate>, "Terminate"},
+        FunctionInfo{30, D<&IApplicationAccessor::GetResult>, "GetResult"},
+        FunctionInfo{101, D<&IApplicationAccessor::RequestForApplicationToGetForeground>, "RequestForApplicationToGetForeground"},
+        FunctionInfo{110, nullptr, "TerminateAllLibraryApplets"},
+        FunctionInfo{111, nullptr, "AreAnyLibraryAppletsLeft"},
+        FunctionInfo{112, D<&IApplicationAccessor::GetCurrentLibraryApplet>, "GetCurrentLibraryApplet"},
+        FunctionInfo{120, nullptr, "GetApplicationId"},
+        FunctionInfo{121, D<&IApplicationAccessor::PushLaunchParameter>, "PushLaunchParameter"},
+        FunctionInfo{122, D<&IApplicationAccessor::GetApplicationControlProperty>, "GetApplicationControlProperty"},
+        FunctionInfo{123, nullptr, "GetApplicationLaunchProperty"},
+        FunctionInfo{124, nullptr, "GetApplicationLaunchRequestInfo"},
+        FunctionInfo{130, D<&IApplicationAccessor::SetUsers>, "SetUsers"},
+        FunctionInfo{131, D<&IApplicationAccessor::CheckRightsEnvironmentAvailable>, "CheckRightsEnvironmentAvailable"},
+        FunctionInfo{132, D<&IApplicationAccessor::GetNsRightsEnvironmentHandle>, "GetNsRightsEnvironmentHandle"},
+        FunctionInfo{140, nullptr, "GetDesirableUids"},
+        FunctionInfo{150, D<&IApplicationAccessor::ReportApplicationExitTimeout>, "ReportApplicationExitTimeout"},
+        FunctionInfo{160, nullptr, "SetApplicationAttribute"},
+        FunctionInfo{170, nullptr, "HasSaveDataAccessPermission"},
+        FunctionInfo{180, nullptr, "PushToFriendInvitationStorageChannel"},
+        FunctionInfo{190, nullptr, "PushToNotificationStorageChannel"},
+        FunctionInfo{200, nullptr, "RequestApplicationSoftReset"},
+        FunctionInfo{201, nullptr, "RestartApplicationTimer"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IApplicationAccessor::IApplicationAccessor(Core::System& system_, std::shared_ptr<Applet> applet,
                                            WindowSystem& window_system)
     : ServiceFramework{system_, "IApplicationAccessor"}, m_window_system(window_system),
       m_applet(std::move(applet)) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IApplicationAccessor::GetAppletStateChangedEvent>, "GetAppletStateChangedEvent"},
-        {1, nullptr, "IsCompleted"},
-        {10, D<&IApplicationAccessor::Start>, "Start"},
-        {20, D<&IApplicationAccessor::RequestExit>, "RequestExit"},
-        {25, D<&IApplicationAccessor::Terminate>, "Terminate"},
-        {30, D<&IApplicationAccessor::GetResult>, "GetResult"},
-        {101, D<&IApplicationAccessor::RequestForApplicationToGetForeground>, "RequestForApplicationToGetForeground"},
-        {110, nullptr, "TerminateAllLibraryApplets"},
-        {111, nullptr, "AreAnyLibraryAppletsLeft"},
-        {112, D<&IApplicationAccessor::GetCurrentLibraryApplet>, "GetCurrentLibraryApplet"},
-        {120, nullptr, "GetApplicationId"},
-        {121, D<&IApplicationAccessor::PushLaunchParameter>, "PushLaunchParameter"},
-        {122, D<&IApplicationAccessor::GetApplicationControlProperty>, "GetApplicationControlProperty"},
-        {123, nullptr, "GetApplicationLaunchProperty"},
-        {124, nullptr, "GetApplicationLaunchRequestInfo"},
-        {130, D<&IApplicationAccessor::SetUsers>, "SetUsers"},
-        {131, D<&IApplicationAccessor::CheckRightsEnvironmentAvailable>, "CheckRightsEnvironmentAvailable"},
-        {132, D<&IApplicationAccessor::GetNsRightsEnvironmentHandle>, "GetNsRightsEnvironmentHandle"},
-        {140, nullptr, "GetDesirableUids"},
-        {150, D<&IApplicationAccessor::ReportApplicationExitTimeout>, "ReportApplicationExitTimeout"},
-        {160, nullptr, "SetApplicationAttribute"},
-        {170, nullptr, "HasSaveDataAccessPermission"},
-        {180, nullptr, "PushToFriendInvitationStorageChannel"},
-        {190, nullptr, "PushToNotificationStorageChannel"},
-        {200, nullptr, "RequestApplicationSoftReset"},
-        {201, nullptr, "RestartApplicationTimer"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IApplicationAccessor::~IApplicationAccessor() = default;

src/core/hle/service/am/service/application_accessor.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -36,6 +39,7 @@ private:
     Result GetNsRightsEnvironmentHandle(Out<u64> out_handle);
     Result ReportApplicationExitTimeout();
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     WindowSystem& m_window_system;
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/am/service/application_creator.cpp

@@ -20,6 +20,16 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IApplicationCreator::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IApplicationCreator::CreateApplication>, "CreateApplication"},
+        FunctionInfo{1, nullptr, "PopLaunchRequestedApplication"},
+        FunctionInfo{10, D<&IApplicationCreator::CreateSystemApplication>, "CreateSystemApplication"},
+        FunctionInfo{100, nullptr, "PopFloatingApplicationForDevelopment"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 namespace {
 
 Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_application_accessor, Core::System& system, WindowSystem& window_system, u64 program_id) {
@@ -54,16 +64,6 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
 
 IApplicationCreator::IApplicationCreator(Core::System& system_, WindowSystem& window_system)
     : ServiceFramework{system_, "IApplicationCreator"}, m_window_system{window_system} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IApplicationCreator::CreateApplication>, "CreateApplication"},
-        {1, nullptr, "PopLaunchRequestedApplication"},
-        {10, D<&IApplicationCreator::CreateSystemApplication>, "CreateSystemApplication"},
-        {100, nullptr, "PopFloatingApplicationForDevelopment"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IApplicationCreator::~IApplicationCreator() = default;

src/core/hle/service/am/service/application_creator.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -24,6 +24,7 @@ private:
     Result CreateApplication(Out<SharedPointer<IApplicationAccessor>>, u64 application_id);
     Result CreateSystemApplication(Out<SharedPointer<IApplicationAccessor>>, u64 application_id);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     WindowSystem& m_window_system;
 };
 

src/core/hle/service/am/service/application_functions.cpp

@@ -51,84 +51,85 @@ FileSys::PatchManager::Metadata GetApplicationMetadata(Core::System& system, u64
 
 } // Anonymous namespace
 
-IApplicationFunctions::IApplicationFunctions(Core::System& system_, std::shared_ptr<Applet> applet)
-    : ServiceFramework{system_, "IApplicationFunctions"}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {1, D<&IApplicationFunctions::PopLaunchParameter>, "PopLaunchParameter"},
-        {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
-        {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
-        {12, D<&IApplicationFunctions::CreateApplicationAndRequestToStart>, "CreateApplicationAndRequestToStart"},
-        {13, nullptr, "CreateApplicationAndRequestToStartForQuest"},
-        {14, nullptr, "CreateApplicationWithAttributeAndPushAndRequestToStartForQuest"},
-        {15, nullptr, "CreateApplicationWithAttributeAndRequestToStartForQuest"},
-        {20, D<&IApplicationFunctions::EnsureSaveData>, "EnsureSaveData"},
-        {21, D<&IApplicationFunctions::GetDesiredLanguage>, "GetDesiredLanguage"},
-        {22, D<&IApplicationFunctions::SetTerminateResult>, "SetTerminateResult"},
-        {23, D<&IApplicationFunctions::GetDisplayVersion>, "GetDisplayVersion"},
-        {24, nullptr, "GetLaunchStorageInfoForDebug"},
-        {25, D<&IApplicationFunctions::ExtendSaveData>, "ExtendSaveData"},
-        {26, D<&IApplicationFunctions::GetSaveDataSize>, "GetSaveDataSize"},
-        {27, D<&IApplicationFunctions::CreateCacheStorage>, "CreateCacheStorage"},
-        {28, D<&IApplicationFunctions::GetSaveDataSizeMax>, "GetSaveDataSizeMax"},
-        {29, D<&IApplicationFunctions::GetCacheStorageMax>, "GetCacheStorageMax"},
-        {30, D<&IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed>, "BeginBlockingHomeButtonShortAndLongPressed"},
-        {31, D<&IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed>, "EndBlockingHomeButtonShortAndLongPressed"},
-        {32, D<&IApplicationFunctions::BeginBlockingHomeButton>, "BeginBlockingHomeButton"},
-        {33, D<&IApplicationFunctions::EndBlockingHomeButton>, "EndBlockingHomeButton"},
-        {34, nullptr, "SelectApplicationLicense"},
-        {35, nullptr, "GetDeviceSaveDataSizeMax"},
-        {36, nullptr, "GetLimitedApplicationLicense"},
-        {37, nullptr, "GetLimitedApplicationLicenseUpgradableEvent"},
-        {40, D<&IApplicationFunctions::NotifyRunning>, "NotifyRunning"},
-        {50, D<&IApplicationFunctions::GetPseudoDeviceId>, "GetPseudoDeviceId"},
-        {60, D<&IApplicationFunctions::SetMediaPlaybackStateForApplication>, "SetMediaPlaybackStateForApplication"},
-        {65, D<&IApplicationFunctions::IsGamePlayRecordingSupported>, "IsGamePlayRecordingSupported"},
-        {66, D<&IApplicationFunctions::InitializeGamePlayRecording>, "InitializeGamePlayRecording"},
-        {67, D<&IApplicationFunctions::SetGamePlayRecordingState>, "SetGamePlayRecordingState"},
-        {68, nullptr, "RequestFlushGamePlayingMovieForDebug"},
-        {70, nullptr, "RequestToShutdown"},
-        {71, nullptr, "RequestToReboot"},
-        {72, nullptr, "RequestToSleep"},
-        {80, nullptr, "ExitAndRequestToShowThanksMessage"},
-        {90, D<&IApplicationFunctions::EnableApplicationCrashReport>, "EnableApplicationCrashReport"},
-        {100, D<&IApplicationFunctions::InitializeApplicationCopyrightFrameBuffer>, "InitializeApplicationCopyrightFrameBuffer"},
-        {101, D<&IApplicationFunctions::SetApplicationCopyrightImage>, "SetApplicationCopyrightImage"},
-        {102, D<&IApplicationFunctions::SetApplicationCopyrightVisibility>, "SetApplicationCopyrightVisibility"},
-        {110, D<&IApplicationFunctions::QueryApplicationPlayStatistics>, "QueryApplicationPlayStatistics"},
-        {111, D<&IApplicationFunctions::QueryApplicationPlayStatisticsByUid>, "QueryApplicationPlayStatisticsByUid"},
-        {120, D<&IApplicationFunctions::ExecuteProgram>, "ExecuteProgram"},
-        {121, D<&IApplicationFunctions::ClearUserChannel>, "ClearUserChannel"},
-        {122, D<&IApplicationFunctions::UnpopToUserChannel>, "UnpopToUserChannel"},
-        {123, D<&IApplicationFunctions::GetPreviousProgramIndex>, "GetPreviousProgramIndex"},
-        {124, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
-        {130, D<&IApplicationFunctions::GetGpuErrorDetectedSystemEvent>, "GetGpuErrorDetectedSystemEvent"},
-        {131, nullptr, "SetDelayTimeToAbortOnGpuError"},
-        {140, D<&IApplicationFunctions::GetFriendInvitationStorageChannelEvent>, "GetFriendInvitationStorageChannelEvent"},
-        {141, D<&IApplicationFunctions::TryPopFromFriendInvitationStorageChannel>, "TryPopFromFriendInvitationStorageChannel"},
-        {150, D<&IApplicationFunctions::GetNotificationStorageChannelEvent>, "GetNotificationStorageChannelEvent"},
-        {151, nullptr, "TryPopFromNotificationStorageChannel"},
-        {160, D<&IApplicationFunctions::GetHealthWarningDisappearedSystemEvent>, "GetHealthWarningDisappearedSystemEvent"},
-        {170, nullptr, "SetHdcpAuthenticationActivated"},
-        {180, nullptr, "GetLaunchRequiredVersion"},
-        {181, nullptr, "UpgradeLaunchRequiredVersion"},
-        {190, nullptr, "SendServerMaintenanceOverlayNotification"},
-        {200, nullptr, "GetLastApplicationExitReason"},
-        {210, D<&IApplicationFunctions::GetUnknownEvent210>, "Unknown210"},
-        {220, nullptr, "Unknown220"}, // [20.0.0+]
-        {300, nullptr, "CreateMovieWriter"}, // [19.0.0+]
-        {310, nullptr, "Unknown310"}, // [20.0.0+]
-        {320, nullptr, "Unknown320"}, // [20.0.0+]
-        {330, D<&IApplicationFunctions::Unknown330>, "Unknown330"}, // [20.0.0+]
-        {500, nullptr, "StartContinuousRecordingFlushForDebug"},
-        {1000, nullptr, "CreateMovieMaker"},
-        {1001, D<&IApplicationFunctions::PrepareForJit>, "PrepareForJit"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IApplicationFunctions::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{1, D<&IApplicationFunctions::PopLaunchParameter>, "PopLaunchParameter"},
+        FunctionInfo{10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
+        FunctionInfo{11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
+        FunctionInfo{12, D<&IApplicationFunctions::CreateApplicationAndRequestToStart>, "CreateApplicationAndRequestToStart"},
+        FunctionInfo{13, nullptr, "CreateApplicationAndRequestToStartForQuest"},
+        FunctionInfo{14, nullptr, "CreateApplicationWithAttributeAndPushAndRequestToStartForQuest"},
+        FunctionInfo{15, nullptr, "CreateApplicationWithAttributeAndRequestToStartForQuest"},
+        FunctionInfo{20, D<&IApplicationFunctions::EnsureSaveData>, "EnsureSaveData"},
+        FunctionInfo{21, D<&IApplicationFunctions::GetDesiredLanguage>, "GetDesiredLanguage"},
+        FunctionInfo{22, D<&IApplicationFunctions::SetTerminateResult>, "SetTerminateResult"},
+        FunctionInfo{23, D<&IApplicationFunctions::GetDisplayVersion>, "GetDisplayVersion"},
+        FunctionInfo{24, nullptr, "GetLaunchStorageInfoForDebug"},
+        FunctionInfo{25, D<&IApplicationFunctions::ExtendSaveData>, "ExtendSaveData"},
+        FunctionInfo{26, D<&IApplicationFunctions::GetSaveDataSize>, "GetSaveDataSize"},
+        FunctionInfo{27, D<&IApplicationFunctions::CreateCacheStorage>, "CreateCacheStorage"},
+        FunctionInfo{28, D<&IApplicationFunctions::GetSaveDataSizeMax>, "GetSaveDataSizeMax"},
+        FunctionInfo{29, D<&IApplicationFunctions::GetCacheStorageMax>, "GetCacheStorageMax"},
+        FunctionInfo{30, D<&IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed>, "BeginBlockingHomeButtonShortAndLongPressed"},
+        FunctionInfo{31, D<&IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed>, "EndBlockingHomeButtonShortAndLongPressed"},
+        FunctionInfo{32, D<&IApplicationFunctions::BeginBlockingHomeButton>, "BeginBlockingHomeButton"},
+        FunctionInfo{33, D<&IApplicationFunctions::EndBlockingHomeButton>, "EndBlockingHomeButton"},
+        FunctionInfo{34, nullptr, "SelectApplicationLicense"},
+        FunctionInfo{35, nullptr, "GetDeviceSaveDataSizeMax"},
+        FunctionInfo{36, nullptr, "GetLimitedApplicationLicense"},
+        FunctionInfo{37, nullptr, "GetLimitedApplicationLicenseUpgradableEvent"},
+        FunctionInfo{40, D<&IApplicationFunctions::NotifyRunning>, "NotifyRunning"},
+        FunctionInfo{50, D<&IApplicationFunctions::GetPseudoDeviceId>, "GetPseudoDeviceId"},
+        FunctionInfo{60, D<&IApplicationFunctions::SetMediaPlaybackStateForApplication>, "SetMediaPlaybackStateForApplication"},
+        FunctionInfo{65, D<&IApplicationFunctions::IsGamePlayRecordingSupported>, "IsGamePlayRecordingSupported"},
+        FunctionInfo{66, D<&IApplicationFunctions::InitializeGamePlayRecording>, "InitializeGamePlayRecording"},
+        FunctionInfo{67, D<&IApplicationFunctions::SetGamePlayRecordingState>, "SetGamePlayRecordingState"},
+        FunctionInfo{68, nullptr, "RequestFlushGamePlayingMovieForDebug"},
+        FunctionInfo{70, nullptr, "RequestToShutdown"},
+        FunctionInfo{71, nullptr, "RequestToReboot"},
+        FunctionInfo{72, nullptr, "RequestToSleep"},
+        FunctionInfo{80, nullptr, "ExitAndRequestToShowThanksMessage"},
+        FunctionInfo{90, D<&IApplicationFunctions::EnableApplicationCrashReport>, "EnableApplicationCrashReport"},
+        FunctionInfo{100, D<&IApplicationFunctions::InitializeApplicationCopyrightFrameBuffer>, "InitializeApplicationCopyrightFrameBuffer"},
+        FunctionInfo{101, D<&IApplicationFunctions::SetApplicationCopyrightImage>, "SetApplicationCopyrightImage"},
+        FunctionInfo{102, D<&IApplicationFunctions::SetApplicationCopyrightVisibility>, "SetApplicationCopyrightVisibility"},
+        FunctionInfo{110, D<&IApplicationFunctions::QueryApplicationPlayStatistics>, "QueryApplicationPlayStatistics"},
+        FunctionInfo{111, D<&IApplicationFunctions::QueryApplicationPlayStatisticsByUid>, "QueryApplicationPlayStatisticsByUid"},
+        FunctionInfo{120, D<&IApplicationFunctions::ExecuteProgram>, "ExecuteProgram"},
+        FunctionInfo{121, D<&IApplicationFunctions::ClearUserChannel>, "ClearUserChannel"},
+        FunctionInfo{122, D<&IApplicationFunctions::UnpopToUserChannel>, "UnpopToUserChannel"},
+        FunctionInfo{123, D<&IApplicationFunctions::GetPreviousProgramIndex>, "GetPreviousProgramIndex"},
+        FunctionInfo{124, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
+        FunctionInfo{130, D<&IApplicationFunctions::GetGpuErrorDetectedSystemEvent>, "GetGpuErrorDetectedSystemEvent"},
+        FunctionInfo{131, nullptr, "SetDelayTimeToAbortOnGpuError"},
+        FunctionInfo{140, D<&IApplicationFunctions::GetFriendInvitationStorageChannelEvent>, "GetFriendInvitationStorageChannelEvent"},
+        FunctionInfo{141, D<&IApplicationFunctions::TryPopFromFriendInvitationStorageChannel>, "TryPopFromFriendInvitationStorageChannel"},
+        FunctionInfo{150, D<&IApplicationFunctions::GetNotificationStorageChannelEvent>, "GetNotificationStorageChannelEvent"},
+        FunctionInfo{151, nullptr, "TryPopFromNotificationStorageChannel"},
+        FunctionInfo{160, D<&IApplicationFunctions::GetHealthWarningDisappearedSystemEvent>, "GetHealthWarningDisappearedSystemEvent"},
+        FunctionInfo{170, nullptr, "SetHdcpAuthenticationActivated"},
+        FunctionInfo{180, nullptr, "GetLaunchRequiredVersion"},
+        FunctionInfo{181, nullptr, "UpgradeLaunchRequiredVersion"},
+        FunctionInfo{190, nullptr, "SendServerMaintenanceOverlayNotification"},
+        FunctionInfo{200, nullptr, "GetLastApplicationExitReason"},
+        FunctionInfo{210, D<&IApplicationFunctions::GetUnknownEvent210>, "Unknown210"},
+        FunctionInfo{220, nullptr, "Unknown220"}, // [20.0.0+]
+        FunctionInfo{300, nullptr, "CreateMovieWriter"}, // [19.0.0+]
+        FunctionInfo{310, nullptr, "Unknown310"}, // [20.0.0+]
+        FunctionInfo{320, nullptr, "Unknown320"}, // [20.0.0+]
+        FunctionInfo{330, D<&IApplicationFunctions::Unknown330>, "Unknown330"}, // [20.0.0+]
+        FunctionInfo{500, nullptr, "StartContinuousRecordingFlushForDebug"},
+        FunctionInfo{1000, nullptr, "CreateMovieMaker"},
+        FunctionInfo{1001, D<&IApplicationFunctions::PrepareForJit>, "PrepareForJit"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
 }
 
+IApplicationFunctions::IApplicationFunctions(Core::System& system_, std::shared_ptr<Applet> applet)
+    : ServiceFramework{system_, "IApplicationFunctions"}
+    , m_applet{std::move(applet)}
+{}
+
 IApplicationFunctions::~IApplicationFunctions() = default;
 
 Result IApplicationFunctions::PopLaunchParameter(Out<SharedPointer<IStorage>> out_storage,

src/core/hle/service/am/service/application_functions.h

@@ -84,6 +84,7 @@ private:
     Result GetUnknownEvent210(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result Unknown330(Out<u8> out);
     Result PrepareForJit();
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
 
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/am/service/application_proxy.cpp

@@ -1,106 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/service/applet_common_functions.h"
-#include "core/hle/service/am/service/application_functions.h"
-#include "core/hle/service/am/service/application_proxy.h"
-#include "core/hle/service/am/service/audio_controller.h"
-#include "core/hle/service/am/service/common_state_getter.h"
-#include "core/hle/service/am/service/debug_functions.h"
-#include "core/hle/service/am/service/display_controller.h"
-#include "core/hle/service/am/service/library_applet_creator.h"
-#include "core/hle/service/am/service/process_winding_controller.h"
-#include "core/hle/service/am/service/self_controller.h"
-#include "core/hle/service/am/service/window_controller.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                                     Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "IApplicationProxy"},
-      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
-        {1, D<&IApplicationProxy::GetSelfController>, "GetSelfController"},
-        {2, D<&IApplicationProxy::GetWindowController>, "GetWindowController"},
-        {3, D<&IApplicationProxy::GetAudioController>, "GetAudioController"},
-        {4, D<&IApplicationProxy::GetDisplayController>, "GetDisplayController"},
-        {10, D<&IApplicationProxy::GetProcessWindingController>, "GetProcessWindingController"},
-        {11, D<&IApplicationProxy::GetLibraryAppletCreator>, "GetLibraryAppletCreator"},
-        {20, D<&IApplicationProxy::GetApplicationFunctions>, "GetApplicationFunctions"},
-        {1000, D<&IApplicationProxy::GetDebugFunctions>, "GetDebugFunctions"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IApplicationProxy::~IApplicationProxy() = default;
-
-Result IApplicationProxy::GetAudioController(
-    Out<SharedPointer<IAudioController>> out_audio_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_audio_controller = std::make_shared<IAudioController>(system);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetDisplayController(
-    Out<SharedPointer<IDisplayController>> out_display_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_display_controller = std::make_shared<IDisplayController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetProcessWindingController(
-    Out<SharedPointer<IProcessWindingController>> out_process_winding_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_process_winding_controller = std::make_shared<IProcessWindingController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetDebugFunctions(
-    Out<SharedPointer<IDebugFunctions>> out_debug_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_debug_functions = std::make_shared<IDebugFunctions>(system);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetWindowController(
-    Out<SharedPointer<IWindowController>> out_window_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_window_controller = std::make_shared<IWindowController>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetSelfController(
-    Out<SharedPointer<ISelfController>> out_self_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_self_controller = std::make_shared<ISelfController>(system, m_applet, m_process);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetCommonStateGetter(
-    Out<SharedPointer<ICommonStateGetter>> out_common_state_getter) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_common_state_getter = std::make_shared<ICommonStateGetter>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetLibraryAppletCreator(
-    Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_library_applet_creator =
-        std::make_shared<ILibraryAppletCreator>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result IApplicationProxy::GetApplicationFunctions(
-    Out<SharedPointer<IApplicationFunctions>> out_application_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_application_functions = std::make_shared<IApplicationFunctions>(system, m_applet);
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/application_proxy.h

@@ -1,49 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-struct Applet;
-class IAudioController;
-class IApplicationFunctions;
-class ICommonStateGetter;
-class IDebugFunctions;
-class IDisplayController;
-class ILibraryAppletCreator;
-class IProcessWindingController;
-class ISelfController;
-class IWindowController;
-class WindowSystem;
-
-class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
-public:
-    explicit IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                               Kernel::KProcess* process, WindowSystem& window_system);
-    ~IApplicationProxy();
-
-private:
-    Result GetAudioController(Out<SharedPointer<IAudioController>> out_audio_controller);
-    Result GetDisplayController(Out<SharedPointer<IDisplayController>> out_display_controller);
-    Result GetProcessWindingController(
-        Out<SharedPointer<IProcessWindingController>> out_process_winding_controller);
-    Result GetDebugFunctions(Out<SharedPointer<IDebugFunctions>> out_debug_functions);
-    Result GetWindowController(Out<SharedPointer<IWindowController>> out_window_controller);
-    Result GetSelfController(Out<SharedPointer<ISelfController>> out_self_controller);
-    Result GetCommonStateGetter(Out<SharedPointer<ICommonStateGetter>> out_common_state_getter);
-    Result GetLibraryAppletCreator(
-        Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator);
-    Result GetApplicationFunctions(
-        Out<SharedPointer<IApplicationFunctions>> out_application_functions);
-
-private:
-    WindowSystem& m_window_system;
-    Kernel::KProcess* const m_process;
-    const std::shared_ptr<Applet> m_applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/application_proxy_service.cpp

@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/am/service/application_proxy.h"
-#include "core/hle/service/am/service/application_proxy_service.h"
-#include "core/hle/service/am/window_system.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-IApplicationProxyService::IApplicationProxyService(Core::System& system_,
-                                                   WindowSystem& window_system)
-    : ServiceFramework{system_, "appletOE"}, m_window_system{window_system} {
-    static const FunctionInfo functions[] = {
-        {0, D<&IApplicationProxyService::OpenApplicationProxy>, "OpenApplicationProxy"},
-    };
-    RegisterHandlers(functions);
-}
-
-IApplicationProxyService::~IApplicationProxyService() = default;
-
-Result IApplicationProxyService::OpenApplicationProxy(
-    Out<SharedPointer<IApplicationProxy>> out_application_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
-    LOG_DEBUG(Service_AM, "called");
-
-    if (const auto applet = this->GetAppletFromProcessId(pid)) {
-        *out_application_proxy = std::make_shared<IApplicationProxy>(
-            system, applet, process_handle.Get(), m_window_system);
-        R_SUCCEED();
-    } else {
-        UNIMPLEMENTED();
-        R_THROW(ResultUnknown);
-    }
-}
-
-std::shared_ptr<Applet> IApplicationProxyService::GetAppletFromProcessId(ProcessId process_id) {
-    return m_window_system.GetByAppletResourceUserId(process_id.pid);
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/application_proxy_service.h

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service {
-
-namespace AM {
-
-struct Applet;
-class IApplicationProxy;
-class WindowSystem;
-
-class IApplicationProxyService final : public ServiceFramework<IApplicationProxyService> {
-public:
-    explicit IApplicationProxyService(Core::System& system_, WindowSystem& window_system);
-    ~IApplicationProxyService() override;
-
-private:
-    Result OpenApplicationProxy(Out<SharedPointer<IApplicationProxy>> out_application_proxy,
-                                ClientProcessId pid, InCopyHandle<Kernel::KProcess> process_handle);
-
-private:
-    std::shared_ptr<Applet> GetAppletFromProcessId(ProcessId pid);
-
-    WindowSystem& m_window_system;
-};
-
-} // namespace AM
-} // namespace Service

src/core/hle/service/am/service/audio_controller.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -9,20 +9,20 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioController::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IAudioController::SetExpectedMasterVolume>, "SetExpectedMasterVolume"},
+        FunctionInfo{1, D<&IAudioController::GetMainAppletExpectedMasterVolume>, "GetMainAppletExpectedMasterVolume"},
+        FunctionInfo{2, D<&IAudioController::GetLibraryAppletExpectedMasterVolume>, "GetLibraryAppletExpectedMasterVolume"},
+        FunctionInfo{3, D<&IAudioController::ChangeMainAppletMasterVolume>, "ChangeMainAppletMasterVolume"},
+        FunctionInfo{4, D<&IAudioController::SetTransparentVolumeRate>, "SetTransparentVolumeRate"},
+        FunctionInfo{5, nullptr, "Unknown5", MakeVersionGate({20,0,0})}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IAudioController::IAudioController(Core::System& system_)
     : ServiceFramework{system_, "IAudioController"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IAudioController::SetExpectedMasterVolume>, "SetExpectedMasterVolume"},
-        {1, D<&IAudioController::GetMainAppletExpectedMasterVolume>, "GetMainAppletExpectedMasterVolume"},
-        {2, D<&IAudioController::GetLibraryAppletExpectedMasterVolume>, "GetLibraryAppletExpectedMasterVolume"},
-        {3, D<&IAudioController::ChangeMainAppletMasterVolume>, "ChangeMainAppletMasterVolume"},
-        {4, D<&IAudioController::SetTransparentVolumeRate>, "SetTransparentVolumeRate"},
-        {5, nullptr, "Unknown5"}, //20.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IAudioController::~IAudioController() = default;

src/core/hle/service/am/service/audio_controller.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,6 +23,7 @@ private:
     Result ChangeMainAppletMasterVolume(f32 volume, s64 fade_time_ns);
     Result SetTransparentVolumeRate(f32 transparent_volume_rate);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     static constexpr float MinAllowedVolume = 0.0f;
     static constexpr float MaxAllowedVolume = 1.0f;
 

src/core/hle/service/am/service/common_state_getter.cpp

@@ -8,7 +8,6 @@
 #include "core/hle/service/am/am_results.h"
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/service/common_state_getter.h"
-#include "core/hle/service/am/service/lock_accessor.h"
 #include "core/hle/service/am/service/storage.h"
 #include "core/hle/service/apm/apm_interface.h"
 #include "core/hle/service/cmif_serialization.h"
@@ -18,77 +17,147 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> ICommonStateGetter::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&ICommonStateGetter::GetEventHandle>, "GetEventHandle"},
+        FunctionInfo{1, D<&ICommonStateGetter::ReceiveMessage>, "ReceiveMessage"},
+        FunctionInfo{2, nullptr, "GetThisAppletKind"},
+        FunctionInfo{3, nullptr, "AllowToEnterSleep"},
+        FunctionInfo{4, nullptr, "DisallowToEnterSleep"},
+        FunctionInfo{5, D<&ICommonStateGetter::GetOperationMode>, "GetOperationMode"},
+        FunctionInfo{6, D<&ICommonStateGetter::GetPerformanceMode>, "GetPerformanceMode"},
+        FunctionInfo{7, nullptr, "GetCradleStatus"},
+        FunctionInfo{8, D<&ICommonStateGetter::GetBootMode>, "GetBootMode"},
+        FunctionInfo{9, D<&ICommonStateGetter::GetCurrentFocusState>, "GetCurrentFocusState"},
+        FunctionInfo{10, D<&ICommonStateGetter::RequestToAcquireSleepLock>, "RequestToAcquireSleepLock"},
+        FunctionInfo{11, D<&ICommonStateGetter::ReleaseSleepLock>, "ReleaseSleepLock"},
+        FunctionInfo{12, D<&ICommonStateGetter::ReleaseSleepLockTransiently>, "ReleaseSleepLockTransiently"},
+        FunctionInfo{13, D<&ICommonStateGetter::GetAcquiredSleepLockEvent>, "GetAcquiredSleepLockEvent"},
+        FunctionInfo{14, nullptr, "GetWakeupCount", MakeVersionGate({11,0,0})},
+        FunctionInfo{15, nullptr, "Unknown15", MakeVersionGate({19,0,0})},
+        FunctionInfo{20, D<&ICommonStateGetter::PushToGeneralChannel>, "PushToGeneralChannel"},
+        FunctionInfo{30, D<&ICommonStateGetter::GetHomeButtonReaderLockAccessor>, "GetHomeButtonReaderLockAccessor"},
+        FunctionInfo{31, D<&ICommonStateGetter::GetReaderLockAccessorEx>, "GetReaderLockAccessorEx", MakeVersionGate({2,0,0})},
+        FunctionInfo{32, D<&ICommonStateGetter::GetWriterLockAccessorEx>, "GetWriterLockAccessorEx", MakeVersionGate({7,0,0})},
+        FunctionInfo{40, nullptr, "GetCradleFwVersion", MakeVersionGate({2,0,0})},
+        FunctionInfo{50, D<&ICommonStateGetter::IsVrModeEnabled>, "IsVrModeEnabled", MakeVersionGate({3,0,0})},
+        FunctionInfo{51, D<&ICommonStateGetter::SetVrModeEnabled>, "SetVrModeEnabled", MakeVersionGate({3,0,0})},
+        FunctionInfo{52, D<&ICommonStateGetter::SetLcdBacklighOffEnabled>, "SetLcdBacklighOffEnabled", MakeVersionGate({4,0,0})},
+        FunctionInfo{53, D<&ICommonStateGetter::BeginVrModeEx>, "BeginVrModeEx", MakeVersionGate({7,0,0})},
+        FunctionInfo{54, D<&ICommonStateGetter::EndVrModeEx>, "EndVrModeEx", MakeVersionGate({7,0,0})},
+        FunctionInfo{55, D<&ICommonStateGetter::IsInControllerFirmwareUpdateSection>, "IsInControllerFirmwareUpdateSection", MakeVersionGate({3,0,0})},
+        FunctionInfo{59, nullptr, "SetVrPositionForDebug", MakeVersionGate({1,0,0})},
+        FunctionInfo{60, D<&ICommonStateGetter::GetDefaultDisplayResolution>, "GetDefaultDisplayResolution"},
+        FunctionInfo{61, D<&ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent>, "GetDefaultDisplayResolutionChangeEvent"},
+        FunctionInfo{62, D<&ICommonStateGetter::GetHdcpAuthenticationState>, "GetHdcpAuthenticationState"},
+        FunctionInfo{63, D<&ICommonStateGetter::GetHdcpAuthenticationStateChangeEvent>, "GetHdcpAuthenticationStateChangeEvent"},
+        FunctionInfo{64, nullptr, "SetTvPowerStateMatchingMode"},
+        FunctionInfo{65, nullptr, "GetApplicationIdByContentActionName"},
+        FunctionInfo{66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
+        FunctionInfo{67, nullptr, "CancelCpuBoostMode"},
+        FunctionInfo{68, D<&ICommonStateGetter::GetBuiltInDisplayType>, "GetBuiltInDisplayType"},
+        FunctionInfo{80, D<&ICommonStateGetter::PerformSystemButtonPressingIfInFocus>, "PerformSystemButtonPressingIfInFocus"},
+        FunctionInfo{90, nullptr, "SetPerformanceConfigurationChangedNotification"},
+        FunctionInfo{91, nullptr, "GetCurrentPerformanceConfiguration"},
+        FunctionInfo{100, D<&ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
+        FunctionInfo{110, nullptr, "OpenMyGpuErrorHandler"},
+        FunctionInfo{120, D<&ICommonStateGetter::GetAppletLaunchedHistory>, "GetAppletLaunchedHistory", MakeVersionGate({13,0,0})},
+        FunctionInfo{130, D<&ICommonStateGetter::EnableStartupLogoDisappearedMessage>, "EnableStartupLogoDisappearedMessage", MakeVersionGate({21,0,0})},
+        FunctionInfo{200, D<&ICommonStateGetter::GetOperationModeSystemInfo>, "GetOperationModeSystemInfo"},
+        FunctionInfo{300, D<&ICommonStateGetter::GetSettingsPlatformRegion>, "GetSettingsPlatformRegion"},
+        FunctionInfo{400, nullptr, "ActivateMigrationService"},
+        FunctionInfo{401, nullptr, "DeactivateMigrationService"},
+        FunctionInfo{500, nullptr, "DisableSleepTillShutdown"},
+        FunctionInfo{501, nullptr, "SuppressDisablingSleepTemporarily"},
+        FunctionInfo{502, nullptr, "IsSleepEnabled"},
+        FunctionInfo{503, nullptr, "IsDisablingSleepSuppressed"},
+        FunctionInfo{600, nullptr, "SetHidInputMagnificationForApplication", MakeVersionGate({20,0,0})},
+        FunctionInfo{610, D<&ICommonStateGetter::Unknown610>, "Unknown610", MakeVersionGate({21,0,0})},
+        FunctionInfo{611, D<&ICommonStateGetter::Unknown611>, "Unknown611", MakeVersionGate({22,0,0})},
+        FunctionInfo{900, D<&ICommonStateGetter::SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled>, "SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled", MakeVersionGate({11,0,0})},
+        FunctionInfo{910, nullptr, "GetLaunchRequiredTick", MakeVersionGate({17,0,0})},
+        FunctionInfo{1000, D<&ICommonStateGetter::BeginVrMode3d>, "BeginVrMode3d", MakeVersionGate({19,0,0})},
+        FunctionInfo{1001, D<&ICommonStateGetter::EndVrMode3d>, "EndVrMode3d", MakeVersionGate({19,0,0})},
+        FunctionInfo{1002, D<&ICommonStateGetter::IsVrModeEnabled3d>, "IsVrModeEnabled3d", MakeVersionGate({19,0,0})},
+        FunctionInfo{1003, D<&ICommonStateGetter::GetVrLaboGoggleViewport>, "GetVrLaboGoggleViewport", MakeVersionGate({21,0,0})},
+        FunctionInfo{1004, D<&ICommonStateGetter::GetPanelPhysicalSizeForSpecificTitle>, "GetPanelPhysicalSizeForSpecificTitle", MakeVersionGate({21,0,0})},
+        FunctionInfo{1005, D<&ICommonStateGetter::GetPanelResolutionForSpecificTitle>, "GetPanelResolutionForSpecificTitle", MakeVersionGate({21,0,0})}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
+class ILockAccessor final : public ServiceFramework<ILockAccessor> {
+public:
+    explicit ILockAccessor(Core::System& system_)
+        : ServiceFramework{system_, "ILockAccessor"}, m_context{system_, "ILockAccessor"},
+        m_event{m_context} {
+        m_event.Signal(system.Kernel());
+    }
+    ~ILockAccessor() override = default;
+
+    Result TryLock(Out<bool> out_is_locked, OutCopyHandle<Kernel::KReadableEvent> out_handle, bool return_handle) {
+        LOG_INFO(Service_AM, "called, return_handle={}", return_handle);
+
+        {
+            std::scoped_lock lk{m_mutex};
+            if (m_is_locked) {
+                *out_is_locked = false;
+            } else {
+                m_is_locked = true;
+                *out_is_locked = true;
+            }
+        }
+
+        if (return_handle) {
+            *out_handle = m_event.GetHandle();
+        }
+
+        R_SUCCEED();
+    }
+
+    Result Unlock() {
+        LOG_INFO(Service_AM, "called");
+
+        {
+            std::scoped_lock lk{m_mutex};
+            m_is_locked = false;
+        }
+
+        m_event.Signal(system.Kernel());
+        R_SUCCEED();
+    }
+
+    Result GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_handle) {
+        LOG_INFO(Service_AM, "called");
+        *out_handle = m_event.GetHandle();
+        R_SUCCEED();
+    }
+
+    Result IsLocked(Out<bool> out_is_locked) {
+        LOG_INFO(Service_AM, "called");
+        std::scoped_lock lk{m_mutex};
+        *out_is_locked = m_is_locked;
+        R_SUCCEED();
+    }
+
+private:
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{1, D<&ILockAccessor::TryLock>, "TryLock"},
+        FunctionInfo{2, D<&ILockAccessor::Unlock>, "Unlock"},
+        FunctionInfo{3, D<&ILockAccessor::GetEvent>, "GetEvent"},
+        FunctionInfo{4, D<&ILockAccessor::IsLocked>, "IsLocked"}
+    );
+    KernelHelpers::ServiceContext m_context;
+    Event m_event;
+    std::mutex m_mutex{};
+    bool m_is_locked{};
+};
+
 ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Applet> applet)
     : ServiceFramework{system_, "ICommonStateGetter"}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ICommonStateGetter::GetEventHandle>, "GetEventHandle"},
-        {1, D<&ICommonStateGetter::ReceiveMessage>, "ReceiveMessage"},
-        {2, nullptr, "GetThisAppletKind"},
-        {3, nullptr, "AllowToEnterSleep"},
-        {4, nullptr, "DisallowToEnterSleep"},
-        {5, D<&ICommonStateGetter::GetOperationMode>, "GetOperationMode"},
-        {6, D<&ICommonStateGetter::GetPerformanceMode>, "GetPerformanceMode"},
-        {7, nullptr, "GetCradleStatus"},
-        {8, D<&ICommonStateGetter::GetBootMode>, "GetBootMode"},
-        {9, D<&ICommonStateGetter::GetCurrentFocusState>, "GetCurrentFocusState"},
-        {10, D<&ICommonStateGetter::RequestToAcquireSleepLock>, "RequestToAcquireSleepLock"},
-        {11, D<&ICommonStateGetter::ReleaseSleepLock>, "ReleaseSleepLock"},
-        {12, D<&ICommonStateGetter::ReleaseSleepLockTransiently>, "ReleaseSleepLockTransiently"},
-        {13, D<&ICommonStateGetter::GetAcquiredSleepLockEvent>, "GetAcquiredSleepLockEvent"},
-        {14, nullptr, "GetWakeupCount"}, //11.0.0+
-        {15, nullptr, "Unknown15"}, //19.0.0+
-        {20, D<&ICommonStateGetter::PushToGeneralChannel>, "PushToGeneralChannel"},
-        {30, D<&ICommonStateGetter::GetHomeButtonReaderLockAccessor>, "GetHomeButtonReaderLockAccessor"},
-        {31, D<&ICommonStateGetter::GetReaderLockAccessorEx>, "GetReaderLockAccessorEx"}, //2.0.0+
-        {32, D<&ICommonStateGetter::GetWriterLockAccessorEx>, "GetWriterLockAccessorEx"}, //7.0.0+
-        {40, nullptr, "GetCradleFwVersion"}, //2.0.0+
-        {50, D<&ICommonStateGetter::IsVrModeEnabled>, "IsVrModeEnabled"}, //3.0.0+
-        {51, D<&ICommonStateGetter::SetVrModeEnabled>, "SetVrModeEnabled"}, //3.0.0+
-        {52, D<&ICommonStateGetter::SetLcdBacklighOffEnabled>, "SetLcdBacklighOffEnabled"}, //4.0.0+
-        {53, D<&ICommonStateGetter::BeginVrModeEx>, "BeginVrModeEx"}, //7.0.0+
-        {54, D<&ICommonStateGetter::EndVrModeEx>, "EndVrModeEx"}, //7.0.0+
-        {55, D<&ICommonStateGetter::IsInControllerFirmwareUpdateSection>, "IsInControllerFirmwareUpdateSection"}, //3.0.0+
-        {59, nullptr, "SetVrPositionForDebug"}, //1.0.0+
-        {60, D<&ICommonStateGetter::GetDefaultDisplayResolution>, "GetDefaultDisplayResolution"},
-        {61, D<&ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent>, "GetDefaultDisplayResolutionChangeEvent"},
-        {62, D<&ICommonStateGetter::GetHdcpAuthenticationState>, "GetHdcpAuthenticationState"},
-        {63, D<&ICommonStateGetter::GetHdcpAuthenticationStateChangeEvent>, "GetHdcpAuthenticationStateChangeEvent"},
-        {64, nullptr, "SetTvPowerStateMatchingMode"},
-        {65, nullptr, "GetApplicationIdByContentActionName"},
-        {66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
-        {67, nullptr, "CancelCpuBoostMode"},
-        {68, D<&ICommonStateGetter::GetBuiltInDisplayType>, "GetBuiltInDisplayType"},
-        {80, D<&ICommonStateGetter::PerformSystemButtonPressingIfInFocus>, "PerformSystemButtonPressingIfInFocus"},
-        {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
-        {91, nullptr, "GetCurrentPerformanceConfiguration"},
-        {100, D<&ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
-        {110, nullptr, "OpenMyGpuErrorHandler"},
-        {120, D<&ICommonStateGetter::GetAppletLaunchedHistory>, "GetAppletLaunchedHistory"}, //13.0.0+
-        {130, D<&ICommonStateGetter::EnableStartupLogoDisappearedMessage>, "EnableStartupLogoDisappearedMessage"}, //21.0.0+
-        {200, D<&ICommonStateGetter::GetOperationModeSystemInfo>, "GetOperationModeSystemInfo"},
-        {300, D<&ICommonStateGetter::GetSettingsPlatformRegion>, "GetSettingsPlatformRegion"},
-        {400, nullptr, "ActivateMigrationService"},
-        {401, nullptr, "DeactivateMigrationService"},
-        {500, nullptr, "DisableSleepTillShutdown"},
-        {501, nullptr, "SuppressDisablingSleepTemporarily"},
-        {502, nullptr, "IsSleepEnabled"},
-        {503, nullptr, "IsDisablingSleepSuppressed"},
-        {600, nullptr, "SetHidInputMagnificationForApplication"}, //20.0.0+
-        {610, D<&ICommonStateGetter::Unknown610>, "Unknown610"}, //21.0.0+
-        {611, D<&ICommonStateGetter::Unknown611>, "Unknown611"}, //22.0.0+
-        {900, D<&ICommonStateGetter::SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled>, "SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled"}, //11.0.0+
-        {910, nullptr, "GetLaunchRequiredTick"}, //17.0.0+
-        {1000, D<&ICommonStateGetter::BeginVrMode3d>, "BeginVrMode3d"}, //19.0.0+
-        {1001, D<&ICommonStateGetter::EndVrMode3d>, "EndVrMode3d"}, //19.0.0+
-        {1002, D<&ICommonStateGetter::IsVrModeEnabled3d>, "IsVrModeEnabled3d"}, //19.0.0+
-        {1003, D<&ICommonStateGetter::GetVrLaboGoggleViewport>, "GetVrLaboGoggleViewport"}, //21.0.0+
-        {1004, D<&ICommonStateGetter::GetPanelPhysicalSizeForSpecificTitle>, "GetPanelPhysicalSizeForSpecificTitle"}, //21.0.0+
-        {1005, D<&ICommonStateGetter::GetPanelResolutionForSpecificTitle>, "GetPanelResolutionForSpecificTitle"}, //21.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 ICommonStateGetter::~ICommonStateGetter() = default;

src/core/hle/service/am/service/common_state_getter.h

@@ -76,6 +76,7 @@ private:
 
     void SetCpuBoostMode(HLERequestContext& ctx);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     const std::shared_ptr<Applet> m_applet;
 };
 

src/core/hle/service/am/service/cradle_firmware_updater.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,22 +9,21 @@
 
 namespace Service::AM {
 
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> ICradleFirmwareUpdater::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, D<&ICradleFirmwareUpdater::StartUpdate>, "StartUpdate"},
+            FunctionInfo{1, D<&ICradleFirmwareUpdater::FinishUpdate>, "FinishUpdate"},
+            FunctionInfo{2, D<&ICradleFirmwareUpdater::GetCradleDeviceInfo>, "GetCradleDeviceInfo"},
+            FunctionInfo{3, D<&ICradleFirmwareUpdater::GetCradleDeviceInfoChangeEvent>, "GetCradleDeviceInfoChangeEvent"},
+            FunctionInfo{4, nullptr, "GetUpdateProgressInfo"},
+            FunctionInfo{5, nullptr, "GetLastInternalResult"}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+
 ICradleFirmwareUpdater::ICradleFirmwareUpdater(Core::System& system_)
     : ServiceFramework{system_, "ICradleFirmwareUpdater"},
       m_context{system, "ICradleFirmwareUpdater"}, m_cradle_device_info_event{m_context} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ICradleFirmwareUpdater::StartUpdate>, "StartUpdate"},
-        {1, D<&ICradleFirmwareUpdater::FinishUpdate>, "FinishUpdate"},
-        {2, D<&ICradleFirmwareUpdater::GetCradleDeviceInfo>, "GetCradleDeviceInfo"},
-        {3, D<&ICradleFirmwareUpdater::GetCradleDeviceInfoChangeEvent>, "GetCradleDeviceInfoChangeEvent"},
-        {4, nullptr, "GetUpdateProgressInfo"},
-        {5, nullptr, "GetLastInternalResult"},
-
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 ICradleFirmwareUpdater::~ICradleFirmwareUpdater() = default;

src/core/hle/service/am/service/cradle_firmware_updater.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -30,6 +33,7 @@ private:
     Result GetCradleDeviceInfoChangeEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
 private:
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext m_context;
     Event m_cradle_device_info_event;
 };

src/core/hle/service/am/service/debug_functions.cpp

@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/service/debug_functions.h"
-
-namespace Service::AM {
-
-IDebugFunctions::IDebugFunctions(Core::System& system_)
-    : ServiceFramework{system_, "IDebugFunctions"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "NotifyMessageToHomeMenuForDebug"},
-        {1, nullptr, "OpenMainApplication"},
-        {10, nullptr, "PerformSystemButtonPressing"},
-        {20, nullptr, "InvalidateTransitionLayer"},
-        {30, nullptr, "RequestLaunchApplicationWithUserAndArgumentForDebug"},
-        {31, nullptr, "RequestLaunchApplicationByApplicationLaunchInfoForDebug"},
-        {40, nullptr, "GetAppletResourceUsageInfo"},
-        {50, nullptr, "AddSystemProgramIdAndAppletIdForDebug"},
-        {51, nullptr, "AddOperationConfirmedLibraryAppletIdForDebug"},
-        {100, nullptr, "SetCpuBoostModeForApplet"},
-        {101, nullptr, "CancelCpuBoostModeForApplet"},
-        {110, nullptr, "PushToAppletBoundChannelForDebug"},
-        {111, nullptr, "TryPopFromAppletBoundChannelForDebug"},
-        {120, nullptr, "AlarmSettingNotificationEnableAppEventReserve"},
-        {121, nullptr, "AlarmSettingNotificationDisableAppEventReserve"},
-        {122, nullptr, "AlarmSettingNotificationPushAppEventNotify"},
-        {130, nullptr, "FriendInvitationSetApplicationParameter"},
-        {131, nullptr, "FriendInvitationClearApplicationParameter"},
-        {132, nullptr, "FriendInvitationPushApplicationParameter"},
-        {140, nullptr, "RestrictPowerOperationForSecureLaunchModeForDebug"},
-        {200, nullptr, "CreateFloatingLibraryAppletAccepterForDebug"},
-        {300, nullptr, "TerminateAllRunningApplicationsForDebug"},
-        {900, nullptr, "GetGrcProcessLaunchedSystemEvent"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDebugFunctions::~IDebugFunctions() = default;
-
-} // namespace Service::AM

src/core/hle/service/am/service/debug_functions.h

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-class IDebugFunctions final : public ServiceFramework<IDebugFunctions> {
-public:
-    explicit IDebugFunctions(Core::System& system_);
-    ~IDebugFunctions() override;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/display_controller.cpp

@@ -12,42 +12,42 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IDisplayController::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, nullptr, "GetLastForegroundCaptureImage"},
+        FunctionInfo{1, nullptr, "UpdateLastForegroundCaptureImage"},
+        FunctionInfo{2, nullptr, "GetLastApplicationCaptureImage"},
+        FunctionInfo{3, nullptr, "GetCallerAppletCaptureImage"},
+        FunctionInfo{4, nullptr, "UpdateCallerAppletCaptureImage"},
+        FunctionInfo{5, D<&IDisplayController::GetLastForegroundCaptureImageEx>, "GetLastForegroundCaptureImageEx"},
+        FunctionInfo{6, nullptr, "GetLastApplicationCaptureImageEx"},
+        FunctionInfo{7, D<&IDisplayController::GetCallerAppletCaptureImageEx>, "GetCallerAppletCaptureImageEx"},
+        FunctionInfo{8, D<&IDisplayController::TakeScreenShotOfOwnLayer>, "TakeScreenShotOfOwnLayer"},
+        FunctionInfo{9, nullptr, "CopyBetweenCaptureBuffers"},
+        FunctionInfo{10, nullptr, "AcquireLastApplicationCaptureBuffer"},
+        FunctionInfo{11, nullptr, "ReleaseLastApplicationCaptureBuffer"},
+        FunctionInfo{12, nullptr, "AcquireLastForegroundCaptureBuffer"},
+        FunctionInfo{13, nullptr, "ReleaseLastForegroundCaptureBuffer"},
+        FunctionInfo{14, nullptr, "AcquireCallerAppletCaptureBuffer"},
+        FunctionInfo{15, nullptr, "ReleaseCallerAppletCaptureBuffer"},
+        FunctionInfo{16, nullptr, "AcquireLastApplicationCaptureBufferEx"},
+        FunctionInfo{17, nullptr, "AcquireLastForegroundCaptureBufferEx"},
+        FunctionInfo{18, nullptr, "AcquireCallerAppletCaptureBufferEx"},
+        FunctionInfo{20, D<&IDisplayController::ClearCaptureBuffer>, "ClearCaptureBuffer"},
+        FunctionInfo{21, nullptr, "ClearAppletTransitionBuffer"},
+        FunctionInfo{22, D<&IDisplayController::AcquireLastApplicationCaptureSharedBuffer>, "AcquireLastApplicationCaptureSharedBuffer"},
+        FunctionInfo{23, D<&IDisplayController::ReleaseLastApplicationCaptureSharedBuffer>, "ReleaseLastApplicationCaptureSharedBuffer"},
+        FunctionInfo{24, D<&IDisplayController::AcquireLastForegroundCaptureSharedBuffer>, "AcquireLastForegroundCaptureSharedBuffer"},
+        FunctionInfo{25, D<&IDisplayController::ReleaseLastForegroundCaptureSharedBuffer>, "ReleaseLastForegroundCaptureSharedBuffer"},
+        FunctionInfo{26, D<&IDisplayController::AcquireCallerAppletCaptureSharedBuffer>, "AcquireCallerAppletCaptureSharedBuffer"},
+        FunctionInfo{27, D<&IDisplayController::ReleaseCallerAppletCaptureSharedBuffer>, "ReleaseCallerAppletCaptureSharedBuffer"},
+        FunctionInfo{28, nullptr, "TakeScreenShotOfOwnLayerEx"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IDisplayController::IDisplayController(Core::System& system_, std::shared_ptr<Applet> applet_)
     : ServiceFramework{system_, "IDisplayController"}, applet(std::move(applet_)) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetLastForegroundCaptureImage"},
-        {1, nullptr, "UpdateLastForegroundCaptureImage"},
-        {2, nullptr, "GetLastApplicationCaptureImage"},
-        {3, nullptr, "GetCallerAppletCaptureImage"},
-        {4, nullptr, "UpdateCallerAppletCaptureImage"},
-        {5, D<&IDisplayController::GetLastForegroundCaptureImageEx>, "GetLastForegroundCaptureImageEx"},
-        {6, nullptr, "GetLastApplicationCaptureImageEx"},
-        {7, D<&IDisplayController::GetCallerAppletCaptureImageEx>, "GetCallerAppletCaptureImageEx"},
-        {8, D<&IDisplayController::TakeScreenShotOfOwnLayer>, "TakeScreenShotOfOwnLayer"},
-        {9, nullptr, "CopyBetweenCaptureBuffers"},
-        {10, nullptr, "AcquireLastApplicationCaptureBuffer"},
-        {11, nullptr, "ReleaseLastApplicationCaptureBuffer"},
-        {12, nullptr, "AcquireLastForegroundCaptureBuffer"},
-        {13, nullptr, "ReleaseLastForegroundCaptureBuffer"},
-        {14, nullptr, "AcquireCallerAppletCaptureBuffer"},
-        {15, nullptr, "ReleaseCallerAppletCaptureBuffer"},
-        {16, nullptr, "AcquireLastApplicationCaptureBufferEx"},
-        {17, nullptr, "AcquireLastForegroundCaptureBufferEx"},
-        {18, nullptr, "AcquireCallerAppletCaptureBufferEx"},
-        {20, D<&IDisplayController::ClearCaptureBuffer>, "ClearCaptureBuffer"},
-        {21, nullptr, "ClearAppletTransitionBuffer"},
-        {22, D<&IDisplayController::AcquireLastApplicationCaptureSharedBuffer>, "AcquireLastApplicationCaptureSharedBuffer"},
-        {23, D<&IDisplayController::ReleaseLastApplicationCaptureSharedBuffer>, "ReleaseLastApplicationCaptureSharedBuffer"},
-        {24, D<&IDisplayController::AcquireLastForegroundCaptureSharedBuffer>, "AcquireLastForegroundCaptureSharedBuffer"},
-        {25, D<&IDisplayController::ReleaseLastForegroundCaptureSharedBuffer>, "ReleaseLastForegroundCaptureSharedBuffer"},
-        {26, D<&IDisplayController::AcquireCallerAppletCaptureSharedBuffer>, "AcquireCallerAppletCaptureSharedBuffer"},
-        {27, D<&IDisplayController::ReleaseCallerAppletCaptureSharedBuffer>, "ReleaseCallerAppletCaptureSharedBuffer"},
-        {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IDisplayController::~IDisplayController() = default;

src/core/hle/service/am/service/display_controller.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -35,6 +35,7 @@ private:
                                                      Out<s32> out_fbshare_layer_index);
     Result ReleaseLastApplicationCaptureSharedBuffer();
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     const std::shared_ptr<Applet> applet;
 };
 

src/core/hle/service/am/service/global_state_controller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,28 +10,28 @@
 
 namespace Service::AM {
 
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> IGlobalStateController::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestToEnterSleep"},
+            FunctionInfo{1, nullptr, "EnterSleep"},
+            FunctionInfo{2, nullptr, "StartSleepSequence"},
+            FunctionInfo{3, D<&IGlobalStateController::StartShutdownSequence>, "StartShutdownSequence"},
+            FunctionInfo{4, D<&IGlobalStateController::StartRebootSequence>, "StartRebootSequence"},
+            FunctionInfo{9, nullptr, "IsAutoPowerDownRequested"},
+            FunctionInfo{10, D<&IGlobalStateController::LoadAndApplyIdlePolicySettings>, "LoadAndApplyIdlePolicySettings"},
+            FunctionInfo{11, nullptr, "NotifyCecSettingsChanged"},
+            FunctionInfo{12, nullptr, "SetDefaultHomeButtonLongPressTime"},
+            FunctionInfo{13, nullptr, "UpdateDefaultDisplayResolution"},
+            FunctionInfo{14, D<&IGlobalStateController::ShouldSleepOnBoot>, "ShouldSleepOnBoot"},
+            FunctionInfo{15, D<&IGlobalStateController::GetHdcpAuthenticationFailedEvent>, "GetHdcpAuthenticationFailedEvent"},
+            FunctionInfo{30, D<&IGlobalStateController::OpenCradleFirmwareUpdater>, "OpenCradleFirmwareUpdater"}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+
 IGlobalStateController::IGlobalStateController(Core::System& system_)
     : ServiceFramework{system_, "IGlobalStateController"},
       m_context{system_, "IGlobalStateController"}, m_hdcp_authentication_failed_event{m_context} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestToEnterSleep"},
-        {1, nullptr, "EnterSleep"},
-        {2, nullptr, "StartSleepSequence"},
-        {3, D<&IGlobalStateController::StartShutdownSequence>, "StartShutdownSequence"},
-        {4, D<&IGlobalStateController::StartRebootSequence>, "StartRebootSequence"},
-        {9, nullptr, "IsAutoPowerDownRequested"},
-        {10, D<&IGlobalStateController::LoadAndApplyIdlePolicySettings>, "LoadAndApplyIdlePolicySettings"},
-        {11, nullptr, "NotifyCecSettingsChanged"},
-        {12, nullptr, "SetDefaultHomeButtonLongPressTime"},
-        {13, nullptr, "UpdateDefaultDisplayResolution"},
-        {14, D<&IGlobalStateController::ShouldSleepOnBoot>, "ShouldSleepOnBoot"},
-        {15, D<&IGlobalStateController::GetHdcpAuthenticationFailedEvent>, "GetHdcpAuthenticationFailedEvent"},
-        {30, D<&IGlobalStateController::OpenCradleFirmwareUpdater>, "OpenCradleFirmwareUpdater"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 Result IGlobalStateController::StartShutdownSequence() {

src/core/hle/service/am/service/global_state_controller.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,9 +26,9 @@ private:
     Result LoadAndApplyIdlePolicySettings();
     Result ShouldSleepOnBoot(Out<bool> out_should_sleep_on_boot);
     Result GetHdcpAuthenticationFailedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result OpenCradleFirmwareUpdater(
-        Out<SharedPointer<ICradleFirmwareUpdater>> out_cradle_firmware_updater);
+    Result OpenCradleFirmwareUpdater(Out<SharedPointer<ICradleFirmwareUpdater>> out_cradle_firmware_updater);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext m_context;
     Event m_hdcp_authentication_failed_event;
 };

src/core/hle/service/am/service/home_menu_functions.cpp

@@ -14,31 +14,31 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IHomeMenuFunctions::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{10, D<&IHomeMenuFunctions::RequestToGetForeground>, "RequestToGetForeground"},
+        FunctionInfo{11, D<&IHomeMenuFunctions::LockForeground>, "LockForeground"},
+        FunctionInfo{12, D<&IHomeMenuFunctions::UnlockForeground>, "UnlockForeground"},
+        FunctionInfo{20, D<&IHomeMenuFunctions::PopFromGeneralChannel>, "PopFromGeneralChannel"},
+        FunctionInfo{21, D<&IHomeMenuFunctions::GetPopFromGeneralChannelEvent>, "GetPopFromGeneralChannelEvent"},
+        FunctionInfo{30, nullptr, "GetHomeButtonWriterLockAccessor"},
+        FunctionInfo{31, nullptr, "GetWriterLockAccessorEx"},
+        FunctionInfo{40, D<&IHomeMenuFunctions::IsSleepEnabled>, "IsSleepEnabled"},
+        FunctionInfo{41, D<&IHomeMenuFunctions::IsRebootEnabled>, "IsRebootEnabled"},
+        FunctionInfo{50, nullptr, "LaunchSystemApplet"},
+        FunctionInfo{51, nullptr, "LaunchStarter"},
+        FunctionInfo{100, nullptr, "PopRequestLaunchApplicationForDebug"},
+        FunctionInfo{110, D<&IHomeMenuFunctions::IsForceTerminateApplicationDisabledForDebug>, "IsForceTerminateApplicationDisabledForDebug"},
+        FunctionInfo{200, nullptr, "LaunchDevMenu"},
+        FunctionInfo{1000, nullptr, "SetLastApplicationExitReason"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IHomeMenuFunctions::IHomeMenuFunctions(Core::System& system_, std::shared_ptr<Applet> applet,
                                        WindowSystem& window_system)
     : ServiceFramework{system_, "IHomeMenuFunctions"}, m_window_system{window_system},
       m_applet{std::move(applet)}, m_context{system, "IHomeMenuFunctions"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {10, D<&IHomeMenuFunctions::RequestToGetForeground>, "RequestToGetForeground"},
-        {11, D<&IHomeMenuFunctions::LockForeground>, "LockForeground"},
-        {12, D<&IHomeMenuFunctions::UnlockForeground>, "UnlockForeground"},
-        {20, D<&IHomeMenuFunctions::PopFromGeneralChannel>, "PopFromGeneralChannel"},
-        {21, D<&IHomeMenuFunctions::GetPopFromGeneralChannelEvent>, "GetPopFromGeneralChannelEvent"},
-        {30, nullptr, "GetHomeButtonWriterLockAccessor"},
-        {31, nullptr, "GetWriterLockAccessorEx"},
-        {40, D<&IHomeMenuFunctions::IsSleepEnabled>, "IsSleepEnabled"},
-        {41, D<&IHomeMenuFunctions::IsRebootEnabled>, "IsRebootEnabled"},
-        {50, nullptr, "LaunchSystemApplet"},
-        {51, nullptr, "LaunchStarter"},
-        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
-        {110, D<&IHomeMenuFunctions::IsForceTerminateApplicationDisabledForDebug>, "IsForceTerminateApplicationDisabledForDebug"},
-        {200, nullptr, "LaunchDevMenu"},
-        {1000, nullptr, "SetLastApplicationExitReason"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IHomeMenuFunctions::~IHomeMenuFunctions() = default;

src/core/hle/service/am/service/home_menu_functions.h

@@ -34,6 +34,7 @@ private:
     Result IsForceTerminateApplicationDisabledForDebug(
         Out<bool> out_is_force_terminate_application_disabled_for_debug);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     WindowSystem& m_window_system;
     const std::shared_ptr<Applet> m_applet;
     KernelHelpers::ServiceContext m_context;

src/core/hle/service/am/service/library_applet_accessor.cpp

@@ -17,9 +17,7 @@
 
 namespace Service::AM {
 
-namespace {
-
-void EnableSingleUserPlay(const std::shared_ptr<LibraryAppletStorage>& impl) {
+static void EnableSingleUserPlay(const std::shared_ptr<LibraryAppletStorage>& impl) {
     constexpr s64 DisplayOptionsOffset = 0x90;
     constexpr s64 IsSkipEnabledOffset = 1;
     constexpr s64 ShowSkipButtonOffset = 4;
@@ -29,7 +27,7 @@ void EnableSingleUserPlay(const std::shared_ptr<LibraryAppletStorage>& impl) {
     impl->Write(DisplayOptionsOffset + ShowSkipButtonOffset, &enabled, sizeof(enabled));
 }
 
-void ReplaceEmptyUuidWithCurrentUser(const std::shared_ptr<LibraryAppletStorage>& impl) {
+static void ReplaceEmptyUuidWithCurrentUser(const std::shared_ptr<LibraryAppletStorage>& impl) {
     Frontend::UiReturnArg return_arg{};
     impl->Read(0, &return_arg, sizeof(return_arg));
 
@@ -47,42 +45,40 @@ void ReplaceEmptyUuidWithCurrentUser(const std::shared_ptr<LibraryAppletStorage>
     }
 }
 
-} // namespace
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> ILibraryAppletAccessor::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, D<&ILibraryAppletAccessor::GetAppletStateChangedEvent>, "GetAppletStateChangedEvent"},
+            FunctionInfo{1, D<&ILibraryAppletAccessor::IsCompleted>, "IsCompleted"},
+            FunctionInfo{10, D<&ILibraryAppletAccessor::Start>, "Start"},
+            FunctionInfo{20, D<&ILibraryAppletAccessor::RequestExit>, "RequestExit"},
+            FunctionInfo{25, D<&ILibraryAppletAccessor::Terminate>, "Terminate"},
+            FunctionInfo{30, D<&ILibraryAppletAccessor::GetResult>, "GetResult"},
+            FunctionInfo{50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
+            FunctionInfo{60, D<&ILibraryAppletAccessor::PresetLibraryAppletGpuTimeSliceZero>, "PresetLibraryAppletGpuTimeSliceZero", MakeVersionGate({10,0,0})},
+            FunctionInfo{80, nullptr, "RequestForLibraryAppletToGetForeground", MakeVersionGate({19,0,0})},
+            FunctionInfo{81, nullptr, "GetCurrentChildLibraryApplet", MakeVersionGate({19,0,0})},
+            FunctionInfo{90, D<&ILibraryAppletAccessor::Unknown90>, "Unknown90", MakeVersionGate({20,0,0})},
+            FunctionInfo{100, D<&ILibraryAppletAccessor::PushInData>, "PushInData"},
+            FunctionInfo{101, D<&ILibraryAppletAccessor::PopOutData>, "PopOutData"},
+            FunctionInfo{102, nullptr, "PushExtraStorage"},
+            FunctionInfo{103, D<&ILibraryAppletAccessor::PushInteractiveInData>, "PushInteractiveInData"},
+            FunctionInfo{104, D<&ILibraryAppletAccessor::PopInteractiveOutData>, "PopInteractiveOutData"},
+            FunctionInfo{105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
+            FunctionInfo{106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
+            FunctionInfo{110, nullptr, "NeedsToExitProcess"},
+            FunctionInfo{120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
+            FunctionInfo{150, nullptr, "RequestForAppletToGetForeground"},
+            FunctionInfo{160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle", MakeVersionGate({2,0,0})},
+            FunctionInfo{170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170", MakeVersionGate({22,0,0})}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
 
 ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
                                                std::shared_ptr<AppletDataBroker> broker,
                                                std::shared_ptr<Applet> applet)
     : ServiceFramework{system_, "ILibraryAppletAccessor"}, m_broker{std::move(broker)},
       m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ILibraryAppletAccessor::GetAppletStateChangedEvent>, "GetAppletStateChangedEvent"},
-        {1, D<&ILibraryAppletAccessor::IsCompleted>, "IsCompleted"},
-        {10, D<&ILibraryAppletAccessor::Start>, "Start"},
-        {20, D<&ILibraryAppletAccessor::RequestExit>, "RequestExit"},
-        {25, D<&ILibraryAppletAccessor::Terminate>, "Terminate"},
-        {30, D<&ILibraryAppletAccessor::GetResult>, "GetResult"},
-        {50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
-        {60, D<&ILibraryAppletAccessor::PresetLibraryAppletGpuTimeSliceZero>, "PresetLibraryAppletGpuTimeSliceZero"}, //10.0.0+
-        {80, nullptr, "RequestForLibraryAppletToGetForeground"}, //19.0.0+
-        {81, nullptr, "GetCurrentChildLibraryApplet"}, //19.0.0+
-        {90, D<&ILibraryAppletAccessor::Unknown90>, "Unknown90"}, //20.0.0+
-        {100, D<&ILibraryAppletAccessor::PushInData>, "PushInData"},
-        {101, D<&ILibraryAppletAccessor::PopOutData>, "PopOutData"},
-        {102, nullptr, "PushExtraStorage"},
-        {103, D<&ILibraryAppletAccessor::PushInteractiveInData>, "PushInteractiveInData"},
-        {104, D<&ILibraryAppletAccessor::PopInteractiveOutData>, "PopInteractiveOutData"},
-        {105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
-        {106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
-        {110, nullptr, "NeedsToExitProcess"},
-        {120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
-        {150, nullptr, "RequestForAppletToGetForeground"},
-        {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
-        {170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170"}, //22.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 ILibraryAppletAccessor::~ILibraryAppletAccessor() = default;

src/core/hle/service/am/service/library_applet_accessor.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include "core/hle/service/am/service/library_applet_self_accessor.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
@@ -16,6 +15,26 @@ class AppletDataBroker;
 struct Applet;
 class IStorage;
 
+struct LibraryAppletInfo {
+    AppletId applet_id;
+    LibraryAppletMode library_applet_mode;
+};
+static_assert(sizeof(LibraryAppletInfo) == 0x8, "LibraryAppletInfo has incorrect size.");
+
+struct ErrorCode {
+    u32 category;
+    u32 number;
+};
+static_assert(sizeof(ErrorCode) == 0x8, "ErrorCode has incorrect size.");
+
+struct ErrorContext {
+    u8 type;
+    INSERT_PADDING_BYTES_NOINIT(0x7);
+    std::array<u8, 0x1f4> data;
+    Result result;
+};
+static_assert(sizeof(ErrorContext) == 0x200, "ErrorContext has incorrect size.");
+
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
     explicit ILibraryAppletAccessor(Core::System& system_, std::shared_ptr<AppletDataBroker> broker,
@@ -49,6 +68,7 @@ private:
     void FrontendExecuteInteractive();
     void FrontendRequestExit();
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     const std::shared_ptr<AppletDataBroker> m_broker;
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/am/service/library_applet_creator.cpp

@@ -1,287 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/settings.h"
-#include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/service/am/applet_data_broker.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/am/frontend/applets.h"
-#include "core/hle/service/am/library_applet_storage.h"
-#include "core/hle/service/am/process_creation.h"
-#include "core/hle/service/am/service/library_applet_accessor.h"
-#include "core/hle/service/am/service/library_applet_creator.h"
-
-#include "core/hle/api_version.h"
-#include "core/hle/service/am/service/storage.h"
-#include "core/hle/service/am/window_system.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace Service::AM {
-
-namespace {
-
-bool ShouldCreateGuestApplet(AppletId applet_id) {
-#define X(Name, name)                                                                              \
-    if (applet_id == AppletId::Name &&                                                             \
-        Settings::values.name##_applet_mode.GetValue() != Settings::AppletMode::LLE) {             \
-        return false;                                                                              \
-    }
-
-    X(Cabinet, cabinet)
-    X(Controller, controller)
-    X(DataErase, data_erase)
-    X(Error, error)
-    X(NetConnect, net_connect)
-    X(ProfileSelect, player_select)
-    X(SoftwareKeyboard, swkbd)
-    X(MiiEdit, mii_edit)
-    X(Web, web)
-    X(Shop, shop)
-    X(PhotoViewer, photo_viewer)
-    X(OfflineWeb, offline_web)
-    X(LoginShare, login_share)
-    X(WebAuth, wifi_web_auth)
-    X(MyPage, my_page)
-
-#undef X
-
-    return true;
-}
-
-AppletProgramId AppletIdToProgramId(AppletId applet_id) {
-    switch (applet_id) {
-    case AppletId::OverlayDisplay:
-        return AppletProgramId::OverlayDisplay;
-    case AppletId::QLaunch:
-        return AppletProgramId::QLaunch;
-    case AppletId::Starter:
-        return AppletProgramId::Starter;
-    case AppletId::Auth:
-        return AppletProgramId::Auth;
-    case AppletId::Cabinet:
-        return AppletProgramId::Cabinet;
-    case AppletId::Controller:
-        return AppletProgramId::Controller;
-    case AppletId::DataErase:
-        return AppletProgramId::DataErase;
-    case AppletId::Error:
-        return AppletProgramId::Error;
-    case AppletId::NetConnect:
-        return AppletProgramId::NetConnect;
-    case AppletId::ProfileSelect:
-        return AppletProgramId::ProfileSelect;
-    case AppletId::SoftwareKeyboard:
-        return AppletProgramId::SoftwareKeyboard;
-    case AppletId::MiiEdit:
-        return AppletProgramId::MiiEdit;
-    case AppletId::Web:
-        return AppletProgramId::Web;
-    case AppletId::Shop:
-        return AppletProgramId::Shop;
-    case AppletId::PhotoViewer:
-        return AppletProgramId::PhotoViewer;
-    case AppletId::Settings:
-        return AppletProgramId::Settings;
-    case AppletId::OfflineWeb:
-        return AppletProgramId::OfflineWeb;
-    case AppletId::LoginShare:
-        return AppletProgramId::LoginShare;
-    case AppletId::WebAuth:
-        return AppletProgramId::WebAuth;
-    case AppletId::MyPage:
-        return AppletProgramId::MyPage;
-    default:
-        return static_cast<AppletProgramId>(0);
-    }
-}
-
-std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
-                                                          WindowSystem& window_system,
-                                                          std::shared_ptr<Applet> caller_applet,
-                                                          AppletId applet_id,
-                                                          LibraryAppletMode mode) {
-    const auto program_id = static_cast<u64>(AppletIdToProgramId(applet_id));
-    if (program_id == 0) {
-        // Unknown applet
-        return {};
-    }
-
-    auto process = CreateProcess(system, program_id, 1, HLE::ApiVersion::HOS_VERSION_MAJOR);
-    if (process) {
-        const auto applet = std::make_shared<Applet>(system, std::move(process), false);
-        applet->program_id = program_id;
-        applet->applet_id = applet_id;
-        applet->type = AppletType::LibraryApplet;
-        applet->library_applet_mode = mode;
-        applet->window_visible = mode != LibraryAppletMode::AllForegroundInitiallyHidden;
-
-        auto broker = std::make_shared<AppletDataBroker>(system);
-        applet->caller_applet = caller_applet;
-        applet->caller_applet_broker = broker;
-        {
-            std::scoped_lock lk{caller_applet->lock};
-            caller_applet->child_applets.push_back(applet);
-        }
-        window_system.TrackApplet(applet, false);
-        return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
-    }
-    // Couldn't initialize the guest process
-    return {};
-}
-
-std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& system,
-                                                             WindowSystem& window_system,
-                                                             std::shared_ptr<Applet> caller_applet,
-                                                             AppletId applet_id,
-                                                             LibraryAppletMode mode) {
-    const auto program_id = static_cast<u64>(AppletIdToProgramId(applet_id));
-
-    auto process = std::make_unique<Process>(system);
-    auto applet = std::make_shared<Applet>(system, std::move(process), false);
-    applet->program_id = program_id;
-    applet->applet_id = applet_id;
-    applet->type = AppletType::LibraryApplet;
-    applet->library_applet_mode = mode;
-
-    auto storage = std::make_shared<AppletDataBroker>(system);
-    applet->caller_applet = caller_applet;
-    applet->caller_applet_broker = storage;
-    applet->frontend = system.GetFrontendAppletHolder().GetApplet(applet, applet_id, mode);
-    {
-        std::scoped_lock lk{caller_applet->lock};
-        caller_applet->child_applets.push_back(applet);
-    }
-    return std::make_shared<ILibraryAppletAccessor>(system, storage, applet);
-}
-
-} // namespace
-
-ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
-                                             WindowSystem& window_system)
-    : ServiceFramework{system_, "ILibraryAppletCreator"},
-      m_window_system{window_system}, m_applet{std::move(applet)} {
-    static const FunctionInfo functions[] = {
-        {0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
-        {1, nullptr, "TerminateAllLibraryApplets"},
-        {2, nullptr, "AreAnyLibraryAppletsLeft"},
-        {3, D<&ILibraryAppletCreator::CreateLibraryAppletEx>, "CreateLibraryAppletEx"},
-        {10, D<&ILibraryAppletCreator::CreateStorage>, "CreateStorage"},
-        {11, D<&ILibraryAppletCreator::CreateTransferMemoryStorage>, "CreateTransferMemoryStorage"},
-        {12, D<&ILibraryAppletCreator::CreateHandleStorage>, "CreateHandleStorage"},
-    };
-    RegisterHandlers(functions);
-}
-
-ILibraryAppletCreator::~ILibraryAppletCreator() = default;
-
-Result ILibraryAppletCreator::CreateLibraryApplet(
-    Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-    LibraryAppletMode library_applet_mode) {
-    LOG_DEBUG(Service_AM, "called with applet_id={} applet_mode={}", applet_id,
-              library_applet_mode);
-
-    std::shared_ptr<ILibraryAppletAccessor> library_applet;
-    if (ShouldCreateGuestApplet(applet_id)) {
-        library_applet =
-            CreateGuestApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        library_applet =
-            CreateFrontendApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
-        R_THROW(ResultUnknown);
-    }
-
-    // Applet is created, can now be launched.
-    m_applet->library_applet_launchable_event.Signal(system.Kernel());
-    *out_library_applet_accessor = library_applet;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletCreator::CreateLibraryAppletEx(
-    Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-    LibraryAppletMode library_applet_mode, u64 thread_id) {
-    LOG_DEBUG(Service_AM, "called with applet_id={} applet_mode={} thread_id={}", applet_id,
-              library_applet_mode, thread_id);
-
-    std::shared_ptr<ILibraryAppletAccessor> library_applet;
-    if (ShouldCreateGuestApplet(applet_id)) {
-        library_applet =
-            CreateGuestApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        library_applet =
-            CreateFrontendApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
-        R_THROW(ResultUnknown);
-    }
-
-    // Applet is created, can now be launched.
-    m_applet->library_applet_launchable_event.Signal(system.Kernel());
-    *out_library_applet_accessor = library_applet;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletCreator::CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size) {
-    LOG_DEBUG(Service_AM, "called, size={}", size);
-
-    if (size <= 0) {
-        LOG_ERROR(Service_AM, "size is less than or equal to 0");
-        R_THROW(ResultUnknown);
-    }
-
-    *out_storage = std::make_shared<IStorage>(system, AM::CreateStorage(std::vector<u8>(size)));
-    R_SUCCEED();
-}
-
-Result ILibraryAppletCreator::CreateTransferMemoryStorage(
-    Out<SharedPointer<IStorage>> out_storage, bool is_writable, s64 size,
-    InCopyHandle<Kernel::KTransferMemory> transfer_memory_handle) {
-    LOG_DEBUG(Service_AM, "called, is_writable={} size={}", is_writable, size);
-
-    if (size <= 0) {
-        LOG_ERROR(Service_AM, "size is less than or equal to 0");
-        R_THROW(ResultUnknown);
-    }
-
-    if (!transfer_memory_handle) {
-        LOG_ERROR(Service_AM, "transfer_memory_handle is null");
-        R_THROW(ResultUnknown);
-    }
-
-    *out_storage = std::make_shared<IStorage>(
-        system, AM::CreateTransferMemoryStorage(system.Kernel(), transfer_memory_handle->GetOwner()->GetMemory(),
-                                                transfer_memory_handle.Get(), is_writable, size));
-    R_SUCCEED();
-}
-
-Result ILibraryAppletCreator::CreateHandleStorage(
-    Out<SharedPointer<IStorage>> out_storage, s64 size,
-    InCopyHandle<Kernel::KTransferMemory> transfer_memory_handle) {
-    LOG_DEBUG(Service_AM, "called, size={}", size);
-
-    if (size <= 0) {
-        LOG_ERROR(Service_AM, "size is less than or equal to 0");
-        R_THROW(ResultUnknown);
-    }
-
-    if (!transfer_memory_handle) {
-        LOG_ERROR(Service_AM, "transfer_memory_handle is null");
-        R_THROW(ResultUnknown);
-    }
-
-    *out_storage = std::make_shared<IStorage>(
-        system, AM::CreateHandleStorage(system.Kernel(), transfer_memory_handle->GetOwner()->GetMemory(),
-                                        transfer_memory_handle.Get(), size));
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/library_applet_creator.h

@@ -1,44 +0,0 @@
-// 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-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/am/am_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-struct Applet;
-class ILibraryAppletAccessor;
-class IStorage;
-class WindowSystem;
-
-class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
-public:
-    explicit ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
-                                   WindowSystem& window_system);
-    ~ILibraryAppletCreator() override;
-
-private:
-    Result CreateLibraryApplet(
-        Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-        LibraryAppletMode library_applet_mode);
-    Result CreateLibraryAppletEx(
-        Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-        LibraryAppletMode library_applet_mode, u64 thread_id);
-    Result CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size);
-    Result CreateTransferMemoryStorage(
-        Out<SharedPointer<IStorage>> out_storage, bool is_writable, s64 size,
-        InCopyHandle<Kernel::KTransferMemory> transfer_memory_handle);
-    Result CreateHandleStorage(Out<SharedPointer<IStorage>> out_storage, s64 size,
-                               InCopyHandle<Kernel::KTransferMemory> transfer_memory_handle);
-
-    WindowSystem& m_window_system;
-    const std::shared_ptr<Applet> m_applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/library_applet_proxy.cpp

@@ -1,134 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/service/applet_common_functions.h"
-#include "core/hle/service/am/service/audio_controller.h"
-#include "core/hle/service/am/service/common_state_getter.h"
-#include "core/hle/service/am/service/debug_functions.h"
-#include "core/hle/service/am/service/display_controller.h"
-#include "core/hle/service/am/service/global_state_controller.h"
-#include "core/hle/service/am/service/home_menu_functions.h"
-#include "core/hle/service/am/service/library_applet_creator.h"
-#include "core/hle/service/am/service/library_applet_proxy.h"
-#include "core/hle/service/am/service/library_applet_self_accessor.h"
-#include "core/hle/service/am/service/process_winding_controller.h"
-#include "core/hle/service/am/service/self_controller.h"
-#include "core/hle/service/am/service/window_controller.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                                         Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "ILibraryAppletProxy"},
-      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
-        {1, D<&ILibraryAppletProxy::GetSelfController>, "GetSelfController"},
-        {2, D<&ILibraryAppletProxy::GetWindowController>, "GetWindowController"},
-        {3, D<&ILibraryAppletProxy::GetAudioController>, "GetAudioController"},
-        {4, D<&ILibraryAppletProxy::GetDisplayController>, "GetDisplayController"},
-        {10, D<&ILibraryAppletProxy::GetProcessWindingController>, "GetProcessWindingController"},
-        {11, D<&ILibraryAppletProxy::GetLibraryAppletCreator>, "GetLibraryAppletCreator"},
-        {20, D<&ILibraryAppletProxy::OpenLibraryAppletSelfAccessor>, "OpenLibraryAppletSelfAccessor"},
-        {21, D<&ILibraryAppletProxy::GetAppletCommonFunctions>, "GetAppletCommonFunctions"},
-        {22, D<&ILibraryAppletProxy::GetHomeMenuFunctions>, "GetHomeMenuFunctions"},
-        {23, D<&ILibraryAppletProxy::GetGlobalStateController>, "GetGlobalStateController"},
-        {1000, D<&ILibraryAppletProxy::GetDebugFunctions>, "GetDebugFunctions"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-ILibraryAppletProxy::~ILibraryAppletProxy() = default;
-
-Result ILibraryAppletProxy::GetAudioController(
-    Out<SharedPointer<IAudioController>> out_audio_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_audio_controller = std::make_shared<IAudioController>(system);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetDisplayController(
-    Out<SharedPointer<IDisplayController>> out_display_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_display_controller = std::make_shared<IDisplayController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetProcessWindingController(
-    Out<SharedPointer<IProcessWindingController>> out_process_winding_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_process_winding_controller = std::make_shared<IProcessWindingController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetDebugFunctions(
-    Out<SharedPointer<IDebugFunctions>> out_debug_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_debug_functions = std::make_shared<IDebugFunctions>(system);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetWindowController(
-    Out<SharedPointer<IWindowController>> out_window_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_window_controller = std::make_shared<IWindowController>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetSelfController(
-    Out<SharedPointer<ISelfController>> out_self_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_self_controller = std::make_shared<ISelfController>(system, m_applet, m_process);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetCommonStateGetter(
-    Out<SharedPointer<ICommonStateGetter>> out_common_state_getter) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_common_state_getter = std::make_shared<ICommonStateGetter>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetLibraryAppletCreator(
-    Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_library_applet_creator =
-        std::make_shared<ILibraryAppletCreator>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::OpenLibraryAppletSelfAccessor(
-    Out<SharedPointer<ILibraryAppletSelfAccessor>> out_library_applet_self_accessor) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_library_applet_self_accessor =
-        std::make_shared<ILibraryAppletSelfAccessor>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetAppletCommonFunctions(
-    Out<SharedPointer<IAppletCommonFunctions>> out_applet_common_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_applet_common_functions = std::make_shared<IAppletCommonFunctions>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetHomeMenuFunctions(
-    Out<SharedPointer<IHomeMenuFunctions>> out_home_menu_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_home_menu_functions =
-        std::make_shared<IHomeMenuFunctions>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletProxy::GetGlobalStateController(
-    Out<SharedPointer<IGlobalStateController>> out_global_state_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_global_state_controller = std::make_shared<IGlobalStateController>(system);
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/library_applet_proxy.h

@@ -1,56 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-struct Applet;
-class IAppletCommonFunctions;
-class IAudioController;
-class ICommonStateGetter;
-class IDebugFunctions;
-class IDisplayController;
-class IHomeMenuFunctions;
-class IGlobalStateController;
-class ILibraryAppletCreator;
-class ILibraryAppletSelfAccessor;
-class IProcessWindingController;
-class ISelfController;
-class IWindowController;
-class WindowSystem;
-
-class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
-public:
-    explicit ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                                 Kernel::KProcess* process, WindowSystem& window_system);
-    ~ILibraryAppletProxy();
-
-private:
-    Result GetAudioController(Out<SharedPointer<IAudioController>> out_audio_controller);
-    Result GetDisplayController(Out<SharedPointer<IDisplayController>> out_display_controller);
-    Result GetProcessWindingController(
-        Out<SharedPointer<IProcessWindingController>> out_process_winding_controller);
-    Result GetDebugFunctions(Out<SharedPointer<IDebugFunctions>> out_debug_functions);
-    Result GetWindowController(Out<SharedPointer<IWindowController>> out_window_controller);
-    Result GetSelfController(Out<SharedPointer<ISelfController>> out_self_controller);
-    Result GetCommonStateGetter(Out<SharedPointer<ICommonStateGetter>> out_common_state_getter);
-    Result GetLibraryAppletCreator(
-        Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator);
-    Result OpenLibraryAppletSelfAccessor(
-        Out<SharedPointer<ILibraryAppletSelfAccessor>> out_library_applet_self_accessor);
-    Result GetAppletCommonFunctions(
-        Out<SharedPointer<IAppletCommonFunctions>> out_applet_common_functions);
-    Result GetHomeMenuFunctions(Out<SharedPointer<IHomeMenuFunctions>> out_home_menu_functions);
-    Result GetGlobalStateController(
-        Out<SharedPointer<IGlobalStateController>> out_global_state_controller);
-
-    WindowSystem& m_window_system;
-    Kernel::KProcess* const m_process;
-    const std::shared_ptr<Applet> m_applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/library_applet_self_accessor.cpp

@@ -1,332 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core_timing.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/patch_manager.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/am/applet_data_broker.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/am/frontend/applets.h"
-#include "core/hle/service/am/service/library_applet_self_accessor.h"
-#include "core/hle/service/am/service/storage.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/glue/glue_manager.h"
-#include "core/hle/service/ns/application_manager_interface.h"
-#include "core/hle/service/ns/service_getter_interface.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace Service::AM {
-
-namespace {
-
-AppletIdentityInfo GetCallerIdentity(Applet& applet) {
-    if (const auto caller_applet = applet.caller_applet.lock(); caller_applet) {
-        // TODO: is this actually the application ID?
-        return {
-            .applet_id = caller_applet->applet_id,
-            .application_id = caller_applet->program_id,
-        };
-    } else {
-        return {
-            .applet_id = AppletId::QLaunch,
-            .application_id = 0x0100000000001000ull,
-        };
-    }
-}
-
-} // namespace
-
-ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_,
-                                                       std::shared_ptr<Applet> applet)
-    : ServiceFramework{system_, "ILibraryAppletSelfAccessor"}, m_applet{std::move(applet)},
-      m_broker{m_applet->caller_applet_broker} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ILibraryAppletSelfAccessor::PopInData>, "PopInData"},
-        {1, D<&ILibraryAppletSelfAccessor::PushOutData>, "PushOutData"},
-        {2, D<&ILibraryAppletSelfAccessor::PopInteractiveInData>, "PopInteractiveInData"},
-        {3, D<&ILibraryAppletSelfAccessor::PushInteractiveOutData>, "PushInteractiveOutData"},
-        {5, D<&ILibraryAppletSelfAccessor::GetPopInDataEvent>, "GetPopInDataEvent"},
-        {6, D<&ILibraryAppletSelfAccessor::GetPopInteractiveInDataEvent>, "GetPopInteractiveInDataEvent"},
-        {10, D<&ILibraryAppletSelfAccessor::ExitProcessAndReturn>, "ExitProcessAndReturn"},
-        {11, D<&ILibraryAppletSelfAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
-        {12, D<&ILibraryAppletSelfAccessor::GetMainAppletIdentityInfo>, "GetMainAppletIdentityInfo"},
-        {13, D<&ILibraryAppletSelfAccessor::CanUseApplicationCore>, "CanUseApplicationCore"},
-        {14, D<&ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo>, "GetCallerAppletIdentityInfo"},
-        {15, D<&ILibraryAppletSelfAccessor::GetMainAppletApplicationControlProperty>, "GetMainAppletApplicationControlProperty"},
-        {16, D<&ILibraryAppletSelfAccessor::GetMainAppletStorageId>, "GetMainAppletStorageId"},
-        {17, D<&ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfoStack>, "GetCallerAppletIdentityInfoStack"},
-        {18, nullptr, "GetNextReturnDestinationAppletIdentityInfo"},
-        {19, D<&ILibraryAppletSelfAccessor::GetDesirableKeyboardLayout>, "GetDesirableKeyboardLayout"},
-        {20, nullptr, "PopExtraStorage"},
-        {25, nullptr, "GetPopExtraStorageEvent"},
-        {30, D<&ILibraryAppletSelfAccessor::UnpopInData>, "UnpopInData"},
-        {31, nullptr, "UnpopExtraStorage"},
-        {40, nullptr, "GetIndirectLayerProducerHandle"},
-        {50, D<&ILibraryAppletSelfAccessor::ReportVisibleError>, "ReportVisibleError"},
-        {51, D<&ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext>, "ReportVisibleErrorWithErrorContext"},
-        {60, D<&ILibraryAppletSelfAccessor::GetMainAppletApplicationDesiredLanguage>, "GetMainAppletApplicationDesiredLanguage"},
-        {70, D<&ILibraryAppletSelfAccessor::GetCurrentApplicationId>, "GetCurrentApplicationId"},
-        {80, nullptr, "RequestExitToSelf"},
-        {90, nullptr, "CreateApplicationAndPushAndRequestToLaunch"},
-        {100, nullptr, "CreateGameMovieTrimmer"},
-        {101, nullptr, "ReserveResourceForMovieOperation"},
-        {102, nullptr, "UnreserveResourceForMovieOperation"},
-        {110, D<&ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers>, "GetMainAppletAvailableUsers"},
-        {120, nullptr, "GetLaunchStorageInfoForDebug"},
-        {130, nullptr, "GetGpuErrorDetectedSystemEvent"},
-        {140, nullptr, "SetApplicationMemoryReservation"},
-        {150, D<&ILibraryAppletSelfAccessor::ShouldSetGpuTimeSliceManually>, "ShouldSetGpuTimeSliceManually"},
-        {160, D<&ILibraryAppletSelfAccessor::GetLibraryAppletInfoEx>, "GetLibraryAppletInfoEx"},
-    };
-    // clang-format on
-    RegisterHandlers(functions);
-}
-
-ILibraryAppletSelfAccessor::~ILibraryAppletSelfAccessor() = default;
-
-Result ILibraryAppletSelfAccessor::PopInData(Out<SharedPointer<IStorage>> out_storage) {
-    LOG_INFO(Service_AM, "called");
-    R_RETURN(m_broker->GetInData().Pop(system.Kernel(), out_storage));
-}
-
-Result ILibraryAppletSelfAccessor::PushOutData(SharedPointer<IStorage> storage) {
-    LOG_INFO(Service_AM, "called");
-    m_broker->GetOutData().Push(system.Kernel(), storage);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::PopInteractiveInData(Out<SharedPointer<IStorage>> out_storage) {
-    LOG_INFO(Service_AM, "called");
-    R_RETURN(m_broker->GetInteractiveInData().Pop(system.Kernel(), out_storage));
-}
-
-Result ILibraryAppletSelfAccessor::PushInteractiveOutData(SharedPointer<IStorage> storage) {
-    LOG_INFO(Service_AM, "called");
-    m_broker->GetInteractiveOutData().Push(system.Kernel(), storage);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetPopInDataEvent(
-    OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_INFO(Service_AM, "called");
-    *out_event = m_broker->GetInData().GetEvent();
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetPopInteractiveInDataEvent(
-    OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_INFO(Service_AM, "called");
-    *out_event = m_broker->GetInteractiveInData().GetEvent();
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetLibraryAppletInfo(
-    Out<LibraryAppletInfo> out_library_applet_info) {
-    LOG_INFO(Service_AM, "called");
-    *out_library_applet_info = {
-        .applet_id = m_applet->applet_id,
-        .library_applet_mode = m_applet->library_applet_mode,
-    };
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetMainAppletIdentityInfo(
-    Out<AppletIdentityInfo> out_identity_info) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_identity_info = {
-        .applet_id = AppletId::QLaunch,
-        .application_id = 0x0100000000001000ull,
-    };
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::CanUseApplicationCore(Out<bool> out_can_use_application_core) {
-    // TODO: This appears to read the NPDM from state and check the core mask of the applet.
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_can_use_application_core = false;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetMainAppletApplicationControlProperty(
-    OutLargeData<std::array<u8, 0x4000>, BufferAttr_HipcMapAlias> out_nacp) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    // TODO: this should be the main applet, not the caller applet
-    const auto application = GetCallerIdentity(*m_applet);
-    std::vector<u8> nacp;
-    const auto result =
-        system.GetARPManager().GetControlProperty(&nacp, application.application_id);
-
-    if (R_SUCCEEDED(result)) {
-        std::memcpy(out_nacp->data(), nacp.data(), (std::min)(nacp.size(), out_nacp->size()));
-    }
-
-    R_RETURN(result);
-}
-
-Result ILibraryAppletSelfAccessor::GetMainAppletStorageId(Out<FileSys::StorageId> out_storage_id) {
-    LOG_INFO(Service_AM, "(STUBBED) called");
-    *out_storage_id = FileSys::StorageId::NandUser;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::ExitProcessAndReturn() {
-    LOG_INFO(Service_AM, "called");
-
-    if (const auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
-        m_applet->process->Terminate();
-    } else {
-        system.GetUserChannel() = m_applet->user_channel_launch_parameter;
-        system.ExecuteProgram(0);
-    }
-
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(
-    Out<AppletIdentityInfo> out_identity_info) {
-    LOG_INFO(Service_AM, "called");
-    *out_identity_info = GetCallerIdentity(*m_applet);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfoStack(
-    Out<s32> out_count, OutArray<AppletIdentityInfo, BufferAttr_HipcMapAlias> out_identity_info) {
-    LOG_INFO(Service_AM, "called");
-
-    std::shared_ptr<Applet> applet = m_applet;
-    *out_count = 0;
-
-    do {
-        if (*out_count >= static_cast<s32>(out_identity_info.size())) {
-            break;
-        }
-        out_identity_info[(*out_count)++] = GetCallerIdentity(*applet);
-    } while ((applet = applet->caller_applet.lock()));
-
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetDesirableKeyboardLayout(Out<u32> out_desirable_layout) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_desirable_layout = 0;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::ReportVisibleError(ErrorCode error_code) {
-    LOG_WARNING(Service_AM, "(STUBBED) called, error {}-{}", error_code.category,
-                error_code.number);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext(
-    ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context) {
-    LOG_WARNING(Service_AM, "(STUBBED) called, error {}-{}", error_code.category,
-                error_code.number);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::UnpopInData(SharedPointer<IStorage> storage) {
-    LOG_INFO(Service_AM, "called");
-    m_broker->GetInData().Unpop(system.Kernel(), storage);
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetMainAppletApplicationDesiredLanguage(
-    Out<u64> out_desired_language) {
-    // FIXME: this is copied from IApplicationFunctions::GetDesiredLanguage
-    // FIXME: all of this stuff belongs to ns
-    auto identity = GetCallerIdentity(*m_applet);
-
-    // TODO(bunnei): This should be configurable
-    LOG_DEBUG(Service_AM, "called");
-
-    // Get supported languages from NACP, if possible
-    // Default to 0 (all languages supported)
-    u32 supported_languages = 0;
-
-    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, identity.application_id);
-
-    if (res.first != nullptr) {
-        supported_languages = res.first->GetSupportedLanguages();
-    }
-
-    // Call IApplicationManagerInterface implementation.
-    auto& service_manager = system.ServiceManager();
-    auto ns_am2 = service_manager.GetService<NS::IServiceGetterInterface>("ns:am2");
-
-    std::shared_ptr<NS::IApplicationManagerInterface> app_man;
-    R_TRY(ns_am2->GetApplicationManagerInterface(&app_man));
-
-    // Get desired application language
-    NS::ApplicationLanguage desired_language{};
-    R_TRY(app_man->GetApplicationDesiredLanguage(&desired_language, supported_languages));
-
-    // Convert to settings language code.
-    u64 language_code{};
-    R_TRY(app_man->ConvertApplicationLanguageToLanguageCode(&language_code, desired_language));
-
-    LOG_DEBUG(Service_AM, "got desired_language={:016X}", language_code);
-
-    *out_desired_language = language_code;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetCurrentApplicationId(Out<u64> out_application_id) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    // TODO: this should be the main applet, not the caller applet
-    const auto main_applet = GetCallerIdentity(*m_applet);
-    *out_application_id = main_applet.application_id;
-
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers(
-    Out<bool> out_can_select_any_user, Out<s32> out_users_count,
-    OutArray<Common::UUID, BufferAttr_HipcMapAlias> out_users) {
-    const Service::Account::ProfileManager manager{};
-
-    *out_can_select_any_user = false;
-    *out_users_count = -1;
-
-    LOG_INFO(Service_AM, "called");
-
-    if (manager.GetUserCount() > 0) {
-        *out_can_select_any_user = true;
-        *out_users_count = static_cast<s32>(manager.GetUserCount());
-
-        const auto users = manager.GetAllUsers();
-        for (size_t i = 0; i < users.size() && i < out_users.size(); i++) {
-            out_users[i] = users[i];
-        }
-    }
-
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::ShouldSetGpuTimeSliceManually(
-    Out<bool> out_should_set_gpu_time_slice_manually) {
-    LOG_INFO(Service_AM, "(STUBBED) called");
-    *out_should_set_gpu_time_slice_manually = false;
-    R_SUCCEED();
-}
-
-Result ILibraryAppletSelfAccessor::GetLibraryAppletInfoEx(
-    Out<LibraryAppletInfo> out_library_applet_info) {
-    LOG_INFO(Service_AM, "called");
-    *out_library_applet_info = {
-        .applet_id = m_applet->applet_id,
-        .library_applet_mode = m_applet->library_applet_mode,
-    };
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/library_applet_self_accessor.h

@@ -1,87 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/uuid.h"
-#include "core/hle/service/am/am_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace FileSys {
-enum class StorageId : u8;
-}
-
-namespace Kernel {
-class KReadableEvent;
-}
-
-namespace Service::AM {
-
-class AppletDataBroker;
-struct Applet;
-class IStorage;
-
-struct LibraryAppletInfo {
-    AppletId applet_id;
-    LibraryAppletMode library_applet_mode;
-};
-static_assert(sizeof(LibraryAppletInfo) == 0x8, "LibraryAppletInfo has incorrect size.");
-
-struct ErrorCode {
-    u32 category;
-    u32 number;
-};
-static_assert(sizeof(ErrorCode) == 0x8, "ErrorCode has incorrect size.");
-
-struct ErrorContext {
-    u8 type;
-    INSERT_PADDING_BYTES_NOINIT(0x7);
-    std::array<u8, 0x1f4> data;
-    Result result;
-};
-static_assert(sizeof(ErrorContext) == 0x200, "ErrorContext has incorrect size.");
-
-class ILibraryAppletSelfAccessor final : public ServiceFramework<ILibraryAppletSelfAccessor> {
-public:
-    explicit ILibraryAppletSelfAccessor(Core::System& system_, std::shared_ptr<Applet> applet);
-    ~ILibraryAppletSelfAccessor() override;
-
-private:
-    Result PopInData(Out<SharedPointer<IStorage>> out_storage);
-    Result PushOutData(SharedPointer<IStorage> storage);
-    Result PopInteractiveInData(Out<SharedPointer<IStorage>> out_storage);
-    Result PushInteractiveOutData(SharedPointer<IStorage> storage);
-    Result GetPopInDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result GetPopInteractiveInDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result GetLibraryAppletInfo(Out<LibraryAppletInfo> out_library_applet_info);
-    Result GetMainAppletIdentityInfo(Out<AppletIdentityInfo> out_identity_info);
-    Result CanUseApplicationCore(Out<bool> out_can_use_application_core);
-    Result GetMainAppletApplicationControlProperty(
-        OutLargeData<std::array<u8, 0x4000>, BufferAttr_HipcMapAlias> out_nacp);
-    Result GetMainAppletStorageId(Out<FileSys::StorageId> out_storage_id);
-    Result ExitProcessAndReturn();
-    Result GetCallerAppletIdentityInfo(Out<AppletIdentityInfo> out_identity_info);
-    Result GetCallerAppletIdentityInfoStack(
-        Out<s32> out_count,
-        OutArray<AppletIdentityInfo, BufferAttr_HipcMapAlias> out_identity_info);
-    Result GetDesirableKeyboardLayout(Out<u32> out_desirable_layout);
-    Result ReportVisibleError(ErrorCode error_code);
-    Result ReportVisibleErrorWithErrorContext(
-        ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context);
-    Result UnpopInData(SharedPointer<IStorage> storage);
-    Result GetMainAppletApplicationDesiredLanguage(Out<u64> out_desired_language);
-    Result GetCurrentApplicationId(Out<u64> out_application_id);
-    Result GetMainAppletAvailableUsers(Out<bool> out_can_select_any_user, Out<s32> out_users_count,
-                                       OutArray<Common::UUID, BufferAttr_HipcMapAlias> out_users);
-    Result ShouldSetGpuTimeSliceManually(Out<bool> out_should_set_gpu_time_slice_manually);
-    Result GetLibraryAppletInfoEx(Out<LibraryAppletInfo> out_library_applet_info);
-
-    const std::shared_ptr<Applet> m_applet;
-    const std::shared_ptr<AppletDataBroker> m_broker;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/lock_accessor.cpp

@@ -1,78 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/service/lock_accessor.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-ILockAccessor::ILockAccessor(Core::System& system_)
-    : ServiceFramework{system_, "ILockAccessor"}, m_context{system_, "ILockAccessor"},
-      m_event{m_context} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {1, D<&ILockAccessor::TryLock>, "TryLock"},
-        {2, D<&ILockAccessor::Unlock>, "Unlock"},
-        {3, D<&ILockAccessor::GetEvent>, "GetEvent"},
-        {4, D<&ILockAccessor::IsLocked>, "IsLocked"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
-    m_event.Signal(system.Kernel());
-}
-
-ILockAccessor::~ILockAccessor() = default;
-
-Result ILockAccessor::TryLock(Out<bool> out_is_locked,
-                              OutCopyHandle<Kernel::KReadableEvent> out_handle,
-                              bool return_handle) {
-    LOG_INFO(Service_AM, "called, return_handle={}", return_handle);
-
-    {
-        std::scoped_lock lk{m_mutex};
-        if (m_is_locked) {
-            *out_is_locked = false;
-        } else {
-            m_is_locked = true;
-            *out_is_locked = true;
-        }
-    }
-
-    if (return_handle) {
-        *out_handle = m_event.GetHandle();
-    }
-
-    R_SUCCEED();
-}
-
-Result ILockAccessor::Unlock() {
-    LOG_INFO(Service_AM, "called");
-
-    {
-        std::scoped_lock lk{m_mutex};
-        m_is_locked = false;
-    }
-
-    m_event.Signal(system.Kernel());
-    R_SUCCEED();
-}
-
-Result ILockAccessor::GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_handle) {
-    LOG_INFO(Service_AM, "called");
-    *out_handle = m_event.GetHandle();
-    R_SUCCEED();
-}
-
-Result ILockAccessor::IsLocked(Out<bool> out_is_locked) {
-    LOG_INFO(Service_AM, "called");
-    std::scoped_lock lk{m_mutex};
-    *out_is_locked = m_is_locked;
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/lock_accessor.h

@@ -1,32 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/os/event.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-class ILockAccessor final : public ServiceFramework<ILockAccessor> {
-public:
-    explicit ILockAccessor(Core::System& system_);
-    ~ILockAccessor() override;
-
-private:
-    Result TryLock(Out<bool> out_is_locked, OutCopyHandle<Kernel::KReadableEvent> out_handle,
-                   bool return_handle);
-    Result Unlock();
-    Result GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_handle);
-    Result IsLocked(Out<bool> out_is_locked);
-
-private:
-    KernelHelpers::ServiceContext m_context;
-    Event m_event;
-    std::mutex m_mutex{};
-    bool m_is_locked{};
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/overlay_applet_proxy.cpp

@@ -1,120 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/am/service/common_state_getter.h"
-#include "core/hle/service/am/service/display_controller.h"
-#include "core/hle/service/am/service/global_state_controller.h"
-#include "core/hle/service/am/service/audio_controller.h"
-#include "core/hle/service/am/service/applet_common_functions.h"
-#include "core/hle/service/am/service/overlay_applet_proxy.h"
-#include "core/hle/service/am/service/library_applet_creator.h"
-#include "core/hle/service/am/service/process_winding_controller.h"
-#include "core/hle/service/am/service/self_controller.h"
-#include "core/hle/service/am/service/window_controller.h"
-#include "core/hle/service/am/service/debug_functions.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-    IOverlayAppletProxy::IOverlayAppletProxy(Core::System &system_, std::shared_ptr<Applet> applet,
-                                             Kernel::KProcess *process, WindowSystem &window_system)
-        : ServiceFramework{system_, "IOverlayAppletProxy"},
-          m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IOverlayAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
-        {1, D<&IOverlayAppletProxy::GetSelfController>, "GetSelfController"},
-        {2, D<&IOverlayAppletProxy::GetWindowController>, "GetWindowController"},
-        {3, D<&IOverlayAppletProxy::GetAudioController>, "GetAudioController"},
-        {4, D<&IOverlayAppletProxy::GetDisplayController>, "GetDisplayController"},
-        {10, D<&IOverlayAppletProxy::GetProcessWindingController>, "GetProcessWindingController"},
-        {11, D<&IOverlayAppletProxy::GetLibraryAppletCreator>, "GetLibraryAppletCreator"},
-        {20, D<&IOverlayAppletProxy::GetOverlayFunctions>, "GetOverlayFunctions"},
-        {21, D<&IOverlayAppletProxy::GetAppletCommonFunctions>, "GetAppletCommonFunctions"},
-        {23, D<&IOverlayAppletProxy::GetGlobalStateController>, "GetGlobalStateController"},
-        {1000, D<&IOverlayAppletProxy::GetDebugFunctions>, "GetDebugFunctions"},
-    };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-    IOverlayAppletProxy::~IOverlayAppletProxy() = default;
-
-    Result IOverlayAppletProxy::GetCommonStateGetter(
-        Out<SharedPointer<ICommonStateGetter> > out_common_state_getter) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_common_state_getter = std::make_shared<ICommonStateGetter>(system, m_applet);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetSelfController(
-        Out<SharedPointer<ISelfController> > out_self_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_self_controller = std::make_shared<ISelfController>(system, m_applet, m_process);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetWindowController(
-        Out<SharedPointer<IWindowController> > out_window_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_window_controller = std::make_shared<IWindowController>(system, m_applet, m_window_system);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetAudioController(
-        Out<SharedPointer<IAudioController> > out_audio_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_audio_controller = std::make_shared<IAudioController>(system);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetDisplayController(
-        Out<SharedPointer<IDisplayController> > out_display_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_display_controller = std::make_shared<IDisplayController>(system, m_applet);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetProcessWindingController(
-        Out<SharedPointer<IProcessWindingController> > out_process_winding_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_process_winding_controller = std::make_shared<IProcessWindingController>(system, m_applet);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetLibraryAppletCreator(
-        Out<SharedPointer<ILibraryAppletCreator> > out_library_applet_creator) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_library_applet_creator =
-                std::make_shared<ILibraryAppletCreator>(system, m_applet, m_window_system);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetOverlayFunctions(
-        Out<SharedPointer<IOverlayFunctions> > out_overlay_functions) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_overlay_functions = std::make_shared<IOverlayFunctions>(system, m_applet);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetAppletCommonFunctions(
-        Out<SharedPointer<IAppletCommonFunctions> > out_applet_common_functions) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_applet_common_functions = std::make_shared<IAppletCommonFunctions>(system, m_applet);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetGlobalStateController(
-        Out<SharedPointer<IGlobalStateController> > out_global_state_controller) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_global_state_controller = std::make_shared<IGlobalStateController>(system);
-        R_SUCCEED();
-    }
-
-    Result IOverlayAppletProxy::GetDebugFunctions(
-        Out<SharedPointer<IDebugFunctions> > out_debug_functions) {
-        LOG_DEBUG(Service_AM, "called");
-        *out_debug_functions = std::make_shared<IDebugFunctions>(system);
-        R_SUCCEED();
-    }
-} // namespace Service::AM

src/core/hle/service/am/service/overlay_applet_proxy.h

@@ -1,55 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden 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/am/service/overlay_functions.h"
-
-namespace Service::AM {
-
-struct Applet;
-class IAppletCommonFunctions;
-class IAudioController;
-class ICommonStateGetter;
-class IDebugFunctions;
-class IDisplayController;
-class IHomeMenuFunctions;
-class IGlobalStateController;
-class ILibraryAppletCreator;
-class ILibraryAppletSelfAccessor;
-class IProcessWindingController;
-class ISelfController;
-class IWindowController;
-class WindowSystem;
-
-class IOverlayAppletProxy final : public ServiceFramework<IOverlayAppletProxy> {
-public:
-    explicit IOverlayAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                                 Kernel::KProcess* process, WindowSystem& window_system);
-    ~IOverlayAppletProxy();
-
-private:
-    Result GetCommonStateGetter(Out<SharedPointer<ICommonStateGetter>> out_common_state_getter);
-    Result GetSelfController(Out<SharedPointer<ISelfController>> out_self_controller);
-    Result GetWindowController(Out<SharedPointer<IWindowController>> out_window_controller);
-    Result GetAudioController(Out<SharedPointer<IAudioController>> out_audio_controller);
-    Result GetDisplayController(Out<SharedPointer<IDisplayController>> out_display_controller);
-    Result GetProcessWindingController(
-        Out<SharedPointer<IProcessWindingController>> out_process_winding_controller);
-    Result GetLibraryAppletCreator(
-        Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator);
-    Result GetOverlayFunctions(Out<SharedPointer<IOverlayFunctions>> out_overlay_functions);
-    Result GetAppletCommonFunctions(
-        Out<SharedPointer<IAppletCommonFunctions>> out_applet_common_functions);
-    Result GetGlobalStateController(
-        Out<SharedPointer<IGlobalStateController>> out_global_state_controller);
-    Result GetDebugFunctions(Out<SharedPointer<IDebugFunctions>> out_debug_functions);
-
-    WindowSystem& m_window_system;
-    Kernel::KProcess* const m_process;
-    const std::shared_ptr<Applet> m_applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/overlay_functions.cpp

@@ -8,34 +8,34 @@
 #include "core/hle/service/am/window_system.h"
 
 namespace Service::AM {
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> IOverlayFunctions::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, D<&IOverlayFunctions::BeginToWatchShortHomeButtonMessage>, "BeginToWatchShortHomeButtonMessage"},
+            FunctionInfo{1, D<&IOverlayFunctions::EndToWatchShortHomeButtonMessage>, "EndToWatchShortHomeButtonMessage"},
+            FunctionInfo{2, D<&IOverlayFunctions::GetApplicationIdForLogo>, "GetApplicationIdForLogo"},
+            FunctionInfo{3, nullptr, "SetGpuTimeSliceBoost"},
+            FunctionInfo{4, D<&IOverlayFunctions::SetAutoSleepTimeAndDimmingTimeEnabled>, "SetAutoSleepTimeAndDimmingTimeEnabled"},
+            FunctionInfo{5, nullptr, "TerminateApplicationAndSetReason"},
+            FunctionInfo{6, nullptr, "SetScreenShotPermissionGlobally"},
+            FunctionInfo{10, nullptr, "StartShutdownSequenceForOverlay"},
+            FunctionInfo{11, nullptr, "StartRebootSequenceForOverlay"},
+            FunctionInfo{20, D<&IOverlayFunctions::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
+            FunctionInfo{21, D<&IOverlayFunctions::SetHandlingTouchScreenInputEnabled>, "SetHandlingTouchScreenInputEnabled"},
+            FunctionInfo{30, nullptr, "SetHealthWarningShowingState"},
+            FunctionInfo{31, D<&IOverlayFunctions::IsHealthWarningRequired>, "IsHealthWarningRequired"},
+            FunctionInfo{40, nullptr, "GetApplicationNintendoLogo"},
+            FunctionInfo{41, nullptr, "GetApplicationStartupMovie"},
+            FunctionInfo{50, nullptr, "SetGpuTimeSliceBoostForApplication"},
+            FunctionInfo{60, nullptr, "Unknown60"},
+            FunctionInfo{70, D<&IOverlayFunctions::Unknown70>, "Unknown70"},
+            FunctionInfo{90, nullptr, "SetRequiresGpuResourceUse"},
+            FunctionInfo{101, nullptr, "BeginToObserveHidInputForDevelop"}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+
     IOverlayFunctions::IOverlayFunctions(Core::System &system_, std::shared_ptr<Applet> applet)
         : ServiceFramework{system_, "IOverlayFunctions"}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IOverlayFunctions::BeginToWatchShortHomeButtonMessage>, "BeginToWatchShortHomeButtonMessage"},
-        {1, D<&IOverlayFunctions::EndToWatchShortHomeButtonMessage>, "EndToWatchShortHomeButtonMessage"},
-        {2, D<&IOverlayFunctions::GetApplicationIdForLogo>, "GetApplicationIdForLogo"},
-        {3, nullptr, "SetGpuTimeSliceBoost"},
-        {4, D<&IOverlayFunctions::SetAutoSleepTimeAndDimmingTimeEnabled>, "SetAutoSleepTimeAndDimmingTimeEnabled"},
-        {5, nullptr, "TerminateApplicationAndSetReason"},
-        {6, nullptr, "SetScreenShotPermissionGlobally"},
-        {10, nullptr, "StartShutdownSequenceForOverlay"},
-        {11, nullptr, "StartRebootSequenceForOverlay"},
-        {20, D<&IOverlayFunctions::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
-        {21, D<&IOverlayFunctions::SetHandlingTouchScreenInputEnabled>, "SetHandlingTouchScreenInputEnabled"},
-        {30, nullptr, "SetHealthWarningShowingState"},
-        {31, D<&IOverlayFunctions::IsHealthWarningRequired>, "IsHealthWarningRequired"},
-        {40, nullptr, "GetApplicationNintendoLogo"},
-        {41, nullptr, "GetApplicationStartupMovie"},
-        {50, nullptr, "SetGpuTimeSliceBoostForApplication"},
-        {60, nullptr, "Unknown60"},
-        {70, D<&IOverlayFunctions::Unknown70>, "Unknown70"},
-        {90, nullptr, "SetRequiresGpuResourceUse"},
-        {101, nullptr, "BeginToObserveHidInputForDevelop"},
-    };
-        // clang-format on
-
-        RegisterHandlers(functions);
     }
 
     IOverlayFunctions::~IOverlayFunctions() = default;

src/core/hle/service/am/service/overlay_functions.h

@@ -6,24 +6,25 @@
 #include "core/hle/service/service.h"
 
 namespace Service::AM {
-    struct Applet;
+struct Applet;
 
-    class IOverlayFunctions final : public ServiceFramework<IOverlayFunctions> {
-    public:
-        explicit IOverlayFunctions(Core::System &system_, std::shared_ptr<Applet> applet);
-        ~IOverlayFunctions() override;
+class IOverlayFunctions final : public ServiceFramework<IOverlayFunctions> {
+public:
+    explicit IOverlayFunctions(Core::System &system_, std::shared_ptr<Applet> applet);
+    ~IOverlayFunctions() override;
 
-    private:
-        Result BeginToWatchShortHomeButtonMessage();
-        Result EndToWatchShortHomeButtonMessage();
-        Result GetApplicationIdForLogo(Out<u64> out_application_id);
-        Result SetAutoSleepTimeAndDimmingTimeEnabled(bool enabled);
-        Result IsHealthWarningRequired(Out<bool> is_required);
-        Result SetHandlingHomeButtonShortPressedEnabled(bool enabled);
-        Result SetHandlingTouchScreenInputEnabled(bool enabled);
-        Result Unknown70();
+private:
+    Result BeginToWatchShortHomeButtonMessage();
+    Result EndToWatchShortHomeButtonMessage();
+    Result GetApplicationIdForLogo(Out<u64> out_application_id);
+    Result SetAutoSleepTimeAndDimmingTimeEnabled(bool enabled);
+    Result IsHealthWarningRequired(Out<bool> is_required);
+    Result SetHandlingHomeButtonShortPressedEnabled(bool enabled);
+    Result SetHandlingTouchScreenInputEnabled(bool enabled);
+    Result Unknown70();
 
-    private:
-        const std::shared_ptr<Applet> m_applet;
-    };
+private:
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
+    const std::shared_ptr<Applet> m_applet;
+};
 } // namespace Service::AM

src/core/hle/service/am/service/process_winding_controller.cpp

@@ -13,23 +13,23 @@
 
 namespace Service::AM {
 
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> IProcessWindingController::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, D<&IProcessWindingController::GetLaunchReason>, "GetLaunchReason"},
+            FunctionInfo{11, D<&IProcessWindingController::OpenCallingLibraryApplet>, "OpenCallingLibraryApplet"},
+            FunctionInfo{21, D<&IProcessWindingController::PushContext>, "PushContext"},
+            FunctionInfo{22, D<&IProcessWindingController::PopContext>, "PopContext"},
+            FunctionInfo{23, D<&IProcessWindingController::CancelWindingReservation>, "CancelWindingReservation"},
+            FunctionInfo{30, D<&IProcessWindingController::WindAndDoReserved>, "WindAndDoReserved"},
+            FunctionInfo{40, D<&IProcessWindingController::ReserveToStartAndWaitAndUnwindThis>, "ReserveToStartAndWaitAndUnwindThis"},
+            FunctionInfo{41, D<&IProcessWindingController::ReserveToStartAndWait>, "ReserveToStartAndWait"}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+
 IProcessWindingController::IProcessWindingController(Core::System& system_,
                                                      std::shared_ptr<Applet> applet)
     : ServiceFramework{system_, "IProcessWindingController"}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IProcessWindingController::GetLaunchReason>, "GetLaunchReason"},
-        {11, D<&IProcessWindingController::OpenCallingLibraryApplet>, "OpenCallingLibraryApplet"},
-        {21, D<&IProcessWindingController::PushContext>, "PushContext"},
-        {22, D<&IProcessWindingController::PopContext>, "PopContext"},
-        {23, D<&IProcessWindingController::CancelWindingReservation>, "CancelWindingReservation"},
-        {30, D<&IProcessWindingController::WindAndDoReserved>, "WindAndDoReserved"},
-        {40, D<&IProcessWindingController::ReserveToStartAndWaitAndUnwindThis>, "ReserveToStartAndWaitAndUnwindThis"},
-        {41, D<&IProcessWindingController::ReserveToStartAndWait>, "ReserveToStartAndWait"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IProcessWindingController::~IProcessWindingController() = default;

src/core/hle/service/am/service/process_winding_controller.h

@@ -33,6 +33,7 @@ private:
         SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
     Result ReserveToStartAndWait(SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     const std::shared_ptr<Applet> m_applet;
 };
 

src/core/hle/service/am/service/self_controller.cpp

@@ -17,67 +17,66 @@
 
 namespace Service::AM {
 
+    std::optional<ServiceFrameworkBase::FunctionInfoBase> ISelfController::FindRequest(u32 key) {
+        static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, D<&ISelfController::Exit>, "Exit"},
+            FunctionInfo{1, D<&ISelfController::LockExit>, "LockExit"},
+            FunctionInfo{2, D<&ISelfController::UnlockExit>, "UnlockExit"},
+            FunctionInfo{3, D<&ISelfController::EnterFatalSection>, "EnterFatalSection"},
+            FunctionInfo{4, D<&ISelfController::LeaveFatalSection>, "LeaveFatalSection"},
+            FunctionInfo{9, D<&ISelfController::GetLibraryAppletLaunchableEvent>, "GetLibraryAppletLaunchableEvent"},
+            FunctionInfo{10, D<&ISelfController::SetScreenShotPermission>, "SetScreenShotPermission"},
+            FunctionInfo{11, D<&ISelfController::SetOperationModeChangedNotification>, "SetOperationModeChangedNotification"},
+            FunctionInfo{12, D<&ISelfController::SetPerformanceModeChangedNotification>, "SetPerformanceModeChangedNotification"},
+            FunctionInfo{13, D<&ISelfController::SetFocusHandlingMode>, "SetFocusHandlingMode"},
+            FunctionInfo{14, D<&ISelfController::SetRestartMessageEnabled>, "SetRestartMessageEnabled"},
+            FunctionInfo{15, D<&ISelfController::SetScreenShotAppletIdentityInfo>, "SetScreenShotAppletIdentityInfo"},
+            FunctionInfo{16, D<&ISelfController::SetOutOfFocusSuspendingEnabled>, "SetOutOfFocusSuspendingEnabled"},
+            FunctionInfo{17, nullptr, "SetControllerFirmwareUpdateSection"},
+            FunctionInfo{18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
+            FunctionInfo{19, D<&ISelfController::SetAlbumImageOrientation>, "SetAlbumImageOrientation"},
+            FunctionInfo{20, nullptr, "SetDesirableKeyboardLayout"},
+            FunctionInfo{21, nullptr, "GetScreenShotProgramId"},
+            FunctionInfo{40, D<&ISelfController::CreateManagedDisplayLayer>, "CreateManagedDisplayLayer"},
+            FunctionInfo{41, D<&ISelfController::IsSystemBufferSharingEnabled>, "IsSystemBufferSharingEnabled"},
+            FunctionInfo{42, D<&ISelfController::GetSystemSharedLayerHandle>, "GetSystemSharedLayerHandle"},
+            FunctionInfo{43, D<&ISelfController::GetSystemSharedBufferHandle>, "GetSystemSharedBufferHandle"},
+            FunctionInfo{44, D<&ISelfController::CreateManagedDisplaySeparableLayer>, "CreateManagedDisplaySeparableLayer"},
+            FunctionInfo{45, nullptr, "SetManagedDisplayLayerSeparationMode"},
+            FunctionInfo{46, nullptr, "SetRecordingLayerCompositionEnabled"},
+            FunctionInfo{50, D<&ISelfController::SetHandlesRequestToDisplay>, "SetHandlesRequestToDisplay"},
+            FunctionInfo{51, D<&ISelfController::ApproveToDisplay>, "ApproveToDisplay"},
+            FunctionInfo{60, D<&ISelfController::OverrideAutoSleepTimeAndDimmingTime>, "OverrideAutoSleepTimeAndDimmingTime"},
+            FunctionInfo{61, D<&ISelfController::SetMediaPlaybackState>, "SetMediaPlaybackState"},
+            FunctionInfo{62, D<&ISelfController::SetIdleTimeDetectionExtension>, "SetIdleTimeDetectionExtension"},
+            FunctionInfo{63, D<&ISelfController::GetIdleTimeDetectionExtension>, "GetIdleTimeDetectionExtension"},
+            FunctionInfo{64, nullptr, "SetInputDetectionSourceSet"},
+            FunctionInfo{65, D<&ISelfController::ReportUserIsActive>, "ReportUserIsActive"},
+            FunctionInfo{66, nullptr, "GetCurrentIlluminance"},
+            FunctionInfo{67, D<&ISelfController::IsIlluminanceAvailable>, "IsIlluminanceAvailable"},
+            FunctionInfo{68, D<&ISelfController::SetAutoSleepDisabled>, "SetAutoSleepDisabled"},
+            FunctionInfo{69, D<&ISelfController::IsAutoSleepDisabled>, "IsAutoSleepDisabled"},
+            FunctionInfo{70, nullptr, "ReportMultimediaError"},
+            FunctionInfo{71, nullptr, "GetCurrentIlluminanceEx"},
+            FunctionInfo{72, D<&ISelfController::SetInputDetectionPolicy>, "SetInputDetectionPolicy"},
+            FunctionInfo{80, nullptr, "SetWirelessPriorityMode"},
+            FunctionInfo{90, D<&ISelfController::GetAccumulatedSuspendedTickValue>, "GetAccumulatedSuspendedTickValue"},
+            FunctionInfo{91, D<&ISelfController::GetAccumulatedSuspendedTickChangedEvent>, "GetAccumulatedSuspendedTickChangedEvent"},
+            FunctionInfo{100, D<&ISelfController::SetAlbumImageTakenNotificationEnabled>, "SetAlbumImageTakenNotificationEnabled"},
+            FunctionInfo{110, nullptr, "SetApplicationAlbumUserData"},
+            FunctionInfo{120, D<&ISelfController::SaveCurrentScreenshot>, "SaveCurrentScreenshot"},
+            FunctionInfo{130, D<&ISelfController::SetRecordVolumeMuted>, "SetRecordVolumeMuted"},
+            FunctionInfo{230, D<&ISelfController::Unknown230>, "Unknown230"},
+            FunctionInfo{240, D<&ISelfController::Unknown240>, "Unknown240"},
+            FunctionInfo{1000, nullptr, "GetDebugStorageChannel"}
+        );
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+
 ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet,
                                  Kernel::KProcess* process)
     : ServiceFramework{system_, "ISelfController"}, m_process{process}, m_applet{
                                                                             std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ISelfController::Exit>, "Exit"},
-        {1, D<&ISelfController::LockExit>, "LockExit"},
-        {2, D<&ISelfController::UnlockExit>, "UnlockExit"},
-        {3, D<&ISelfController::EnterFatalSection>, "EnterFatalSection"},
-        {4, D<&ISelfController::LeaveFatalSection>, "LeaveFatalSection"},
-        {9, D<&ISelfController::GetLibraryAppletLaunchableEvent>, "GetLibraryAppletLaunchableEvent"},
-        {10, D<&ISelfController::SetScreenShotPermission>, "SetScreenShotPermission"},
-        {11, D<&ISelfController::SetOperationModeChangedNotification>, "SetOperationModeChangedNotification"},
-        {12, D<&ISelfController::SetPerformanceModeChangedNotification>, "SetPerformanceModeChangedNotification"},
-        {13, D<&ISelfController::SetFocusHandlingMode>, "SetFocusHandlingMode"},
-        {14, D<&ISelfController::SetRestartMessageEnabled>, "SetRestartMessageEnabled"},
-        {15, D<&ISelfController::SetScreenShotAppletIdentityInfo>, "SetScreenShotAppletIdentityInfo"},
-        {16, D<&ISelfController::SetOutOfFocusSuspendingEnabled>, "SetOutOfFocusSuspendingEnabled"},
-        {17, nullptr, "SetControllerFirmwareUpdateSection"},
-        {18, nullptr, "SetRequiresCaptureButtonShortPressedMessage"},
-        {19, D<&ISelfController::SetAlbumImageOrientation>, "SetAlbumImageOrientation"},
-        {20, nullptr, "SetDesirableKeyboardLayout"},
-        {21, nullptr, "GetScreenShotProgramId"},
-        {40, D<&ISelfController::CreateManagedDisplayLayer>, "CreateManagedDisplayLayer"},
-        {41, D<&ISelfController::IsSystemBufferSharingEnabled>, "IsSystemBufferSharingEnabled"},
-        {42, D<&ISelfController::GetSystemSharedLayerHandle>, "GetSystemSharedLayerHandle"},
-        {43, D<&ISelfController::GetSystemSharedBufferHandle>, "GetSystemSharedBufferHandle"},
-        {44, D<&ISelfController::CreateManagedDisplaySeparableLayer>, "CreateManagedDisplaySeparableLayer"},
-        {45, nullptr, "SetManagedDisplayLayerSeparationMode"},
-        {46, nullptr, "SetRecordingLayerCompositionEnabled"},
-        {50, D<&ISelfController::SetHandlesRequestToDisplay>, "SetHandlesRequestToDisplay"},
-        {51, D<&ISelfController::ApproveToDisplay>, "ApproveToDisplay"},
-        {60, D<&ISelfController::OverrideAutoSleepTimeAndDimmingTime>, "OverrideAutoSleepTimeAndDimmingTime"},
-        {61, D<&ISelfController::SetMediaPlaybackState>, "SetMediaPlaybackState"},
-        {62, D<&ISelfController::SetIdleTimeDetectionExtension>, "SetIdleTimeDetectionExtension"},
-        {63, D<&ISelfController::GetIdleTimeDetectionExtension>, "GetIdleTimeDetectionExtension"},
-        {64, nullptr, "SetInputDetectionSourceSet"},
-        {65, D<&ISelfController::ReportUserIsActive>, "ReportUserIsActive"},
-        {66, nullptr, "GetCurrentIlluminance"},
-        {67, D<&ISelfController::IsIlluminanceAvailable>, "IsIlluminanceAvailable"},
-        {68, D<&ISelfController::SetAutoSleepDisabled>, "SetAutoSleepDisabled"},
-        {69, D<&ISelfController::IsAutoSleepDisabled>, "IsAutoSleepDisabled"},
-        {70, nullptr, "ReportMultimediaError"},
-        {71, nullptr, "GetCurrentIlluminanceEx"},
-        {72, D<&ISelfController::SetInputDetectionPolicy>, "SetInputDetectionPolicy"},
-        {80, nullptr, "SetWirelessPriorityMode"},
-        {90, D<&ISelfController::GetAccumulatedSuspendedTickValue>, "GetAccumulatedSuspendedTickValue"},
-        {91, D<&ISelfController::GetAccumulatedSuspendedTickChangedEvent>, "GetAccumulatedSuspendedTickChangedEvent"},
-        {100, D<&ISelfController::SetAlbumImageTakenNotificationEnabled>, "SetAlbumImageTakenNotificationEnabled"},
-        {110, nullptr, "SetApplicationAlbumUserData"},
-        {120, D<&ISelfController::SaveCurrentScreenshot>, "SaveCurrentScreenshot"},
-        {130, D<&ISelfController::SetRecordVolumeMuted>, "SetRecordVolumeMuted"},
-        {230, D<&ISelfController::Unknown230>, "Unknown230"},
-        {240, D<&ISelfController::Unknown240>, "Unknown240"},
-        {1000, nullptr, "GetDebugStorageChannel"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
     std::scoped_lock lk{m_applet->lock};
     m_applet->display_layer_manager.Initialize(system, m_process, m_applet->applet_id,
                                                m_applet->library_applet_mode);

src/core/hle/service/am/service/self_controller.h

@@ -70,6 +70,7 @@ private:
     Result Unknown230(u32 in_val, Out<u16> out_val);
     Result Unknown240(u32 in_val);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     Kernel::KProcess* const m_process;
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/am/service/storage.cpp

@@ -4,22 +4,86 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/service/am/am_results.h"
 #include "core/hle/service/am/library_applet_storage.h"
 #include "core/hle/service/am/service/storage.h"
-#include "core/hle/service/am/service/storage_accessor.h"
 #include "core/hle/service/cmif_serialization.h"
 
 namespace Service::AM {
 
+class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
+public:
+    explicit IStorageAccessor(Core::System& system_, std::shared_ptr<LibraryAppletStorage> impl) : ServiceFramework{system_, "IStorageAccessor"}, m_impl{std::move(impl)} {}
+    ~IStorageAccessor() override = default;
+
+    Result GetSize(Out<s64> out_size) {
+        LOG_DEBUG(Service_AM, "called");
+        *out_size = m_impl->GetSize();
+        R_SUCCEED();
+    }
+
+    Result Write(InBuffer<BufferAttr_HipcAutoSelect> buffer, s64 offset) {
+        LOG_DEBUG(Service_AM, "called, offset={} size={}", offset, buffer.size());
+        R_RETURN(m_impl->Write(offset, buffer.data(), buffer.size()));
+    }
+
+    Result Read(OutBuffer<BufferAttr_HipcAutoSelect> out_buffer, s64 offset) {
+        LOG_DEBUG(Service_AM, "called, offset={} size={}", offset, out_buffer.size());
+        R_RETURN(m_impl->Read(offset, out_buffer.data(), out_buffer.size()));
+    }
+
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IStorageAccessor::GetSize>, "GetSize"},
+        FunctionInfo{10, D<&IStorageAccessor::Write>, "Write"},
+        FunctionInfo{11, D<&IStorageAccessor::Read>, "Read"}
+    );
+
+    const std::shared_ptr<LibraryAppletStorage> m_impl;
+};
+
+class ITransferStorageAccessor final : public ServiceFramework<ITransferStorageAccessor> {
+public:
+    explicit ITransferStorageAccessor(Core::System& system_, std::shared_ptr<LibraryAppletStorage> impl) : ServiceFramework{system_, "ITransferStorageAccessor"}, m_impl{std::move(impl)} {}
+    ~ITransferStorageAccessor() override = default;
+
+    Result GetSize(Out<s64> out_size) {
+        LOG_DEBUG(Service_AM, "called");
+        *out_size = m_impl->GetSize();
+        R_SUCCEED();
+    }
+
+    Result GetHandle(Out<s64> out_size, OutCopyHandle<Kernel::KTransferMemory> out_handle) {
+        LOG_INFO(Service_AM, "called");
+        *out_size = m_impl->GetSize();
+        *out_handle = m_impl->GetHandle();
+        R_SUCCEED();
+    }
+
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&ITransferStorageAccessor::GetSize>, "GetSize"},
+        FunctionInfo{1, D<&ITransferStorageAccessor::GetHandle>, "GetHandle"}
+    );
+
+    const std::shared_ptr<LibraryAppletStorage> m_impl;
+};
+
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IStorage::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IStorage::Open>, "Open"},
+        FunctionInfo{1, D<&IStorage::OpenTransferStorage>, "OpenTransferStorage"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IStorage::IStorage(Core::System& system_, std::shared_ptr<LibraryAppletStorage> impl)
     : ServiceFramework{system_, "IStorage"}, m_impl{std::move(impl)} {
-    static const FunctionInfo functions[] = {
-        {0, D<&IStorage::Open>, "Open"},
-        {1, D<&IStorage::OpenTransferStorage>, "OpenTransferStorage"},
-    };
-
-    RegisterHandlers(functions);
 }
 
 IStorage::IStorage(Core::System& system_, std::vector<u8>&& data)

src/core/hle/service/am/service/storage.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,6 +32,7 @@ private:
     Result OpenTransferStorage(
         Out<SharedPointer<ITransferStorageAccessor>> out_transfer_storage_accessor);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     const std::shared_ptr<LibraryAppletStorage> m_impl;
 };
 

src/core/hle/service/am/service/storage_accessor.cpp

@@ -1,68 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/service/am/library_applet_storage.h"
-#include "core/hle/service/am/service/storage_accessor.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-IStorageAccessor::IStorageAccessor(Core::System& system_,
-                                   std::shared_ptr<LibraryAppletStorage> impl)
-    : ServiceFramework{system_, "IStorageAccessor"}, m_impl{std::move(impl)} {
-    static const FunctionInfo functions[] = {
-        {0, D<&IStorageAccessor::GetSize>, "GetSize"},
-        {10, D<&IStorageAccessor::Write>, "Write"},
-        {11, D<&IStorageAccessor::Read>, "Read"},
-    };
-
-    RegisterHandlers(functions);
-}
-
-IStorageAccessor::~IStorageAccessor() = default;
-
-Result IStorageAccessor::GetSize(Out<s64> out_size) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_size = m_impl->GetSize();
-    R_SUCCEED();
-}
-
-Result IStorageAccessor::Write(InBuffer<BufferAttr_HipcAutoSelect> buffer, s64 offset) {
-    LOG_DEBUG(Service_AM, "called, offset={} size={}", offset, buffer.size());
-    R_RETURN(m_impl->Write(offset, buffer.data(), buffer.size()));
-}
-
-Result IStorageAccessor::Read(OutBuffer<BufferAttr_HipcAutoSelect> out_buffer, s64 offset) {
-    LOG_DEBUG(Service_AM, "called, offset={} size={}", offset, out_buffer.size());
-    R_RETURN(m_impl->Read(offset, out_buffer.data(), out_buffer.size()));
-}
-
-ITransferStorageAccessor::ITransferStorageAccessor(Core::System& system_,
-                                                   std::shared_ptr<LibraryAppletStorage> impl)
-    : ServiceFramework{system_, "ITransferStorageAccessor"}, m_impl{std::move(impl)} {
-    static const FunctionInfo functions[] = {
-        {0, D<&ITransferStorageAccessor::GetSize>, "GetSize"},
-        {1, D<&ITransferStorageAccessor::GetHandle>, "GetHandle"},
-    };
-
-    RegisterHandlers(functions);
-}
-
-ITransferStorageAccessor::~ITransferStorageAccessor() = default;
-
-Result ITransferStorageAccessor::GetSize(Out<s64> out_size) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_size = m_impl->GetSize();
-    R_SUCCEED();
-}
-
-Result ITransferStorageAccessor::GetHandle(Out<s64> out_size,
-                                           OutCopyHandle<Kernel::KTransferMemory> out_handle) {
-    LOG_INFO(Service_AM, "called");
-    *out_size = m_impl->GetSize();
-    *out_handle = m_impl->GetHandle();
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/storage_accessor.h

@@ -1,38 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/am/library_applet_storage.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
-public:
-    explicit IStorageAccessor(Core::System& system_, std::shared_ptr<LibraryAppletStorage> impl);
-    ~IStorageAccessor() override;
-
-private:
-    Result GetSize(Out<s64> out_size);
-    Result Write(InBuffer<BufferAttr_HipcAutoSelect> buffer, s64 offset);
-    Result Read(OutBuffer<BufferAttr_HipcAutoSelect> out_buffer, s64 offset);
-
-    const std::shared_ptr<LibraryAppletStorage> m_impl;
-};
-
-class ITransferStorageAccessor final : public ServiceFramework<ITransferStorageAccessor> {
-public:
-    explicit ITransferStorageAccessor(Core::System& system_,
-                                      std::shared_ptr<LibraryAppletStorage> impl);
-    ~ITransferStorageAccessor() override;
-
-private:
-    Result GetSize(Out<s64> out_size);
-    Result GetHandle(Out<s64> out_size, OutCopyHandle<Kernel::KTransferMemory> out_handle);
-
-    const std::shared_ptr<LibraryAppletStorage> m_impl;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/system_applet_proxy.cpp

@@ -1,133 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/am/service/applet_common_functions.h"
-#include "core/hle/service/am/service/application_creator.h"
-#include "core/hle/service/am/service/audio_controller.h"
-#include "core/hle/service/am/service/common_state_getter.h"
-#include "core/hle/service/am/service/debug_functions.h"
-#include "core/hle/service/am/service/display_controller.h"
-#include "core/hle/service/am/service/global_state_controller.h"
-#include "core/hle/service/am/service/home_menu_functions.h"
-#include "core/hle/service/am/service/library_applet_creator.h"
-#include "core/hle/service/am/service/process_winding_controller.h"
-#include "core/hle/service/am/service/self_controller.h"
-#include "core/hle/service/am/service/system_applet_proxy.h"
-#include "core/hle/service/am/service/window_controller.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AM {
-
-ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
-                                       Kernel::KProcess* process, WindowSystem& window_system)
-    : ServiceFramework{system_, "ISystemAppletProxy"},
-      m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
-        {1, D<&ISystemAppletProxy::GetSelfController>, "GetSelfController"},
-        {2, D<&ISystemAppletProxy::GetWindowController>, "GetWindowController"},
-        {3, D<&ISystemAppletProxy::GetAudioController>, "GetAudioController"},
-        {4, D<&ISystemAppletProxy::GetDisplayController>, "GetDisplayController"},
-        {10, D<&ISystemAppletProxy::GetProcessWindingController>, "GetProcessWindingController"},
-        {11, D<&ISystemAppletProxy::GetLibraryAppletCreator>, "GetLibraryAppletCreator"},
-        {20, D<&ISystemAppletProxy::GetHomeMenuFunctions>, "GetHomeMenuFunctions"},
-        {21, D<&ISystemAppletProxy::GetGlobalStateController>, "GetGlobalStateController"},
-        {22, D<&ISystemAppletProxy::GetApplicationCreator>, "GetApplicationCreator"},
-        {23, D<&ISystemAppletProxy::GetAppletCommonFunctions>, "GetAppletCommonFunctions"},
-        {1000, D<&ISystemAppletProxy::GetDebugFunctions>, "GetDebugFunctions"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-ISystemAppletProxy::~ISystemAppletProxy() = default;
-
-Result ISystemAppletProxy::GetAudioController(
-    Out<SharedPointer<IAudioController>> out_audio_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_audio_controller = std::make_shared<IAudioController>(system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetDisplayController(
-    Out<SharedPointer<IDisplayController>> out_display_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_display_controller = std::make_shared<IDisplayController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetProcessWindingController(
-    Out<SharedPointer<IProcessWindingController>> out_process_winding_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_process_winding_controller = std::make_shared<IProcessWindingController>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetDebugFunctions(
-    Out<SharedPointer<IDebugFunctions>> out_debug_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_debug_functions = std::make_shared<IDebugFunctions>(system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetWindowController(
-    Out<SharedPointer<IWindowController>> out_window_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_window_controller = std::make_shared<IWindowController>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetSelfController(
-    Out<SharedPointer<ISelfController>> out_self_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_self_controller = std::make_shared<ISelfController>(system, m_applet, m_process);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetCommonStateGetter(
-    Out<SharedPointer<ICommonStateGetter>> out_common_state_getter) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_common_state_getter = std::make_shared<ICommonStateGetter>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetLibraryAppletCreator(
-    Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_library_applet_creator =
-        std::make_shared<ILibraryAppletCreator>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetApplicationCreator(
-    Out<SharedPointer<IApplicationCreator>> out_application_creator) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_application_creator = std::make_shared<IApplicationCreator>(system, m_window_system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetAppletCommonFunctions(
-    Out<SharedPointer<IAppletCommonFunctions>> out_applet_common_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_applet_common_functions = std::make_shared<IAppletCommonFunctions>(system, m_applet);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetHomeMenuFunctions(
-    Out<SharedPointer<IHomeMenuFunctions>> out_home_menu_functions) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_home_menu_functions =
-        std::make_shared<IHomeMenuFunctions>(system, m_applet, m_window_system);
-    R_SUCCEED();
-}
-
-Result ISystemAppletProxy::GetGlobalStateController(
-    Out<SharedPointer<IGlobalStateController>> out_global_state_controller) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_global_state_controller = std::make_shared<IGlobalStateController>(system);
-    R_SUCCEED();
-}
-
-} // namespace Service::AM

src/core/hle/service/am/service/system_applet_proxy.h

@@ -1,58 +0,0 @@
-// 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-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-struct Applet;
-class IAppletCommonFunctions;
-class IApplicationCreator;
-class IAudioController;
-class ICommonStateGetter;
-class IDebugFunctions;
-class IDisplayController;
-class IHomeMenuFunctions;
-class IGlobalStateController;
-class ILibraryAppletCreator;
-class IProcessWindingController;
-class ISelfController;
-class IWindowController;
-class WindowSystem;
-
-class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
-public:
-    explicit ISystemAppletProxy(Core::System& system, std::shared_ptr<Applet> applet,
-                                Kernel::KProcess* process, WindowSystem& window_system);
-    ~ISystemAppletProxy();
-
-private:
-    Result GetCommonStateGetter(Out<SharedPointer<ICommonStateGetter>> out_common_state_getter);
-    Result GetSelfController(Out<SharedPointer<ISelfController>> out_self_controller);
-    Result GetWindowController(Out<SharedPointer<IWindowController>> out_window_controller);
-    Result GetAudioController(Out<SharedPointer<IAudioController>> out_audio_controller);
-    Result GetDisplayController(Out<SharedPointer<IDisplayController>> out_display_controller);
-    Result GetProcessWindingController(
-        Out<SharedPointer<IProcessWindingController>> out_process_winding_controller);
-    Result GetDebugFunctions(Out<SharedPointer<IDebugFunctions>> out_debug_functions);
-    Result GetLibraryAppletCreator(
-        Out<SharedPointer<ILibraryAppletCreator>> out_library_applet_creator);
-    Result GetApplicationCreator(Out<SharedPointer<IApplicationCreator>> out_application_creator);
-    Result GetAppletCommonFunctions(
-        Out<SharedPointer<IAppletCommonFunctions>> out_applet_common_functions);
-    Result GetHomeMenuFunctions(Out<SharedPointer<IHomeMenuFunctions>> out_home_menu_functions);
-    Result GetGlobalStateController(
-        Out<SharedPointer<IGlobalStateController>> out_global_state_controller);
-
-    WindowSystem& m_window_system;
-    Kernel::KProcess* const m_process;
-    const std::shared_ptr<Applet> m_applet;
-};
-
-} // namespace Service::AM

src/core/hle/service/am/service/window_controller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,24 +12,24 @@
 
 namespace Service::AM {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IWindowController::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, nullptr, "CreateWindow"},
+        FunctionInfo{1,  D<&IWindowController::GetAppletResourceUserId>, "GetAppletResourceUserId"},
+        FunctionInfo{2,  D<&IWindowController::GetAppletResourceUserIdOfCallerApplet>, "GetAppletResourceUserIdOfCallerApplet"},
+        FunctionInfo{10, D<&IWindowController::AcquireForegroundRights>, "AcquireForegroundRights"},
+        FunctionInfo{11, D<&IWindowController::ReleaseForegroundRights>, "ReleaseForegroundRights"},
+        FunctionInfo{12, D<&IWindowController::RejectToChangeIntoBackground>, "RejectToChangeIntoBackground"},
+        FunctionInfo{20, D<&IWindowController::SetAppletWindowVisibility>, "SetAppletWindowVisibility"},
+        FunctionInfo{21, D<&IWindowController::SetAppletGpuTimeSlice>, "SetAppletGpuTimeSlice"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet,
                                      WindowSystem& window_system)
     : ServiceFramework{system_, "IWindowController"},
       m_window_system{window_system}, m_applet{std::move(applet)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CreateWindow"},
-        {1,  D<&IWindowController::GetAppletResourceUserId>, "GetAppletResourceUserId"},
-        {2,  D<&IWindowController::GetAppletResourceUserIdOfCallerApplet>, "GetAppletResourceUserIdOfCallerApplet"},
-        {10, D<&IWindowController::AcquireForegroundRights>, "AcquireForegroundRights"},
-        {11, D<&IWindowController::ReleaseForegroundRights>, "ReleaseForegroundRights"},
-        {12, D<&IWindowController::RejectToChangeIntoBackground>, "RejectToChangeIntoBackground"},
-        {20, D<&IWindowController::SetAppletWindowVisibility>, "SetAppletWindowVisibility"},
-        {21, D<&IWindowController::SetAppletGpuTimeSlice>, "SetAppletGpuTimeSlice"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 IWindowController::~IWindowController() = default;

src/core/hle/service/am/service/window_controller.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -26,6 +29,7 @@ private:
     Result SetAppletWindowVisibility(bool visible);
     Result SetAppletGpuTimeSlice(s64 time_slice);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     WindowSystem& m_window_system;
     const std::shared_ptr<Applet> m_applet;
 };

src/core/hle/service/aoc/addon_content_manager.cpp

@@ -28,6 +28,34 @@
 
 namespace Service::AOC {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IAddOnContentManager::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, nullptr, "CountAddOnContentByApplicationId"},
+        FunctionInfo{1, nullptr, "ListAddOnContentByApplicationId"},
+        FunctionInfo{2, D<&IAddOnContentManager::CountAddOnContent>, "CountAddOnContent"},
+        FunctionInfo{3, D<&IAddOnContentManager::ListAddOnContent>, "ListAddOnContent"},
+        FunctionInfo{4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
+        FunctionInfo{5, D<&IAddOnContentManager::GetAddOnContentBaseId>, "GetAddOnContentBaseId"},
+        FunctionInfo{6, nullptr, "PrepareAddOnContentByApplicationId"},
+        FunctionInfo{7, D<&IAddOnContentManager::PrepareAddOnContent>, "PrepareAddOnContent"},
+        FunctionInfo{8, D<&IAddOnContentManager::GetAddOnContentListChangedEvent>, "GetAddOnContentListChangedEvent"},
+        FunctionInfo{9, nullptr, "GetAddOnContentLostErrorCode"},
+        FunctionInfo{10, D<&IAddOnContentManager::GetAddOnContentListChangedEventWithProcessId>, "GetAddOnContentListChangedEventWithProcessId"},
+        FunctionInfo{11, D<&IAddOnContentManager::NotifyMountAddOnContent>, "NotifyMountAddOnContent"},
+        FunctionInfo{12, D<&IAddOnContentManager::NotifyUnmountAddOnContent>, "NotifyUnmountAddOnContent"},
+        FunctionInfo{13, nullptr, "IsAddOnContentMountedForDebug"},
+        FunctionInfo{50, D<&IAddOnContentManager::CheckAddOnContentMountStatus>, "CheckAddOnContentMountStatus"},
+        FunctionInfo{100, D<&IAddOnContentManager::CreateEcPurchasedEventManager>, "CreateEcPurchasedEventManager"},
+        FunctionInfo{101, D<&IAddOnContentManager::CreatePermanentEcPurchasedEventManager>, "CreatePermanentEcPurchasedEventManager"},
+        FunctionInfo{110, nullptr, "CreateContentsServiceManager"},
+        FunctionInfo{200, nullptr, "SetRequiredAddOnContentsOnContentsAvailabilityTransition"},
+        FunctionInfo{300, nullptr, "SetupHostAddOnContent"},
+        FunctionInfo{301, nullptr, "GetRegisteredAddOnContentPath"},
+        FunctionInfo{302, nullptr, "UpdateCachedList"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
     return FileSys::GetBaseTitleID(title_id) == base;
 }
@@ -57,35 +85,6 @@ static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
 IAddOnContentManager::IAddOnContentManager(Core::System& system_)
     : ServiceFramework{system_, "aoc:u"}, add_on_content{AccumulateAOCTitleIDs(system)},
       service_context{system_, "aoc:u"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CountAddOnContentByApplicationId"},
-        {1, nullptr, "ListAddOnContentByApplicationId"},
-        {2, D<&IAddOnContentManager::CountAddOnContent>, "CountAddOnContent"},
-        {3, D<&IAddOnContentManager::ListAddOnContent>, "ListAddOnContent"},
-        {4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
-        {5, D<&IAddOnContentManager::GetAddOnContentBaseId>, "GetAddOnContentBaseId"},
-        {6, nullptr, "PrepareAddOnContentByApplicationId"},
-        {7, D<&IAddOnContentManager::PrepareAddOnContent>, "PrepareAddOnContent"},
-        {8, D<&IAddOnContentManager::GetAddOnContentListChangedEvent>, "GetAddOnContentListChangedEvent"},
-        {9, nullptr, "GetAddOnContentLostErrorCode"},
-        {10, D<&IAddOnContentManager::GetAddOnContentListChangedEventWithProcessId>, "GetAddOnContentListChangedEventWithProcessId"},
-        {11, D<&IAddOnContentManager::NotifyMountAddOnContent>, "NotifyMountAddOnContent"},
-        {12, D<&IAddOnContentManager::NotifyUnmountAddOnContent>, "NotifyUnmountAddOnContent"},
-        {13, nullptr, "IsAddOnContentMountedForDebug"},
-        {50, D<&IAddOnContentManager::CheckAddOnContentMountStatus>, "CheckAddOnContentMountStatus"},
-        {100, D<&IAddOnContentManager::CreateEcPurchasedEventManager>, "CreateEcPurchasedEventManager"},
-        {101, D<&IAddOnContentManager::CreatePermanentEcPurchasedEventManager>, "CreatePermanentEcPurchasedEventManager"},
-        {110, nullptr, "CreateContentsServiceManager"},
-        {200, nullptr, "SetRequiredAddOnContentsOnContentsAvailabilityTransition"},
-        {300, nullptr, "SetupHostAddOnContent"},
-        {301, nullptr, "GetRegisteredAddOnContentPath"},
-        {302, nullptr, "UpdateCachedList"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
     aoc_change_event = service_context.CreateEvent("GetAddOnContentListChanged:Event");
 }
 

src/core/hle/service/aoc/addon_content_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -40,9 +43,9 @@ public:
         OutInterface<IPurchaseEventManager> out_interface);
 
 private:
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     std::vector<u64> add_on_content;
     KernelHelpers::ServiceContext service_context;
-
     Kernel::KEvent* aoc_change_event;
 };
 

src/core/hle/service/aoc/purchase_event_manager.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,21 +11,20 @@ namespace Service::AOC {
 
 constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IPurchaseEventManager::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
+        FunctionInfo{1, D<&IPurchaseEventManager::SetDeliveryTarget>, "SetDeliveryTarget"},
+        FunctionInfo{2, D<&IPurchaseEventManager::GetPurchasedEvent>, "GetPurchasedEvent"},
+        FunctionInfo{3, D<&IPurchaseEventManager::PopPurchasedProductInfo>, "PopPurchasedProductInfo"},
+        FunctionInfo{4, D<&IPurchaseEventManager::PopPurchasedProductInfoWithUid>, "PopPurchasedProductInfoWithUid"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
-    : ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
-                                                                          "IPurchaseEventManager"} {
-    // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
-            {1, D<&IPurchaseEventManager::SetDeliveryTarget>, "SetDeliveryTarget"},
-            {2, D<&IPurchaseEventManager::GetPurchasedEvent>, "GetPurchasedEvent"},
-            {3, D<&IPurchaseEventManager::PopPurchasedProductInfo>, "PopPurchasedProductInfo"},
-            {4, D<&IPurchaseEventManager::PopPurchasedProductInfoWithUid>, "PopPurchasedProductInfoWithUid"},
-        };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
+    : ServiceFramework{system_, "IPurchaseEventManager"}
+    , service_context{system, "IPurchaseEventManager"} {
     purchased_event = service_context.CreateEvent("IPurchaseEventManager:PurchasedEvent");
 }
 

src/core/hle/service/aoc/purchase_event_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -22,6 +25,8 @@ public:
     Result PopPurchasedProductInfo();
     Result PopPurchasedProductInfoWithUid();
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
+
 private:
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* purchased_event;

src/core/hle/service/apm/apm_interface.cpp

@@ -14,15 +14,7 @@ namespace Service::APM {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
-    explicit ISession(Core::System& system_, Controller& controller_)
-        : ServiceFramework{system_, "ISession"}, controller{controller_} {
-        static const FunctionInfo functions[] = {
-            {0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
-            {1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
-            {2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"},
-        };
-        RegisterHandlers(functions);
-    }
+    explicit ISession(Core::System& system_, Controller& controller_) : ServiceFramework{system_, "ISession"}, controller{controller_} {}
 
 private:
     void SetPerformanceConfiguration(HLERequestContext& ctx) {
@@ -61,18 +53,20 @@ private:
         rb.Push(ResultSuccess);
     }
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
+        FunctionInfo{1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
+        FunctionInfo{2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"}
+    );
     Controller& controller;
 };
 
 APM::APM(Core::System& system_, std::shared_ptr<Module> apm_, Controller& controller_,
          const char* name)
     : ServiceFramework{system_, name}, apm(std::move(apm_)), controller{controller_} {
-    static const FunctionInfo functions[] = {
-        {0, &APM::OpenSession, "OpenSession"},
-        {1, &APM::GetPerformanceMode, "GetPerformanceMode"},
-        {6, &APM::IsCpuOverclockEnabled, "IsCpuOverclockEnabled"},
-    };
-    RegisterHandlers(functions);
 }
 
 APM::~APM() = default;
@@ -102,20 +96,6 @@ void APM::IsCpuOverclockEnabled(HLERequestContext& ctx) {
 
 APM_Sys::APM_Sys(Core::System& system_, Controller& controller_)
     : ServiceFramework{system_, "apm:sys"}, controller{controller_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestPerformanceMode"},
-        {1, &APM_Sys::GetPerformanceEvent, "GetPerformanceEvent"},
-        {2, nullptr, "GetThrottlingState"},
-        {3, nullptr, "GetLastThrottlingState"},
-        {4, nullptr, "ClearLastThrottlingState"},
-        {5, nullptr, "LoadAndApplySettings"},
-        {6, &APM_Sys::SetCpuBoostMode, "SetCpuBoostMode"},
-        {7, &APM_Sys::GetCurrentPerformanceConfiguration, "GetCurrentPerformanceConfiguration"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
 }
 
 APM_Sys::~APM_Sys() = default;

src/core/hle/service/apm/apm_interface.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -21,6 +24,14 @@ private:
     void GetPerformanceMode(HLERequestContext& ctx);
     void IsCpuOverclockEnabled(HLERequestContext& ctx);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, &APM::OpenSession, "OpenSession"},
+        FunctionInfo{1, &APM::GetPerformanceMode, "GetPerformanceMode"},
+        FunctionInfo{6, &APM::IsCpuOverclockEnabled, "IsCpuOverclockEnabled"}
+    );
     std::shared_ptr<Module> apm;
     Controller& controller;
 };
@@ -36,6 +47,19 @@ private:
     void GetPerformanceEvent(HLERequestContext& ctx);
     void GetCurrentPerformanceConfiguration(HLERequestContext& ctx);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
+    }
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, nullptr, "RequestPerformanceMode"},
+        FunctionInfo{1, &APM_Sys::GetPerformanceEvent, "GetPerformanceEvent"},
+        FunctionInfo{2, nullptr, "GetThrottlingState"},
+        FunctionInfo{3, nullptr, "GetLastThrottlingState"},
+        FunctionInfo{4, nullptr, "ClearLastThrottlingState"},
+        FunctionInfo{5, nullptr, "LoadAndApplySettings"},
+        FunctionInfo{6, &APM_Sys::SetCpuBoostMode, "SetCpuBoostMode"},
+        FunctionInfo{7, &APM_Sys::GetCurrentPerformanceConfiguration, "GetCurrentPerformanceConfiguration"}
+    );
     Controller& controller;
 };
 

src/core/hle/service/audio/audio.cpp

@@ -21,164 +21,164 @@ namespace Service::Audio {
 class IAudioOutManagerForApplet final : public ServiceFramework<IAudioOutManagerForApplet> {
 public:
     explicit IAudioOutManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audout:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-            {2, nullptr, "GetProcessMasterVolume"},
-            {3, nullptr, "SetProcessMasterVolume"},
-            {4, nullptr, "GetProcessRecordVolume"},
-            {5, nullptr, "SetProcessRecordVolume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audout:a"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"},
+            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
+            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
+            FunctionInfo{4, nullptr, "GetProcessRecordVolume"},
+            FunctionInfo{5, nullptr, "SetProcessRecordVolume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioSnoopManager final : public ServiceFramework<IAudioSnoopManager> {
 public:
     explicit IAudioSnoopManager(Core::System& system_)
-        : ServiceFramework{system_, "auddev"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetDspStatistics"},
-            {1, nullptr, "GetAppletStateSummaries"},
-            {2, nullptr, "SetDspStatisticsParameter"},
-            {3, nullptr, "GetDspStatisticsParameter"},
-            {6, nullptr, "GetDspUsage"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "auddev"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "GetDspStatistics"},
+            FunctionInfo{1, nullptr, "GetAppletStateSummaries"},
+            FunctionInfo{2, nullptr, "SetDspStatisticsParameter"},
+            FunctionInfo{3, nullptr, "GetDspStatisticsParameter"},
+            FunctionInfo{6, nullptr, "GetDspUsage"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioInManagerForApplet final : public ServiceFramework<IAudioInManagerForApplet> {
 public:
     explicit IAudioInManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audin:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-            {2, nullptr, "GetProcessMasterVolume"},
-            {3, nullptr, "SetProcessMasterVolume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audin:a"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"},
+            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
+            FunctionInfo{3, nullptr, "SetProcessMasterVolume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioRendererManagerForApplet final : public ServiceFramework<IAudioRendererManagerForApplet> {
 public:
     explicit IAudioRendererManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audren:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-            {2, nullptr, "GetProcessMasterVolume"},
-            {3, nullptr, "SetProcessMasterVolume"},
-            {4, nullptr, "RegisterAppletResourceUserId"},
-            {5, nullptr, "UnregisterAppletResourceUserId"},
-            {6, nullptr, "GetProcessRecordVolume"},
-            {7, nullptr, "SetProcessRecordVolume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audren:a"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"},
+            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
+            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
+            FunctionInfo{4, nullptr, "RegisterAppletResourceUserId"},
+            FunctionInfo{5, nullptr, "UnregisterAppletResourceUserId"},
+            FunctionInfo{6, nullptr, "GetProcessRecordVolume"},
+            FunctionInfo{7, nullptr, "SetProcessRecordVolume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioOutManagerForDebugger final : public ServiceFramework<IAudioOutManagerForDebugger> {
 public:
     explicit IAudioOutManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audout:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audout:d"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioInManagerForDebugger final : public ServiceFramework<IAudioInManagerForDebugger> {
 public:
     explicit IAudioInManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audin:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audin:d"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IFinalOutputRecorderManagerForDebugger final : public ServiceFramework<IFinalOutputRecorderManagerForDebugger> {
 public:
     explicit IFinalOutputRecorderManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audrec:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audrec:d"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioRendererManagerForDebugger final : public ServiceFramework<IAudioRendererManagerForDebugger> {
 public:
     explicit IAudioRendererManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audren:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audren:d"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioSystemManagerForApplet final : public ServiceFramework<IAudioSystemManagerForApplet> {
 public:
     explicit IAudioSystemManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "aud:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RegisterAppletResourceUserId"},
-            {1, nullptr, "UnregisterAppletResourceUserId"},
-            {2, nullptr, "RequestSuspendAudio"},
-            {3, nullptr, "RequestResumeAudio"},
-            {4, nullptr, "GetAudioOutputProcessMasterVolume"},
-            {5, nullptr, "SetAudioOutputProcessMasterVolume"},
-            {6, nullptr, "GetAudioInputProcessMasterVolume"},
-            {7, nullptr, "SetAudioInputProcessMasterVolume"},
-            {8, nullptr, "GetAudioOutputProcessRecordVolume"},
-            {9, nullptr, "SetAudioOutputProcessRecordVolume"},
-            {10, nullptr, "GetAppletStateSummaries"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "aud:a"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RegisterAppletResourceUserId"},
+            FunctionInfo{1, nullptr, "UnregisterAppletResourceUserId"},
+            FunctionInfo{2, nullptr, "RequestSuspendAudio"},
+            FunctionInfo{3, nullptr, "RequestResumeAudio"},
+            FunctionInfo{4, nullptr, "GetAudioOutputProcessMasterVolume"},
+            FunctionInfo{5, nullptr, "SetAudioOutputProcessMasterVolume"},
+            FunctionInfo{6, nullptr, "GetAudioInputProcessMasterVolume"},
+            FunctionInfo{7, nullptr, "SetAudioInputProcessMasterVolume"},
+            FunctionInfo{8, nullptr, "GetAudioOutputProcessRecordVolume"},
+            FunctionInfo{9, nullptr, "SetAudioOutputProcessRecordVolume"},
+            FunctionInfo{10, nullptr, "GetAppletStateSummaries"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 
 class IAudioSystemManagerForDebugger final : public ServiceFramework<IAudioSystemManagerForDebugger> {
 public:
     explicit IAudioSystemManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "aud:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspendAudioForDebug"},
-            {1, nullptr, "RequestResumeAudioForDebug"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "aud:d"} {}
+
+    static constexpr auto functions = CreateStaticMap(
+            FunctionInfo{0, nullptr, "RequestSuspendAudioForDebug"},
+            FunctionInfo{1, nullptr, "RequestResumeAudioForDebug"}
+        );
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key, functions);
     }
 };
 

src/core/hle/service/audio/audio_controller.cpp

@@ -1,7 +1,7 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -20,77 +20,75 @@
 
 namespace Service::Audio {
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioController::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IAudioController::GetTargetVolume>, "GetTargetVolume"},
+        FunctionInfo{1, D<&IAudioController::SetTargetVolume>, "SetTargetVolume"},
+        FunctionInfo{2, D<&IAudioController::GetTargetVolumeMin>, "GetTargetVolumeMin"},
+        FunctionInfo{3, D<&IAudioController::GetTargetVolumeMax>, "GetTargetVolumeMax"},
+        FunctionInfo{4, D<&IAudioController::IsTargetMute>, "IsTargetMute"},
+        FunctionInfo{5, D<&IAudioController::SetTargetMute>, "SetTargetMute"},
+        FunctionInfo{6, nullptr, "IsTargetConnected", MakeVersionGate({20,0,0})},
+        FunctionInfo{7, nullptr, "SetDefaultTarget"},
+        FunctionInfo{8, nullptr, "GetDefaultTarget"},
+        FunctionInfo{9, D<&IAudioController::GetAudioOutputMode>, "GetAudioOutputMode"},
+        FunctionInfo{10, D<&IAudioController::SetAudioOutputMode>, "SetAudioOutputMode"},
+        FunctionInfo{11, nullptr, "SetForceMutePolicy"},
+        FunctionInfo{12, D<&IAudioController::GetForceMutePolicy>, "GetForceMutePolicy"},
+        FunctionInfo{13, D<&IAudioController::GetOutputModeSetting>, "GetOutputModeSetting"},
+        FunctionInfo{14, D<&IAudioController::SetOutputModeSetting>, "SetOutputModeSetting"},
+        FunctionInfo{15, nullptr, "SetOutputTarget"},
+        FunctionInfo{16, nullptr, "SetInputTargetForceEnabled"},
+        FunctionInfo{17, D<&IAudioController::SetHeadphoneOutputLevelMode>, "SetHeadphoneOutputLevelMode"},
+        FunctionInfo{18, D<&IAudioController::GetHeadphoneOutputLevelMode>, "GetHeadphoneOutputLevelMode"},
+        FunctionInfo{19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
+        FunctionInfo{20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
+        FunctionInfo{21, nullptr, "GetAudioOutputTargetForPlayReport"},
+        FunctionInfo{22, D<&IAudioController::NotifyHeadphoneVolumeWarningDisplayedEvent>, "NotifyHeadphoneVolumeWarningDisplayedEvent"},
+        FunctionInfo{23, nullptr, "SetSystemOutputMasterVolume"},
+        FunctionInfo{24, nullptr, "GetSystemOutputMasterVolume"},
+        FunctionInfo{25, nullptr, "GetAudioVolumeDataForPlayReport"},
+        FunctionInfo{26, nullptr, "UpdateHeadphoneSettings"},
+        FunctionInfo{27, nullptr, "SetVolumeMappingTableForDev"},
+        FunctionInfo{28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
+        FunctionInfo{29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
+        FunctionInfo{30, D<&IAudioController::SetSpeakerAutoMuteEnabled>, "SetSpeakerAutoMuteEnabled"},
+        FunctionInfo{31, D<&IAudioController::IsSpeakerAutoMuteEnabled>, "IsSpeakerAutoMuteEnabled"},
+        FunctionInfo{32, D<&IAudioController::GetActiveOutputTarget>, "GetActiveOutputTarget"},
+        FunctionInfo{33, nullptr, "GetTargetDeviceInfo"},
+        FunctionInfo{34, D<&IAudioController::AcquireTargetNotification>, "AcquireTargetNotification"},
+        FunctionInfo{35, nullptr, "SetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
+        FunctionInfo{36, nullptr, "GetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
+        FunctionInfo{37, nullptr, "SetHearingProtectionSafeguardEnabled"},
+        FunctionInfo{38, nullptr, "IsHearingProtectionSafeguardEnabled"},
+        FunctionInfo{39, nullptr, "IsHearingProtectionSafeguardMonitoringOutputForDebug"},
+        FunctionInfo{40, nullptr, "GetSystemInformationForDebug"},
+        FunctionInfo{41, nullptr, "SetVolumeButtonLongPressTime"},
+        FunctionInfo{42, nullptr, "SetNativeVolumeForDebug"},
+        FunctionInfo{43, nullptr, "Unknown43", MakeVersionGate({21,0,0})},
+        FunctionInfo{5000, D<&IAudioController::Unknown5000>, "Unknown5000", MakeVersionGate({19,0,0})},
+        FunctionInfo{10000, nullptr, "NotifyAudioOutputTargetForPlayReport"},
+        FunctionInfo{10001, nullptr, "NotifyAudioOutputChannelCountForPlayReport"},
+        FunctionInfo{10002, nullptr, "NotifyUnsupportedUsbOutputDeviceAttachedForPlayReport"},
+        FunctionInfo{10100, nullptr, "GetAudioVolumeDataForPlayReport"},
+        FunctionInfo{10101, nullptr, "BindAudioVolumeUpdateEventForPlayReport"},
+        FunctionInfo{10102, nullptr, "BindAudioOutputTargetUpdateEventForPlayReport"},
+        FunctionInfo{10103, nullptr, "GetAudioOutputTargetForPlayReport"},
+        FunctionInfo{10104, nullptr, "GetAudioOutputChannelCountForPlayReport"},
+        FunctionInfo{10105, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport", MakeVersionGate({14,0,0}, {19,0,1})},
+        FunctionInfo{10106, nullptr, "GetDefaultAudioOutputTargetForPlayReport", MakeVersionGate({14,0,0}, {19,0,1})},
+        FunctionInfo{10200, nullptr, "Unknown10200", MakeVersionGate({20,0,0})},
+        FunctionInfo{50000, nullptr, "SetAnalogInputBoostGainForPrototyping", MakeVersionGate({15,0,0}, {18,1,0})},
+        FunctionInfo{50001, nullptr, "OverrideDefaultTargetForDebug", MakeVersionGate({19,0,0}, {19,0,1})},
+        FunctionInfo{50003, nullptr, "SetForceOverrideExternalDeviceNameForDebug", MakeVersionGate({19,0,0})},
+        FunctionInfo{50004, nullptr, "ClearForceOverrideExternalDeviceNameForDebug", MakeVersionGate({19,0,0})}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IAudioController::IAudioController(Core::System& system_)
     : ServiceFramework{system_, "audctl"}, service_context{system, "audctl"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IAudioController::GetTargetVolume>, "GetTargetVolume"},
-        {1, D<&IAudioController::SetTargetVolume>, "SetTargetVolume"},
-        {2, D<&IAudioController::GetTargetVolumeMin>, "GetTargetVolumeMin"},
-        {3, D<&IAudioController::GetTargetVolumeMax>, "GetTargetVolumeMax"},
-        {4, D<&IAudioController::IsTargetMute>, "IsTargetMute"},
-        {5, D<&IAudioController::SetTargetMute>, "SetTargetMute"},
-        {6, nullptr, "IsTargetConnected"}, //20.0.0+
-        {7, nullptr, "SetDefaultTarget"},
-        {8, nullptr, "GetDefaultTarget"},
-        {9, D<&IAudioController::GetAudioOutputMode>, "GetAudioOutputMode"},
-        {10, D<&IAudioController::SetAudioOutputMode>, "SetAudioOutputMode"},
-        {11, nullptr, "SetForceMutePolicy"},
-        {12, D<&IAudioController::GetForceMutePolicy>, "GetForceMutePolicy"},
-        {13, D<&IAudioController::GetOutputModeSetting>, "GetOutputModeSetting"},
-        {14, D<&IAudioController::SetOutputModeSetting>, "SetOutputModeSetting"},
-        {15, nullptr, "SetOutputTarget"},
-        {16, nullptr, "SetInputTargetForceEnabled"},
-        {17, D<&IAudioController::SetHeadphoneOutputLevelMode>, "SetHeadphoneOutputLevelMode"},
-        {18, D<&IAudioController::GetHeadphoneOutputLevelMode>, "GetHeadphoneOutputLevelMode"},
-        {19, nullptr, "AcquireAudioVolumeUpdateEventForPlayReport"},
-        {20, nullptr, "AcquireAudioOutputDeviceUpdateEventForPlayReport"},
-        {21, nullptr, "GetAudioOutputTargetForPlayReport"},
-        {22, D<&IAudioController::NotifyHeadphoneVolumeWarningDisplayedEvent>, "NotifyHeadphoneVolumeWarningDisplayedEvent"},
-        {23, nullptr, "SetSystemOutputMasterVolume"},
-        {24, nullptr, "GetSystemOutputMasterVolume"},
-        {25, nullptr, "GetAudioVolumeDataForPlayReport"},
-        {26, nullptr, "UpdateHeadphoneSettings"},
-        {27, nullptr, "SetVolumeMappingTableForDev"},
-        {28, nullptr, "GetAudioOutputChannelCountForPlayReport"},
-        {29, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"},
-        {30, D<&IAudioController::SetSpeakerAutoMuteEnabled>, "SetSpeakerAutoMuteEnabled"},
-        {31, D<&IAudioController::IsSpeakerAutoMuteEnabled>, "IsSpeakerAutoMuteEnabled"},
-        {32, D<&IAudioController::GetActiveOutputTarget>, "GetActiveOutputTarget"},
-        {33, nullptr, "GetTargetDeviceInfo"},
-        {34, D<&IAudioController::AcquireTargetNotification>, "AcquireTargetNotification"},
-        {35, nullptr, "SetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
-        {36, nullptr, "GetHearingProtectionSafeguardTimerRemainingTimeForDebug"},
-        {37, nullptr, "SetHearingProtectionSafeguardEnabled"},
-        {38, nullptr, "IsHearingProtectionSafeguardEnabled"},
-        {39, nullptr, "IsHearingProtectionSafeguardMonitoringOutputForDebug"},
-        {40, nullptr, "GetSystemInformationForDebug"},
-        {41, nullptr, "SetVolumeButtonLongPressTime"},
-        {42, nullptr, "SetNativeVolumeForDebug"},
-        {43, nullptr, "Unknown43"}, //21.0.0+
-        {5000, D<&IAudioController::Unknown5000>, "Unknown5000"}, //19.0.0+
-        {10000, nullptr, "NotifyAudioOutputTargetForPlayReport"},
-        {10001, nullptr, "NotifyAudioOutputChannelCountForPlayReport"},
-        {10002, nullptr, "NotifyUnsupportedUsbOutputDeviceAttachedForPlayReport"},
-        {10100, nullptr, "GetAudioVolumeDataForPlayReport"},
-        {10101, nullptr, "BindAudioVolumeUpdateEventForPlayReport"},
-        {10102, nullptr, "BindAudioOutputTargetUpdateEventForPlayReport"},
-        {10103, nullptr, "GetAudioOutputTargetForPlayReport"},
-        {10104, nullptr, "GetAudioOutputChannelCountForPlayReport"},
-        {10105, nullptr, "BindAudioOutputChannelCountUpdateEventForPlayReport"}, //14.0.0-19.0.1
-        {10106, nullptr, "GetDefaultAudioOutputTargetForPlayReport"}, //14.0.0-19.0.1
-        {10200, nullptr, "Unknown10200"}, //20.0.0+
-        {50000, nullptr, "SetAnalogInputBoostGainForPrototyping"}, //15.0.0-18.1.0
-        {50001, nullptr, "OverrideDefaultTargetForDebug"}, //19.0.0-19.0.1
-        {50003, nullptr, "SetForceOverrideExternalDeviceNameForDebug"}, //19.0.0+
-        {50004, nullptr, "ClearForceOverrideExternalDeviceNameForDebug"} //19.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
-    m_set_sys =
-        system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
+    m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
     notification_event = service_context.CreateEvent("IAudioController:NotificationEvent");
 
     // Probably shouldn't do this in constructor?

src/core/hle/service/audio/audio_controller.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -59,8 +59,8 @@ private:
     Result AcquireTargetNotification(OutCopyHandle<Kernel::KReadableEvent> out_notification_event);
     Result Unknown5000(Out<SharedPointer<IAudioController>> out_audio_controller);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext service_context;
-
     Kernel::KEvent* notification_event;
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
     std::array<s32, 6> m_target_volumes{{15, 15, 15, 15, 15, 15}};

src/core/hle/service/audio/audio_device.cpp

@@ -12,36 +12,38 @@
 namespace Service::Audio {
 using namespace AudioCore::Renderer;
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioDevice::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IAudioDevice::ListAudioDeviceName>, "ListAudioDeviceName"},
+        FunctionInfo{1, D<&IAudioDevice::SetAudioDeviceOutputVolume>, "SetAudioDeviceOutputVolume"},
+        FunctionInfo{2, D<&IAudioDevice::GetAudioDeviceOutputVolume>, "GetAudioDeviceOutputVolume"},
+        FunctionInfo{3, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioDeviceName"},
+        FunctionInfo{4, D<&IAudioDevice::QueryAudioDeviceSystemEvent>, "QueryAudioDeviceSystemEvent"},
+        FunctionInfo{5, D<&IAudioDevice::GetActiveChannelCount>, "GetActiveChannelCount"},
+        FunctionInfo{6, D<&IAudioDevice::ListAudioDeviceNameAuto>, "ListAudioDeviceNameAuto"},
+        FunctionInfo{7, D<&IAudioDevice::SetAudioDeviceOutputVolumeAuto>, "SetAudioDeviceOutputVolumeAuto"},
+        FunctionInfo{8, D<&IAudioDevice::GetAudioDeviceOutputVolumeAuto>, "GetAudioDeviceOutputVolumeAuto"},
+        FunctionInfo{10, D<&IAudioDevice::GetActiveAudioDeviceNameAuto>, "GetActiveAudioDeviceNameAuto"},
+        FunctionInfo{11, D<&IAudioDevice::QueryAudioDeviceInputEvent>, "QueryAudioDeviceInputEvent"},
+        FunctionInfo{12, D<&IAudioDevice::QueryAudioDeviceOutputEvent>, "QueryAudioDeviceOutputEvent"},
+        FunctionInfo{13, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioOutputDeviceName"},
+        FunctionInfo{14, D<&IAudioDevice::ListAudioOutputDeviceName>, "ListAudioOutputDeviceName"},
+        FunctionInfo{15, nullptr, "AcquireAudioInputDeviceNotification", MakeVersionGate({17,0,0})},
+        FunctionInfo{16, nullptr, "ReleaseAudioInputDeviceNotification", MakeVersionGate({17,0,0})},
+        FunctionInfo{17, nullptr, "AcquireAudioOutputDeviceNotification", MakeVersionGate({17,0,0})},
+        FunctionInfo{18, nullptr, "ReleaseAudioOutputDeviceNotification", MakeVersionGate({17,0,0})},
+        FunctionInfo{19, D<&IAudioDevice::SetAudioDeviceOutputVolumeAutoTuneEnabled>, "SetAudioDeviceOutputVolumeAutoTuneEnabled", MakeVersionGate({18,0,0})},
+        FunctionInfo{20, D<&IAudioDevice::IsAudioDeviceOutputVolumeAutoTuneEnabled>, "IsAudioDeviceOutputVolumeAutoTuneEnabled", MakeVersionGate({18,0,0})},
+        FunctionInfo{21, nullptr, "IsActiveOutputDeviceEstimatedLowLatency", MakeVersionGate({21,0,0})}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IAudioDevice::IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                            u32 device_num)
     : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
       impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
       event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
-    static const FunctionInfo functions[] = {
-        {0, D<&IAudioDevice::ListAudioDeviceName>, "ListAudioDeviceName"},
-        {1, D<&IAudioDevice::SetAudioDeviceOutputVolume>, "SetAudioDeviceOutputVolume"},
-        {2, D<&IAudioDevice::GetAudioDeviceOutputVolume>, "GetAudioDeviceOutputVolume"},
-        {3, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioDeviceName"},
-        {4, D<&IAudioDevice::QueryAudioDeviceSystemEvent>, "QueryAudioDeviceSystemEvent"},
-        {5, D<&IAudioDevice::GetActiveChannelCount>, "GetActiveChannelCount"},
-        {6, D<&IAudioDevice::ListAudioDeviceNameAuto>, "ListAudioDeviceNameAuto"},
-        {7, D<&IAudioDevice::SetAudioDeviceOutputVolumeAuto>, "SetAudioDeviceOutputVolumeAuto"},
-        {8, D<&IAudioDevice::GetAudioDeviceOutputVolumeAuto>, "GetAudioDeviceOutputVolumeAuto"},
-        {10, D<&IAudioDevice::GetActiveAudioDeviceNameAuto>, "GetActiveAudioDeviceNameAuto"},
-        {11, D<&IAudioDevice::QueryAudioDeviceInputEvent>, "QueryAudioDeviceInputEvent"},
-        {12, D<&IAudioDevice::QueryAudioDeviceOutputEvent>, "QueryAudioDeviceOutputEvent"},
-        {13, D<&IAudioDevice::GetActiveAudioDeviceName>, "GetActiveAudioOutputDeviceName"},
-        {14, D<&IAudioDevice::ListAudioOutputDeviceName>, "ListAudioOutputDeviceName"},
-        {15, nullptr, "AcquireAudioInputDeviceNotification"}, //17.0.0+
-        {16, nullptr, "ReleaseAudioInputDeviceNotification"}, //17.0.0+
-        {17, nullptr, "AcquireAudioOutputDeviceNotification"}, //17.0.0+
-        {18, nullptr, "ReleaseAudioOutputDeviceNotification"}, //17.0.0+
-        {19, D<&IAudioDevice::SetAudioDeviceOutputVolumeAutoTuneEnabled>, "SetAudioDeviceOutputVolumeAutoTuneEnabled"}, //18.0.0+
-        {20, D<&IAudioDevice::IsAudioDeviceOutputVolumeAutoTuneEnabled>, "IsAudioDeviceOutputVolumeAutoTuneEnabled"}, //18.0.0+
-        {21, nullptr, "IsActiveOutputDeviceEstimatedLowLatency"} //21.0.0+
-    };
-    RegisterHandlers(functions);
-
     event->Signal(system.Kernel());
 }
 

src/core/hle/service/audio/audio_device.h

@@ -55,6 +55,7 @@ private:
     Result SetAudioDeviceOutputVolumeAutoTuneEnabled(bool enabled);
     Result IsAudioDeviceOutputVolumeAutoTuneEnabled(Out<bool> out_enabled);
 
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     KernelHelpers::ServiceContext service_context;
     std::unique_ptr<AudioCore::Renderer::AudioDevice> impl;
     Kernel::KEvent* event;

src/core/hle/service/audio/audio_in.cpp

@@ -11,35 +11,33 @@
 namespace Service::Audio {
 using namespace AudioCore::AudioIn;
 
+std::optional<ServiceFrameworkBase::FunctionInfoBase> IAudioIn::FindRequest(u32 key) {
+    static constexpr auto functions = CreateStaticMap(
+        FunctionInfo{0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},
+        FunctionInfo{1, D<&IAudioIn::Start>, "Start"},
+        FunctionInfo{2, D<&IAudioIn::Stop>, "Stop"},
+        FunctionInfo{3, D<&IAudioIn::AppendAudioInBuffer>, "AppendAudioInBuffer"},
+        FunctionInfo{4, D<&IAudioIn::RegisterBufferEvent>, "RegisterBufferEvent"},
+        FunctionInfo{5, D<&IAudioIn::GetReleasedAudioInBuffers>, "GetReleasedAudioInBuffers"},
+        FunctionInfo{6, D<&IAudioIn::ContainsAudioInBuffer>, "ContainsAudioInBuffer"},
+        FunctionInfo{7, D<&IAudioIn::AppendAudioInBuffer>, "AppendUacInBuffer"},
+        FunctionInfo{8, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendAudioInBufferAuto"},
+        FunctionInfo{9, D<&IAudioIn::GetReleasedAudioInBuffersAuto>, "GetReleasedAudioInBuffersAuto"},
+        FunctionInfo{10, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendUacInBufferAuto"},
+        FunctionInfo{11, D<&IAudioIn::GetAudioInBufferCount>, "GetAudioInBufferCount"},
+        FunctionInfo{12, D<&IAudioIn::SetDeviceGain>, "SetDeviceGain"},
+        FunctionInfo{13, D<&IAudioIn::GetDeviceGain>, "GetDeviceGain"},
+        FunctionInfo{14, D<&IAudioIn::FlushAudioInBuffers>, "FlushAudioInBuffers"}
+    );
+    return HandlerTableGenerateWithFind(key, functions);
+}
+
 IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
                    const std::string& device_name, const AudioInParameter& in_params,
                    Kernel::KProcess* handle, u64 applet_resource_user_id)
-    : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
-      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
-                                                                                    manager, event,
-                                                                                    session_id)} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},
-        {1, D<&IAudioIn::Start>, "Start"},
-        {2, D<&IAudioIn::Stop>, "Stop"},
-        {3, D<&IAudioIn::AppendAudioInBuffer>, "AppendAudioInBuffer"},
-        {4, D<&IAudioIn::RegisterBufferEvent>, "RegisterBufferEvent"},
-        {5, D<&IAudioIn::GetReleasedAudioInBuffers>, "GetReleasedAudioInBuffers"},
-        {6, D<&IAudioIn::ContainsAudioInBuffer>, "ContainsAudioInBuffer"},
-        {7, D<&IAudioIn::AppendAudioInBuffer>, "AppendUacInBuffer"},
-        {8, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendAudioInBufferAuto"},
-        {9, D<&IAudioIn::GetReleasedAudioInBuffersAuto>, "GetReleasedAudioInBuffersAuto"},
-        {10, D<&IAudioIn::AppendAudioInBufferAuto>, "AppendUacInBufferAuto"},
-        {11, D<&IAudioIn::GetAudioInBufferCount>, "GetAudioInBufferCount"},
-        {12, D<&IAudioIn::SetDeviceGain>, "SetDeviceGain"},
-        {13, D<&IAudioIn::GetDeviceGain>, "GetDeviceGain"},
-        {14, D<&IAudioIn::FlushAudioInBuffers>, "FlushAudioInBuffers"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
+    : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"}
+    , event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_, manager, event, session_id)}
+{
     process->Open(system.Kernel());
 
     if (impl->GetSystem()

src/core/hle/service/audio/audio_in.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -43,6 +46,7 @@ public:
     Result FlushAudioInBuffers(Out<bool> out_flushed);
 
 private:
+    std::optional<FunctionInfoBase> FindRequest(u32 key) override;
     Kernel::KProcess* process;
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* event;