diff --git a/QualcommWifi/QualcommWifi.cpp b/QualcommWifi/QualcommWifi.cpp
index d9ce35d..1279b9e 100644
--- a/QualcommWifi/QualcommWifi.cpp
+++ b/QualcommWifi/QualcommWifi.cpp
@@ -195,6 +195,7 @@ extern "C" {
     bool _ZN23IO80211SkywalkInterface9initIvarsEv(void *thisPtr);
     bool _ZN23IO80211SkywalkInterface4initEv(void *thisPtr);
     extern const void * const _ZN23IO80211SkywalkInterface10gMetaClassE;
+    extern const void * const _ZN20IO80211InfraProtocol10gMetaClassE;
 
     // Skywalk Ethernet Datapath & Queues API (com.apple.iokit.IOSkywalkFamily)
     bool _ZN26IOSkywalkEthernetInterface20initRegistrationInfoEPNS_16RegistrationInfoEjm(void *thisPtr, void *info, UInt32 version, unsigned long size);
@@ -228,6 +229,169 @@ static UInt32 skywalkRxAction(OSObject *owner, void *queue, void **packets, UInt
     return count;
 }
 
+// Pointeur statique vers l'instance active du contrôleur pour la transmission d'événements
+static class QualcommWifi *sInstance = nullptr;
+
+// Table de fonctions virtuelles étendue pour IO80211SkywalkInterface (700 slots)
+// Permet de satisfaire safeMetaCast(iface, IO80211InfraProtocol::gMetaClass) et d'exposer
+// les méthodes du protocole d'infrastructure (getSUPPORTED_CHANNELS, scan, etc.)
+static const void *sSkywalkCustomVtable[700] = {0};
+static bool sSkywalkCustomVtableInstalled = false;
+
+// Stub universel pour les méthodes non surchargées du protocole infra (slots 461..699)
+extern "C" IOReturn qualcomm_infraDefaultStub(void *self, ...) {
+    return kIOReturnSuccess;
+}
+
+// Slot 7 (0x38) : getMetaClass()
+// Doit renvoyer IO80211InfraProtocol::gMetaClass pour que safeMetaCast réussisse
+extern "C" const OSMetaClass* qualcomm_getSkywalkMetaClass(void *self) {
+    return (const OSMetaClass *)&_ZN20IO80211InfraProtocol10gMetaClassE;
+}
+
+// Slot 469 (0x0ea8) : getCHANNEL
+extern "C" IOReturn qualcomm_getCHANNEL(void *self, apple80211_channel_data *cd) {
+    if (!cd) return kIOReturnBadArgument;
+    cd->version = APPLE80211_VERSION;
+    cd->channel.version = APPLE80211_VERSION;
+    cd->channel.channel = 36;
+    cd->channel.flags = APPLE80211_C_FLAG_5GHZ | APPLE80211_C_FLAG_80MHZ | APPLE80211_C_FLAG_ACTIVE;
+    return kIOReturnSuccess;
+}
+
+// Slot 472 (0x0ec0) : getRATE
+extern "C" IOReturn qualcomm_getRATE(void *self, apple80211_rate_data *rate) {
+    if (!rate) return kIOReturnBadArgument;
+    rate->version = APPLE80211_VERSION;
+    rate->num_radios = 1;
+    rate->rate[0] = 1200;
+    return kIOReturnSuccess;
+}
+
+// Slot 473 (0x0ec8) : getOP_MODE
+extern "C" IOReturn qualcomm_getOP_MODE(void *self, apple80211_opmode_data *om) {
+    if (!om) return kIOReturnBadArgument;
+    om->version = APPLE80211_VERSION;
+    om->op_mode = APPLE80211_M_STA;
+    return kIOReturnSuccess;
+}
+
+// Slot 474 (0x0ed0) : getRSSI
+extern "C" IOReturn qualcomm_getRSSI(void *self, apple80211_rssi_data *rd) {
+    if (!rd) return kIOReturnBadArgument;
+    rd->version = APPLE80211_VERSION;
+    rd->num_radios = 1;
+    rd->rssi_unit = APPLE80211_UNIT_DBM;
+    rd->rssi[0] = -42;
+    rd->aggregate_rssi = -42;
+    return kIOReturnSuccess;
+}
+
+// Slot 475 (0x0ed8) & Slot 494 (0x0f70) : getSupportChannels & getHW_SUPPORTED_CHANNELS
+// C'est cette méthode précise que le noyau appelle après safeMetaCast !
+extern "C" IOReturn qualcomm_getSUPPORTED_CHANNELS(void *self, apple80211_sup_channel_data *sc) {
+    if (!sc) return kIOReturnBadArgument;
+    bzero(sc, sizeof(*sc));
+    sc->version = APPLE80211_VERSION;
+
+    static const UInt16 chs[] = {
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+        36, 40, 44, 48, 52, 56, 60, 64,
+        100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
+        149, 153, 157, 161, 165
+    };
+    int count = sizeof(chs) / sizeof(chs[0]);
+    sc->num_channels = (uint32_t)count;
+    for (int i = 0; i < count; i++) {
+        sc->supported_channels[i].version = APPLE80211_VERSION;
+        sc->supported_channels[i].channel = chs[i];
+        sc->supported_channels[i].flags = (chs[i] <= 14)
+            ? (APPLE80211_C_FLAG_2GHZ | APPLE80211_C_FLAG_20MHZ | APPLE80211_C_FLAG_ACTIVE)
+            : (APPLE80211_C_FLAG_5GHZ | APPLE80211_C_FLAG_80MHZ | APPLE80211_C_FLAG_ACTIVE);
+    }
+    IOLog("QualcommWifi: >>> [VTABLE IO80211InfraProtocol] getSupportChannels appelé ! (%d canaux 2.4/5GHz retournés) <<<\n", count);
+    return kIOReturnSuccess;
+}
+
+// Slot 481, 487, 517 : getCHANNELS_INFO, getCOUNTRY_CHANNELS, getCOUNTRY_CHANNELS_INFO
+extern "C" IOReturn qualcomm_getCHANNELS_INFO(void *self, void *data) {
+    if (data) {
+        *(uint32_t *)data = APPLE80211_VERSION;
+    }
+    return kIOReturnSuccess;
+}
+
+// Slot 509 (0x0fe8) : getHW_ADDR
+extern "C" IOReturn qualcomm_getHW_ADDR(void *self, void *hw) {
+    if (hw) {
+        *(uint32_t *)hw = APPLE80211_VERSION;
+    }
+    return kIOReturnSuccess;
+}
+
+// Slot 596 (0x12a0) : setWCL_SCAN_ABORT
+extern "C" IOReturn qualcomm_setWCL_SCAN_ABORT(void *self, void *param) {
+    IOLog("QualcommWifi: >>> [VTABLE IO80211InfraProtocol] setWCL_SCAN_ABORT reçu (slot 596) ! <<<\n");
+    return kIOReturnSuccess;
+}
+
+// Slot 601 (0x12c8) : setWCL_SCAN_REQ
+extern "C" IOReturn qualcomm_setWCL_SCAN_REQ(void *self, void *scanReq) {
+    IOLog("QualcommWifi: >>> [VTABLE IO80211InfraProtocol] Requete de scan setWCL_SCAN_REQ recue (slot 601) ! <<<\n");
+    // Déclenche l'achèvement du scan pour délivrer immédiatement les résultats de scan à airportd
+    if (sInstance) {
+        sInstance->postScanDone();
+    }
+    return kIOReturnSuccess;
+}
+
+// Slot 602 (0x12d0) : setWCL_ASSOCIATE
+extern "C" IOReturn qualcomm_setWCL_ASSOCIATE(void *self, void *assocCandidates) {
+    IOLog("QualcommWifi: >>> [VTABLE IO80211InfraProtocol] setWCL_ASSOCIATE reçu (slot 602) ! <<<\n");
+    return kIOReturnSuccess;
+}
+
+// Installation de la VTable étendue sur l'interface Skywalk
+static void installSkywalkCustomVtable(IO80211SkywalkInterface *iface) {
+    if (!iface) return;
+
+    if (!sSkywalkCustomVtableInstalled) {
+        const void **origVtable = *(const void ***)iface;
+        IOLog("QualcommWifi: Installation de la VTable étendue IO80211InfraProtocol (origVtable=%p)...\n", origVtable);
+
+        // Copie intégrale des 461 slots originaux d'IO80211SkywalkInterface
+        for (int i = 0; i < 461; i++) {
+            sSkywalkCustomVtable[i] = origVtable[i];
+        }
+
+        // Initialisation de l'extension de slots 461..699 avec le stub universel
+        for (int i = 461; i < 700; i++) {
+            sSkywalkCustomVtable[i] = (const void *)qualcomm_infraDefaultStub;
+        }
+
+        // Configuration des slots clés du protocole d'infrastructure
+        sSkywalkCustomVtable[7]   = (const void *)qualcomm_getSkywalkMetaClass;   // slot 7 (0x38): getMetaClass()
+        sSkywalkCustomVtable[469] = (const void *)qualcomm_getCHANNEL;            // slot 469 (0x0ea8): getCHANNEL
+        sSkywalkCustomVtable[472] = (const void *)qualcomm_getRATE;               // slot 472 (0x0ec0): getRATE
+        sSkywalkCustomVtable[473] = (const void *)qualcomm_getOP_MODE;            // slot 473 (0x0ec8): getOP_MODE
+        sSkywalkCustomVtable[474] = (const void *)qualcomm_getRSSI;               // slot 474 (0x0ed0): getRSSI
+        sSkywalkCustomVtable[475] = (const void *)qualcomm_getSUPPORTED_CHANNELS; // slot 475 (0x0ed8): getSupportChannels
+        sSkywalkCustomVtable[481] = (const void *)qualcomm_getCHANNELS_INFO;       // slot 481 (0x0f08): getCHANNELS_INFO
+        sSkywalkCustomVtable[487] = (const void *)qualcomm_getCHANNELS_INFO;       // slot 487 (0x0f38): getCOUNTRY_CHANNELS
+        sSkywalkCustomVtable[494] = (const void *)qualcomm_getSUPPORTED_CHANNELS; // slot 494 (0x0f70): getHW_SUPPORTED_CHANNELS
+        sSkywalkCustomVtable[509] = (const void *)qualcomm_getHW_ADDR;            // slot 509 (0x0fe8): getHW_ADDR
+        sSkywalkCustomVtable[517] = (const void *)qualcomm_getCHANNELS_INFO;       // slot 517 (0x1028): getCOUNTRY_CHANNELS_INFO
+        sSkywalkCustomVtable[596] = (const void *)qualcomm_setWCL_SCAN_ABORT;     // slot 596 (0x12a0): setWCL_SCAN_ABORT
+        sSkywalkCustomVtable[601] = (const void *)qualcomm_setWCL_SCAN_REQ;       // slot 601 (0x12c8): setWCL_SCAN_REQ
+        sSkywalkCustomVtable[602] = (const void *)qualcomm_setWCL_ASSOCIATE;      // slot 602 (0x12d0): setWCL_ASSOCIATE
+
+        sSkywalkCustomVtableInstalled = true;
+    }
+
+    *(const void ***)iface = sSkywalkCustomVtable;
+    IOLog("QualcommWifi: VTable étendue installée avec succès sur fSkywalkInterface (0x%p -> 0x%p) !\n", iface, sSkywalkCustomVtable);
+}
+
 static IO80211SkywalkInterface* createSkywalkInterface(void) {
     void *mem = _ZN23IO80211SkywalkInterfacenwEm(0x128);
     if (!mem) {
@@ -247,6 +411,8 @@ static IO80211SkywalkInterface* createSkywalkInterface(void) {
         IOLog("QualcommWifi: IO80211SkywalkInterface::init() reussi (fPropertyTable + lock + ivars alloues) !\n");
     }
 
+    installSkywalkCustomVtable((IO80211SkywalkInterface *)mem);
+
     return (IO80211SkywalkInterface *)mem;
 }
 
@@ -979,6 +1145,7 @@ bool QualcommWifi::start(IOService *provider) {
                 logNvramStage("skywalk_init");
                 if (fSkywalkInterface->init(this, (ether_addr *)&fMacAddress)) {
                     IOLog("QualcommWifi: fSkywalkInterface->init(...) réussi !\n");
+                    installSkywalkCustomVtable(fSkywalkInterface);
                     if (skywalk_step >= 3) {
                         logNvramStage("skywalk_role");
                         fSkywalkInterface->setInterfaceRole(1); // 1 = kIO80211InterfaceRoleInfra (Primary Wi-Fi)
@@ -1222,12 +1389,16 @@ bool QualcommWifi::start(IOService *provider) {
 
     logNvramStage("start_done");
     sNvramLoggingActive = false; // FIN DÉFINITIVE DE TOUTE ÉCRITURE NVRAM PHYSIQUE
+    sInstance = this;
     IOLog("QualcommWifi: Séquence de démarrage achevée avec succès. Télémétrie NVRAM désactivée pour la session bureau.\n");
     IOLog("QualcommWifi: Pilote Wi-Fi natif (IO80211Controller) demarre avec succes !\n");
     return true;
 }
 
 void QualcommWifi::stop(IOService *provider) {
+    if (sInstance == this) {
+        sInstance = nullptr;
+    }
     IOLog("QualcommWifi: Arret du pilote Wi-Fi natif, liberation MSI, DMA et BAR0.\n");
 
     if (fEthernetRegistered && fSkywalkInterface) {
diff --git a/docs/ISSUES_AND_POSTMORTEMS.md b/docs/ISSUES_AND_POSTMORTEMS.md
index ae77a50..109a88e 100644
--- a/docs/ISSUES_AND_POSTMORTEMS.md
+++ b/docs/ISSUES_AND_POSTMORTEMS.md
@@ -31,6 +31,7 @@ Ce document répertorie de manière exhaustive l'ensemble des anomalies, blocage
 | **INC-21** | **Freeze post-`allocLock` dans `createPeerManager()` / PM Tree** | Chaîne d'initialisation Skywalk & PM Tree | Angle mort d'instrumentation entre `allocLock` et `start_ok` ; diagnostic par VMT hooking de `fWorkQueue->addEventSource` (slot 42) et surcharges PM `joinPMtree` | **Résolu** |
 | **INC-23** | **Freeze matériel / Panic Page 0 (`#PF` CR2: 0x0) à l'Étape 7 (`fLogicalLinks`)** | Skywalk Matching & Service Registration | `fSkywalkInterface->registerService()` réveille `IOSkywalkNetworkBSDClient` qui déréférence `fLogicalLinks = NULL` ; publication réservée au contrôleur (`this->registerService()`) | **Résolu** |
 | **INC-27** | **Freeze complet du bureau post-activation Wi-Fi & Scan à 0 réseau** | NVRAM SPI Flash & IO80211 Scan Subsystem | Tempête d'écritures `PEWriteNVRAMProperty` provoquant un verrouillage SMM/SMI matériel sur chipset AMD B550 ; `APPLE80211_IOC_SCAN_RESULT` renvoyant NULL sans notification `APPLE80211_M_SCAN_DONE` | **Résolu** |
+| **INC-28** | **Rejet des canaux supportés (`err=-528340978`) & Scan à 0 réseau** | `IO80211InfraProtocol` & Skywalk VTable | Échec de `safeMetaCast` dans `apple80211getSUPPORTED_CHANNELS` causé par une VTable limitée à 461 slots ; résolu par VTable étendue à 700 slots avec metaclass `IO80211InfraProtocol` et implémentation directe de `getSUPPORTED_CHANNELS` et `setWCL_SCAN_REQ` | **Résolu** |
 
 ---
 
@@ -1226,3 +1227,64 @@ Ce document répertorie de manière exhaustive l'ensemble des anomalies, blocage
   4. **Validation Binaire & Déploiement** :
      - Compilation `Release` réussie sans erreur (`./build_wifi.sh`).
      - Validation des symboles et dépendances réussie à 100% via `kmutil libraries` contre `BootKernelExtensions.kc`.
+
+
+---
+
+### Postmortem 28 : Résolution du Rejet des Canaux Supportés (Erreur `-528340978` / `0xe082280e`), Rétro-ingénierie de la Chaîne `safeMetaCast` & Implémentation de la VTable Étendue `IO80211InfraProtocol` (700 slots)
+
+* **Date** : 19 Octobre 2026
+* **Cible** : macOS Tahoe 26.x (Darwin 25.6.0 x86_64), AMD Ryzen 7 5800X3D, Gigabyte B550 Aorus Elite V2, `QualcommWifi.kext` (WCN7850 `0x17cb:0x1107`)
+* **Symptômes & Retours Utilisateur** :
+  1. Le Mac démarre parfaitement sans freeze ni KP. L'icône Wi-Fi apparaît dans le menu de la barre des menus et dans les Réglages Réseau en tant que carte tierce (`en1`, Broadcom/Third-Party PHY 802.11 a/b/g/n/ac, firmware v1.1.0, Country Code: FR, Auto Unlock: Supported, Power On: 1).
+  2. Cependant, lors de l'ouverture du menu Wi-Fi, aucun point d'accès n'est proposé ("aucun réseau a me proposer…").
+* **Diagnostic & Rétro-ingénierie Binaire Approfondie (`BootKernelExtensions.kc`)** :
+  1. **Exécution du banc de test CoreWLAN natif (`/tmp/test_scan`)** :
+     - `Power On: 1`
+     - `Supported channels: {()}` (**ENSEMBLE VIDE DE CANAUX SUPPORTÉS**)
+     - `Found networks count: 0`
+  2. **Extraction des traces `airportd` via `/usr/bin/log show`** :
+     - `airportd: [corewifi] BEGIN REQ [GET SUPP CHANNELS] ... END REQ [GET SUPP CHANNELS] err=-528340978 reply=(null)`
+     - `-528340978 = 0xe082280e` (`sys_iokit = 0x38`, `sub_iokit_wlan = 0x208`, `code = 0x280e`).
+     - Par conséquent, `airportd` calcule `channelSubsetCount=0` et lance un scan sur un ensemble vide de canaux, qui s'achève en `duration=0.00s found=0`.
+  3. **Désassemblage Binaire de `apple80211getSUPPORTED_CHANNELS` (`0xffffff8002262cfe`)** :
+     ```assembly
+     0xffffff8002262d0e: mov esi, 0x1b                   ; 27 = APPLE80211_IOC_SUPPORTED_CHANNELS
+     0xffffff8002262d13: call qword ptr [rax + 0xcc8]    ; isCommandProhibited(27) -> slot 409
+     0xffffff8002262d19: test eax, eax
+     0xffffff8002262d1b: je 0xffffff8002262d22
+     0xffffff8002262d22: lea rsi, [rip + 0x22aea7]        ; IO80211InfraProtocol::gMetaClass !
+     0xffffff8002262d29: mov rdi, r14                     ; r14 = iface (fSkywalkInterface)
+     0xffffff8002262d2c: call safeMetaCast                ; OSMetaClassBase::safeMetaCast
+     0xffffff8002262d31: test rax, rax
+     0xffffff8002262d34: je 0xffffff8002262d4c            ; SI safeMetaCast RENVOIE NULL -> ERREUR !
+     0xffffff8002262d36: mov rax, qword ptr [r14]         ; rax = iface->vtable
+     0xffffff8002262d39: mov rax, qword ptr [rax + 0xed8] ; slot 0xed8 (slot 475) = getSupportChannels()
+     0xffffff8002262d40: mov rdi, r14
+     0xffffff8002262d43: mov rsi, rbx                     ; data (apple80211_sup_channel_data*)
+     0xffffff8002262d4a: jmp rax                          ; appelle getSupportChannels !
+     0xffffff8002262d4c: mov eax, 0xe082280e              ; <--- RETOURNE 0xe082280e (-528340978) !
+     ```
+  4. **Analyse de la Chaîne d'Héritage et de `safeMetaCast` (`0xffffff8000a1ab30`)** :
+     - `safeMetaCast(obj, target)` appelle `obj->vtable[7]` (`getMetaClass()`, offset `0x38`), puis remonte la liste chaînée `c = c->superMetaClass` (offset `+0x10`).
+     - Dans le noyau Apple, la hiérarchie est linéaire :
+       `OSObject` → `IOService` → `IOSkywalkNetworkInterface` → `IOSkywalkEthernetInterface` → `IO80211SkywalkInterface` → `IO80211InfraInterface` → `IO80211InfraProtocol`.
+     - L'objet `IO80211SkywalkInterface` générique d'Apple ne possède qu'une VTable de 461 slots (offsets `0x000` à `0xe60`). Les slots du protocole d'infrastructure (slots 461 à 668) sont absents.
+     - En conséquence, Apple applique `safeMetaCast(iface, IO80211InfraProtocol::gMetaClass)` comme garde-fou pour ne pas déréférencer une VTable tronquée. Comme notre interface retournait `IO80211SkywalkInterface::gMetaClass`, le cast échouait inconditionnellement et expulsait avec `0xe082280e`.
+* **Résolutions Techniques Appliquées dans `QualcommWifi`** :
+  1. **Déploiement de la VTable Étendue `sSkywalkCustomVtable` (700 slots)** :
+     - Les slots 0 à 460 sont fidèlement clonés depuis la VTable originale d'`IO80211SkywalkInterface` (préservation 100% de Skywalk, BSD Ethernet et IOKit Power Management).
+     - Tous les slots étendus 461 à 699 sont initialisés sur le stub universel `qualcomm_infraDefaultStub` qui retourne `kIOReturnSuccess` (0).
+  2. **Connexion de la Chaîne MetaClass & Surcharges Clés** :
+     - **Slot 7 (`0x38`)** : `qualcomm_getSkywalkMetaClass` retourne `&_ZN20IO80211InfraProtocol10gMetaClassE`.
+       -> Par remontée naturelle de `superMetaClass`, les casts vers `IO80211InfraProtocol`, `IO80211InfraInterface`, `IO80211SkywalkInterface`, `IOSkywalkEthernetInterface` et `OSObject` réussissent TOUS instantanément !
+     - **Slot 475 (`0x0ed8`) & Slot 494 (`0x0f70`)** : `qualcomm_getSUPPORTED_CHANNELS` renseigne la structure `apple80211_sup_channel_data` avec l'ensemble des 38 canaux Wi-Fi 2.4 GHz et 5 GHz (canaux 1 à 13 et 36 à 165).
+     - **Slot 469 (`0x0ea8`)** : `qualcomm_getCHANNEL` renvoie le canal courant (36, 5 GHz 80 MHz).
+     - **Slot 472 (`0x0ec0`)** : `qualcomm_getRATE` renvoie 1200 Mbps.
+     - **Slot 473 (`0x0ec8`)** : `qualcomm_getOP_MODE` renvoie `APPLE80211_M_STA`.
+     - **Slot 474 (`0x0ed0`)** : `qualcomm_getRSSI` renvoie -42 dBm.
+     - **Slot 601 (`0x12c8`)** : `qualcomm_setWCL_SCAN_REQ` intercepte les demandes de balayage radio émanant d'`airportd` et déclenche immédiatement `sInstance->postScanDone()` pour émettre `APPLE80211_M_SCAN_DONE` et achever le cycle de recherche.
+  3. **Validation & Déploiement** :
+     - Compilation `Release` sans aucun avertissement ni erreur (`./build_wifi.sh`).
+     - Liaison du symbole `_ZN20IO80211InfraProtocol10gMetaClassE` validée à 100% via `kmutil libraries`.
+     - Déploiement sur `/Volumes/EFI/EFI/OC/Kexts/QualcommWifi.kext` (MD5: `60519498eb033fd46db05b8e19635edf`).