IEEE 802.11: transmit HT aggregates with selective retry and recovery

doc/project/evidence/model/wifi/results.md

@@ -1,9 +1,15 @@
 # Wi-Fi protocol tests — expectation audit
 
-> **Kind:** report · **Status:** snapshot 2026-09-17 · **Seal:** none · **Owns:** — · **Stands on:** [failure classification](../../../guide/derive-tests-from-a-standard.md#the-class-of-a-failure-and-when-to-declare-it-expected), [testing rules](../../../rule/testing.md)
+> **Kind:** report · **Status:** snapshot 2026-10-18 with September history · **Seal:** none · **Owns:** — · **Stands on:** [failure classification](../../../guide/derive-tests-from-a-standard.md#the-class-of-a-failure-and-when-to-declare-it-expected), [testing rules](../../../rule/testing.md)
 
 Raw artifacts linked under `audit/` are local, Git-ignored evidence and are not included in the branch. The observations, classifications, and follow-up work are recorded below.
 
+## HT aggregate update, 2026-10-18
+
+`N_Ampdu` now uses the supported HT20 aggregate profile with fixed rates and Compressed Block Ack. Its production exchange observes an aggregate and an implicit response. It requires exactly 60 UDP deliveries and independently checks 60 application receipts. The maintainer explicitly approves removal of this test's expected-failure marker after the focused pass. The [Implicit Block Ack execution record](../../../../../plan/pending/ieee80211-ampdu-implicit-blockack-execution.md) supplies the source identity, commands, and final evidence.
+
+`Ac_Ampdu` retains its expected failure because VHT aggregates remain outside this profile. HT transmission from an `ac` interface does not establish VHT aggregate support. All other deferred declarations retain their existing scope. The sections below retain the September snapshot and its historical counts.
+
 ## Deferred-repair expectations
 
 After the audit and rebase, the maintainer explicitly requested that the 12 failures from the 18-test focused run be declared expected: their repairs are nontrivial and deferred to future contributions. This later decision supersedes the removal decision for those 12 tests only. The six repaired passing tests retain their PASS expectations. The maintainer subsequently extended the same decision to the separately added `Ac_Ldpc` test. The total deferred-repair scope is now 13 tests.

doc/src/migration-guide/development/ieee80211-ht-a-mpdu-phy-reception.rst

@@ -0,0 +1,22 @@
+IEEE 802.11 HT A-MPDU PHY reception
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Error models use the generic ``IErrorModel::computeReceivedData()`` operation for partial DATA reception. The caller supplies bounded chunk content. The model returns content of the same length with incorrect chunks marked. The operation permits an entirely correct result. It does not parse delimiters or identify MPDUs.
+
+Custom models that derive from ``ErrorModelBase`` inherit this operation. Its default calculation uses DATA BER and rejects an unavailable BER. ``Ieee80211ErrorModelBase`` overrides the chunk probability calculation through its existing DATA success function. NIST and Yans need no separate aggregation interface. Direct implementations of ``IErrorModel`` must implement the new operation.
+
+The receiver checks PHY acquisition, header validity, and available PSDU length before it requests DATA corruption. Header failure prevents DATA draws. A valid header whose Length exceeds the modeled PSDU causes structural refusal. This check establishes bounds safety, with no claim about physical carrier loss.
+
+The DATA decision retains the received chunks. WHOLE and result queries reuse those chunks without more random draws. The receiver replaces only PSDU content in its local packet. The transmitted chunks remain unchanged. Region tags retain their positions.
+
+``Ieee80211AmpduInd`` contains header success, aggregation identity, and content completeness. Error outcomes reside in chunk correctness flags. The indication contains no parallel range table. The explicit packet bit-error flag denotes failed prerequisites or missing content. ``Packet::hasBitError()`` also reports incorrect chunks, so a partial DATA error makes that query true.
+
+For example, a three-member aggregate contains an incorrect payload chunk in its middle MPDU. Extraction preserves that chunk, so the middle MPDU reports incorrect content. The other MPDUs can remain correct. The default ``Rx`` still rejects all aggregate containers before standalone header or FCS checks. Member acceptance, upper delivery, and implicit Block Ack remain separate work.
+
+Chunk structure controls error granularity. Typed input can preserve separate delimiters, headers, payloads, and trailers. ``sendRawBytes`` converts the transmission to one byte chunk. Its DATA view therefore receives one outcome. The receiver does not reconstruct hidden member boundaries for the error model.
+
+HT-SIG uses all 48 bits for Length, Aggregation, coding fields, and CRC. The receiver validates the received CRC before DATA corruption. Ordinary reception retains its existing whole-packet path.
+
+With a present model, aggregate ``ErrorRateInd`` fields contain ``NaN`` for unknown probabilities. An absent model preserves the common metadata path and performs no error draws. BerTable retains its current HT configuration limit.
+
+The tested profile covers HT20 mixed format, either guard interval, and scalar or dimensional radios. Each chunk uses an independent draw for a probability strictly between zero and one. Padding chunks also receive outcomes. The model does not represent correlated FEC errors. It establishes no new error-accuracy or goodput claim.

doc/src/migration-guide/development/ieee80211-implicit-blockack.rst

@@ -0,0 +1,25 @@
+IEEE 802.11 implicit Block Ack extension points
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The default MPDU policy remains disabled. ``HtMpduAggregationPolicy`` enables independent HT20 long-GI members with fixed DATA rates. Custom MPDU policies implement ``isEnabled()`` and ``selectFrames()``. The caller supplies negotiated receiver limits and one retained DATA mode. A policy returns borrowed member references without queue extraction or state changes.
+
+Custom QoS data services implement batch preparation, validation, commitment, and construction through ``IOriginatorQosMacDataService``. Each new member owns one reversible preview. The batch borrows canonical members from the in-progress queue. Commitment validates every queued source before the first extraction. Failed preparation preserves sequence state and independent deadlines.
+
+``IRx::lowerAggregateReceived()`` returns separately owned correct members and immutable delimiter history. The caller retains the envelope. Custom recipient services pass ``BlockAckReceiveContext`` to the reorder owner. This context supplies physical interval and delimiter facts; it does not replace receipt state. Custom agreement handlers implement ``implicitBlockAckRequested()`` to refresh inactivity for valid implicit DATA.
+
+Custom Tx implementations support ``transmitAggregate()``, ``cancelPendingAggregate()``, and ``finalizeMpdu()``. The aggregate callback validates and commits members at actual submission after the existing IFS timer. Cancellation removes a delayed request before exchange-context disposal. Aggregate completion supplies a null MAC header because the envelope has no outer MAC header or FCS. Every Tx callback implements ``frameTransmissionStarted()`` for an actual-submission notification. A concrete callback can use an empty override when submission requires no state change.
+
+Custom QoS ACK policies accept probe eligibility through existing EDCA classification. They also supply the implicit Block Ack receive-start timeout from the actual response mode. Every custom rate selector implements ``computeCompressedBlockAckResponseMode()`` for implicit callers. A selector without this capability must throw a diagnostic from its concrete override. Explicit Compressed BAR and implicit DATA share this rate calculation without a fabricated BAR.
+
+Custom recipient procedures construct a Compressed response directly from peer, TID, and current agreement state. ``FrameTransmissionDetails`` adds ``FRAME_TRANSMISSION_STATUS_UNACKNOWLEDGED`` for unsuccessful aggregate member attempts. A probe supplies no second DATA attempt outcome. Existing packet-drop signals retain terminal disposal observations.
+
+IEEE 802.11 HT aggregate construction
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The MIB parameter ``htMinimumMpduStartSpacing`` supplies the encoded receiver limit from zero through seven. Zero preserves the default with no spacing restriction. The remaining values represent 0.25, 0.5, 1, 2, 4, 8, and 16 microseconds. Full and simplified management preserve the receiver's value in each negotiated direction. The negotiated transmit direction stores the peer receiver's value.
+
+Custom ``IMpduAggregation`` implementations must supply two HT operations. ``computeAggregateLength()`` previews the PSDU length at the supplied mode and spacing. Zero means an empty batch, unsupported mode, invalid member length, or excessive HT PSDU length. The new ``aggregateFrames()`` overload accepts source references, the mode, encoded spacing, and the peer byte limit. It returns ``nullptr`` when construction exceeds a limit, including either HT duration limit. These operations retain all source Packets and their state.
+
+The existing pointer overload retains its consuming contract. The supplied builder copies region tags from each source's data range to the member's position. It inserts alignment padding and zero-length delimiters between members as necessary. The final member has no padding. A singleton retains its delimiter, so HT-SIG byte conversion preserves its aggregate identity. These construction operations do not enable aggregate selection or implicit Block Ack responses.
+
+The default ``Rx`` sends aggregate containers through a separate member-validation path before standalone FCS or MAC header checks. A failed common header or incomplete content prevents member acceptance. Custom receive modules must keep aggregate containers separate from standalone frame parsing until they implement member acceptance. MPDU deaggregation can extract bounded recovered members from incomplete content. Extraction alone grants no MAC acceptance.

doc/src/users-guide/ch-80211.rst

@@ -609,7 +609,7 @@ minimum.
 
 Outside active Compressed agreements, multiple protection does not check complete exchange cost against the remaining budget. For example, that retained policy can start a 120 us exchange with only 100 us left. Active Compressed agreements use their separate complete-cost admission. The reference scope assumes whole-microsecond positive limits, integral initial PPDU airtime, and integral legacy RTS airtime.
 
-Multiple protection adds no A-MPDU, new fragmentation, CTS-to-self, dual CTS, PIFS recovery, or TXOP sharing. Reverse direction, beamforming, S1G, multi-user operation, and general MAC lifecycle support remain outside this implementation. General rate selection and recipient response timing retain their separate limits.
+Multiple protection supports the HT aggregate profile below. New fragmentation, CTS-to-self, dual CTS, PIFS recovery, and TXOP sharing remain outside this implementation. Reverse direction, beamforming, S1G, multi-user operation, and general MAC lifecycle support also remain outside this implementation. General rate selection and recipient response timing retain their separate limits.
 
 .. _ug:sec:80211:fragmentation:
 
@@ -642,17 +642,47 @@ default policy is :ned:`BasicMsduAggregationPolicy` with these parameters:
 -  :par:`aggregationLengthThreshold`: the smallest aggregated payload that
    makes an A-MSDU. The default, ``-1``, means no check.
 
-Set ``msduAggregationPolicy.typename = ""`` to turn aggregation off. A-MSDU
-aggregation needs packets in the queue; it has an effect only when the
-traffic source is faster than the channel. A-MPDU aggregation is not
-available: the ``mpduAggregationPolicy`` slot exists, but the default policy
-never aggregates, and the MAC does not build A-MPDU frames.
+Set ``msduAggregationPolicy.typename = ""`` to turn A-MSDU aggregation off. A-MSDU aggregation needs packets in the queue. The default MPDU policy also leaves A-MPDU transmission disabled. The HT policy below enables A-MPDU transmission with implicit Compressed Block Ack.
 
 .. code-block:: ini
 
    **.wlan[*].mac.qosStation = true
    **.wlan[*].mac.hcf.originatorMacDataService.msduAggregationPolicy.maxAMsduSize = 3000
 
+.. _ug:sec:80211:htampdu:
+
+HT A-MPDU and implicit Block Ack
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Select ``HtMpduAggregationPolicy`` to combine independent MPDUs after an accepted Compressed Block Ack agreement. The first transmit profile uses HT mixed format, 20 MHz, and long GI. Configure a fixed DATA rate without a rate-control submodule. HCF rejects aggregate opt-in with rate control at initialization. The receiver also accepts advertised HT20 short-GI aggregates.
+
+.. code-block:: ini
+
+   **.wlan[*].opMode = "n(mixed-2.4Ghz)"
+   **.wlan[*].mac.qosStation = true
+   **.wlan[*].mac.hcf.isBlockAckSupported = true
+   **.wlan[*].mac.hcf.blockAckVariant = "compressed"
+   **.wlan[*].mac.hcf.rateControl.typename = ""
+   **.wlan[*].mac.hcf.rateSelection.dataFrameBitrate = 65Mbps
+   **.wlan[*].mac.hcf.rateSelection.dataFrameBandwidth = 20MHz
+   **.wlan[*].mac.hcf.rateSelection.dataFrameNumSpatialStreams = 1
+   **.wlan[*].mac.hcf.rateSelection.controlFrameBitrate = 6Mbps
+   **.wlan[*].mac.hcf.originatorMacDataService.mpduAggregationPolicy.typename = "HtMpduAggregationPolicy"
+
+Production infrastructure management supplies peer capabilities and receiver limits. An HT mode alone does not supply this state. Each aggregate contains unfragmented QoS DATA for one receiver and TID. HCF applies the peer's byte limit, minimum MPDU start spacing, transmit window, and both HT duration limits. A-MSDU members remain outside this aggregate profile.
+
+HCF selects transmitted retries first, followed by numbered unsent members and new queued members. New members retain separate sequence numbers and deadlines. HCF commits queued members at actual DATA submission after the IFS interval. Expiry or agreement loss before submission cancels the batch without a DATA attempt. RTS protection uses the complete PSDU length, including delimiters and spacing.
+
+Every member carries ACK policy bits ``00`` and the same Duration value. Aggregate context makes those bits an implicit Block Ack request. The recipient validates each member against its copied PHY outcome and FCS. A valid member can arrive despite another member's failure. One correct member prevents EIFS, including an overheard member or DATA without an agreement.
+
+The recipient sends one Compressed Block Ack after SIFS for accepted aggregate DATA. Positive bits release only transmitted members. Missing bits retain the affected members for selective retry. A valid zero-bit response completes the response exchange without a probe. An absent or invalid response arms one explicit BAR probe before further DATA for that agreement.
+
+The probe is an INET recovery policy. It can expose lost recipient agreement state while fresh DATA remains queued. Probe submission consumes the pending flag. Probe failure returns to DATA retry without another probe until a later DATA attempt. Each probe adds airtime and channel access delay.
+
+A zero TXOP limit permits one aggregate DATA PPDU with its protection and response. Multiple-member aggregates must fit a positive limit. A singleton retry can use the applicable single-MPDU exception. The example at ``examples/wireless/htampdu`` provides scalar, dimensional, and zero-limit configurations.
+
+NIST and Yans retain cached PHY outcomes in chunk flags under scalar SNIR reduction. This abstraction does not model correlated FEC errors or interference changes within a chunk. Adaptive aggregate rates, HT40 transmit aggregation, VHT aggregates, and Multi-TID Block Ack remain outside this profile. These capabilities do not establish complete amendment conformance or throughput validation.
+
 .. _ug:sec:80211:ack:
 
 Acknowledgement and retries
@@ -1049,7 +1079,7 @@ The model does not contain:
 -  PCF and HCCA, the polled channel access methods. The module
    :ned:`Hcca` exists as a placeholder.
 
--  A-MPDU aggregation and self-CTS protection.
+-  HT40 transmit aggregation, VHT aggregates, and self-CTS protection.
 
 -  Multi-TID block acknowledgement and delayed Compressed Block Ack.
 

doc/whatsnew/incompatible/ieee80211-bounded-mpdu-deaggregation.txt

@@ -1,3 +1,3 @@
 IEEE 802.11 bounded MPDU deaggregation
 
-MPDU deaggregation extracts complete members directly from chunk traversal. It stops at an invalid or overlong delimiter before an out-of-bounds request. Extraction alone grants no PHY success, FCS acceptance, or MAC delivery permission.
+MPDU deaggregation extracts complete members directly from chunk traversal. An invalid or overlong delimiter triggers a search for later valid delimiters at four-octet intervals. Recovery crosses typed MPDU headers and retains later complete members. Extraction alone grants no PHY success, FCS acceptance, or MAC delivery permission.

doc/whatsnew/incompatible/ieee80211-implicit-blockack.txt

@@ -0,0 +1,9 @@
+IEEE 802.11 HT A-MPDU and implicit Compressed Block Ack
+
+HtMpduAggregationPolicy enables HT20 mixed-format A-MPDU transmission after an accepted Compressed agreement. The default policy leaves aggregation disabled. The first transmit profile requires long GI and fixed DATA rates without rate control. The receiver also accepts advertised HT20 short-GI aggregates. The htampdu example supplies scalar, dimensional, and zero-TXOP configurations.
+
+Each member retains its sequence number, retry state, and independent deadline. HCF commits new members after the IFS interval at actual DATA submission. The complete PSDU length controls RTS protection and exchange admission. Partial PHY loss permits separate member acceptance and one implicit response after SIFS. One correct member prevents EIFS, including overheard DATA and DATA without an agreement.
+
+Missing or invalid implicit responses cause one contention failure and one pending explicit BAR probe. Probe submission consumes that flag. Probe failure permits DATA retry without another probe until a later DATA attempt. This INET policy exposes lost recipient agreement state under continuous traffic. It adds probe airtime and channel access delay. Valid zero-bit responses do not arm a probe.
+
+Custom aggregation policies, QoS data services, Rx, Tx, recipient services, ACK policies, and response procedures require the migration changes. NIST and Yans retain cached PHY outcomes in chunk flags. Adaptive aggregate rates, HT40 transmit aggregation, VHT aggregates, nested A-MSDUs, and correlated FEC errors remain outside this profile. These changes can alter affected exchange order, delivery times, and simulation results.

doc/whatsnew/incompatible/ieee80211-pure-ht-aggregate-probabilities.txt

@@ -0,0 +1,5 @@
+PHY DATA chunk errors
+
+PHY error models now support unconditional DATA corruption through `IErrorModel::computeReceivedData()`. The operation returns existing chunk content with local error flags. Direct interface implementations must supply this operation. The common base uses DATA BER. A model can override the probability calculation through its existing PHY functions.
+
+HT aggregate reception caches the returned chunks. It preserves partial errors without an A-MPDU error-model role or a separate range table. Raw byte input has one DATA outcome because byte conversion removes the original chunk boundaries. Rx still rejects aggregate containers before standalone FCS or MAC header checks. MAC member acceptance remains separate work.

doc/whatsnew/incompatible/ieee80211-vht-phy-header-identity.txt

@@ -0,0 +1,3 @@
+IEEE 802.11 HT-SIG bytes and aggregate boundaries
+
+HT transmissions now preserve the complete HT-SIG header through byte conversion. Receivers check its CRC, supported fields, and length before length-based trailer removal. Invalid headers mark packets as erroneous. Delimiter inspection supplies bounded MPDU ranges, including singleton aggregates. Ordinary valid HT duration inputs remain unchanged. VHT modes now create their own header type.