@@ -14,18 +14,14 @@ int main(void) {
 
   printf("LaunchAtLogin is supported on this platform.\n\n");
 
-#if defined(__APPLE__)
   /*
-   * On macOS, the default constructor registers the main app with SMAppService.
-   * Custom identifiers are for bundled login item helpers.
+   * Create a LaunchAtLogin manager with a custom identifier and display name. On macOS
+   * the identifier would name a bundled login item helper, but set_program below names
+   * this application, so the application itself is what gets registered.
    */
-  native_launch_at_login_t launch_at_login = native_launch_at_login_create();
-#else
-  /* Create a LaunchAtLogin manager with a custom identifier and display name */
   native_launch_at_login_t launch_at_login =
       native_launch_at_login_create_with_id_and_display_name("com.example.myapp.c",
                                                              "My C Example App");
-#endif
   if (launch_at_login == NATIVE_INVALID_LAUNCH_AT_LOGIN) {
     printf("Failed to create LaunchAtLogin instance.\n");
     return 1;
@@ -44,23 +40,20 @@ int main(void) {
   free_c_str(id);
   free_c_str(display_name);
 
-#if !defined(__APPLE__)
-  /* Set a custom program path and arguments */
+  /*
+   * Set a custom program path and arguments. macOS records the arguments but never
+   * delivers them: SMAppService starts the app bundle, nothing else.
+   */
   char* argument_items[] = {"--minimized", "--launch_at_login"};
   native_string_list_t arguments = {argument_items, 2};
   native_launch_at_login_set_program(launch_at_login, executable ? executable : "", arguments);
-#endif
   free_c_str(executable);
 
   /* Retrieve and display the updated executable path */
   char* exec_path = native_launch_at_login_get_executable_path(launch_at_login);
   printf("After SetProgram:\n");
   printf("  Executable: %s\n", exec_path ? exec_path : "(null)");
-#if defined(__APPLE__)
-  printf("  Arguments:  (not supported by macOS SMAppService main-app login items)\n\n");
-#else
   printf("  Arguments:  --minimized --launch_at_login\n\n");
-#endif
   free_c_str(exec_path);
 
   /* Check current state before enabling */
 
@@ -18,26 +18,21 @@ int main() {
 
   std::cout << "LaunchAtLogin is supported on this platform.\n\n";
 
-  // On macOS, the default constructor registers the main app with SMAppService.
-  // Custom identifiers are for bundled login item helpers.
-#if defined(__APPLE__)
-  LaunchAtLogin launch_at_login;
-#else
+  // An identifier of your own names the registry value on Windows and the .desktop file
+  // on Linux. On macOS it would name a bundled login item helper, but SetProgram() below
+  // names this application, so the application itself is what gets registered.
   LaunchAtLogin launch_at_login("com.example.myapp", "My Example App");
-#endif
 
   // Display current configuration
   std::cout << "LaunchAtLogin configuration:\n";
   std::cout << "  ID:           " << launch_at_login.GetId() << "\n";
   std::cout << "  Display name: " << launch_at_login.GetDisplayName() << "\n";
   std::cout << "  Executable:   " << launch_at_login.GetExecutablePath() << "\n\n";
 
-// macOS SMAppService main-app login items do not support arbitrary arguments.
-#if !defined(__APPLE__)
-  // Set a custom program path and arguments
+  // Set a custom program path and arguments. macOS records the arguments but never
+  // delivers them: SMAppService starts the app bundle, nothing else.
   launch_at_login.SetProgram(launch_at_login.GetExecutablePath(),
                              {"--minimized", "--launch_at_login"});
-#endif
 
   std::cout << "After SetProgram:\n";
   std::cout << "  Executable: " << launch_at_login.GetExecutablePath() << "\n";
 
@@ -14,7 +14,10 @@ namespace nativeapi {
  * but this class abstracts away those differences.
  *
  * Platform implementations:
- * - Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run registry key
+ * - Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run registry key, and the
+ *   matching Explorer\StartupApproved\Run flag so that an entry the user switched off in
+ *   Task Manager reads as disabled. An app running from an MSIX package sees a virtualized
+ *   registry instead, so there it is a shortcut in the user's Startup folder.
  * - macOS: ServiceManagement SMAppService for the main app or bundled login item helpers
  * - Linux (XDG): ~/.config/autostart/[app_id].desktop
  * - Android/iOS/OHOS: Not supported (returns false from IsSupported/operations)
@@ -25,8 +28,8 @@ namespace nativeapi {
  * - You can let the implementation determine the current executable path, or call
  *   SetProgram() to customize the target binary and arguments recorded in the OS where the
  *   platform supports arbitrary launch commands. On macOS, SMAppService can only register
- *   the main app or a bundled helper, so custom executable paths and arguments are not
- *   supported.
+ *   the main app or a bundled helper, so a custom executable path is not supported and
+ *   arguments are never delivered.
  * - Some platforms may require application-specific permissions or entitlements
  *   (e.g., sandbox restrictions on macOS). In such cases, operations may fail.
  *
@@ -122,6 +125,16 @@ class LaunchAtLogin {
    * @param executable_path Absolute path to the executable to run on login.
    * @param arguments       Optional arguments; order is preserved.
    * @return true if stored locally; does not change OS registration until Enable().
+   *
+   * @note Platform availability:
+   * - macOS: ⚠️ Recorded only - SMAppService starts the app bundle; naming the running
+   *   application registers it whatever the identifier says, any other path makes Enable()
+   *   fail, and arguments are never delivered
+   * - Windows: ✅ Fully supported - written as a quoted command line
+   * - Linux: ✅ Fully supported - written to the .desktop Exec line
+   * - Android: ❌ Not applicable - Always ignored
+   * - iOS: ❌ Not applicable - Always ignored
+   * - OpenHarmony: ❌ Not applicable - Always ignored
    */
   bool SetProgram(const std::string& executable_path,
                   const std::vector<std::string>& arguments = {});
@@ -152,6 +165,15 @@ class LaunchAtLogin {
    * to resolve the current executable path and use that as the program to start.
    *
    * @return true on success; false on error or when unsupported.
+   *
+   * @note Platform availability:
+   * - macOS: ⚠️ Recorded only - fails when the user has denied the app in System Settings,
+   *   or when SetProgram() named an executable that is not this application
+   * - Windows: ✅ Fully supported - also clears the Task Manager "disabled" flag
+   * - Linux: ✅ Fully supported
+   * - Android: ❌ Not applicable - Always returns false
+   * - iOS: ❌ Not applicable - Always returns false
+   * - OpenHarmony: ❌ Not applicable - Always returns false
    */
   bool Enable();
 
@@ -165,10 +187,14 @@ class LaunchAtLogin {
   /**
    * @brief Query whether launch-at-login is currently enabled for this manager's identifier.
    *
-   * This checks the platform-specific mechanism to determine whether the app (program path
-   * and arguments currently configured) is registered to start at user login.
+   * This checks the platform-specific mechanism for an entry under this manager's
+   * identifier. It does not compare the registered command against the program and
+   * arguments currently configured: an entry written by an older version of the app, from
+   * a different path, still reads as enabled.
    *
    * @return true if currently enabled; false otherwise.
+   *
+   * @see Enable() for platform availability.
    */
   bool IsEnabled() const;
 
 
@@ -82,20 +82,41 @@
   }
 }
 
+// The path of the running executable as the loader knows it, which is what a caller
+// asking "is this me?" has most likely been handed (Dart's Platform.resolvedExecutable,
+// for one). It can differ from arg0, so both are compared.
+static std::string LoaderExecutablePath() {
+  uint32_t size = 0;
+  _NSGetExecutablePath(nullptr, &size);
+  if (size == 0) {
+    return std::string();
+  }
+  std::string buffer(size + 1, '\0');
+  if (_NSGetExecutablePath(buffer.data(), &size) != 0) {
+    return std::string();
+  }
+  return std::string(buffer.c_str());
+}
+
 static bool IsCurrentProgram(const std::string& executable_path) {
   if (executable_path.empty()) {
     return true;
   }
 
-  std::string current = DetectDefaultProgramPath();
-  if (current.empty()) {
-    return false;
-  }
-
   @autoreleasepool {
-    NSString* requested = [ToNSString(executable_path) stringByStandardizingPath];
-    NSString* detected = [ToNSString(current) stringByStandardizingPath];
-    return [requested isEqualToString:detected];
+    NSString* requested =
+        [[ToNSString(executable_path) stringByStandardizingPath] stringByResolvingSymlinksInPath];
+    for (const std::string& candidate : {DetectDefaultProgramPath(), LoaderExecutablePath()}) {
+      if (candidate.empty()) {
+        continue;
+      }
+      NSString* detected =
+          [[ToNSString(candidate) stringByStandardizingPath] stringByResolvingSymlinksInPath];
+      if ([requested isEqualToString:detected]) {
+        return true;
+      }
+    }
+    return false;
   }
 }
 
@@ -147,6 +168,7 @@ bool SetDisplayName(const std::string& display_name) {
   bool SetProgram(const std::string& executable_path, const std::vector<std::string>& arguments) {
     program_path_ = executable_path;
     arguments_ = arguments;
+    program_was_set_ = true;
     return true;
   }
 
@@ -226,7 +248,7 @@ bool IsEnabled() const {
 #if NATIVEAPI_HAS_SM_APP_SERVICE
   SMAppService* Service() const API_AVAILABLE(macos(13.0)) {
     @autoreleasepool {
-      if (id_.empty() || id_ == default_id_) {
+      if (UsesMainApp()) {
         return [SMAppService mainAppService];
       }
 
@@ -239,12 +261,25 @@ bool IsEnabled() const {
   }
 #endif
 
+  // Whether this manager registers the application itself rather than a bundled login
+  // item helper. An identifier that is not the bundle identifier names a helper — unless
+  // SetProgram() named the running application, which says plainly which app to start.
+  bool UsesMainApp() const {
+    if (id_.empty() || id_ == default_id_) {
+      return true;
+    }
+    return program_was_set_ && IsCurrentProgram(program_path_);
+  }
+
   bool CanUseConfiguredProgram() const {
     // SMAppService registers the main app or bundled helpers. It cannot register
-    // an arbitrary executable path or ProgramArguments like a legacy LaunchAgent.
+    // an arbitrary executable path like a legacy LaunchAgent, and it starts the app
+    // bundle without arguments — those are recorded but never delivered.
+    if (UsesMainApp()) {
+      return program_path_.empty() || IsCurrentProgram(program_path_);
+    }
     return arguments_.empty() &&
-           (program_path_.empty() || program_path_ == default_program_path_ ||
-            IsCurrentProgram(program_path_));
+           (program_path_.empty() || program_path_ == default_program_path_);
   }
 
  private:
@@ -254,6 +289,7 @@ bool CanUseConfiguredProgram() const {
   std::vector<std::string> arguments_;
   std::string default_id_;
   std::string default_program_path_;
+  bool program_was_set_ = false;
 };
 
 // LaunchAtLogin public API implementations