Advance native Windows RR integration, kernel tooling and local packaging

Implement native NGX feature-13 RR through a LUID-matched D3D12/Vulkan
shared-memory and timeline-fence bridge. Add owned parameter snapshots,
GPU resource lifetime handling, inherited/enhanced barriers, optional
guides, sampled input formats and depth-plane support with stencil
preservation. Separate RR initialization from the SR CUDA runtime and
expose explicit backend/model selection through player configuration.

Add synthetic bridge, snapshot and NGX lifecycle harnesses covering
camera/history/reset, parameter mutation, delayed submission, early
release, capability gating and unsupported-input rejection.

Add exact gfx11 D/E model generation, verified caches, versioned local
deployment with configuration backups, and isolated portable model
tools with pinned Python, NumPy and glslang dependencies.

Extend Windows K benchmarking and private native-cache selection.
Fix LLVM 22 emitter/helper compatibility and preserve exact-output
validation for local output-kernel optimization.

Add native FSR RR provider diagnostics, local development package
refresh tooling, installer/checker updates, FidelityFX headers and
Windows parity documentation.

Keep NVIDIA binaries, derived models and private optimized kernels out
of distributable packages. Native RR evidence remains synthetic;
game validation, FSR RR dispatch, installer integration and Linux
performance parity remain incomplete.

tools/windows/llvm22_ir.py

@@ -0,0 +1,64 @@
+"""Adapt textual HIP helper IR to the pinned LLVM 22 reader without relaxing FP."""
+import argparse
+from pathlib import Path
+import re
+import struct
+
+
+def float_hex(match):
+    bits = int(match[1], 16)
+    sign, exponent, fraction = bits >> 31, (bits >> 23) & 255, bits & 0x7fffff
+    if exponent:
+        wide_exponent = 2047 if exponent == 255 else exponent + 896
+        wide_fraction = fraction << 29
+    elif fraction:
+        leading = fraction.bit_length() - 1
+        wide_exponent = leading - 149 + 1023
+        wide_fraction = (fraction - (1 << leading)) << (52 - leading)
+    else:
+        wide_exponent = wide_fraction = 0
+    # LLVM's legacy float spelling uses the exact widening's binary64 bits.
+    # Integer operations preserve signed zero and signaling/quiet NaN payloads.
+    return f'0x{((sign << 63) | (wide_exponent << 52) | wide_fraction):016X}'
+
+
+def compatible_ir(text):
+    text = re.sub(r'\bf0x([0-9A-Fa-f]{16})\b', r'0x\1', text)
+    text = re.sub(r'\bf0x([0-9A-Fa-f]{4})\b', r'0xH\1', text)
+    text = re.sub(r'\bf0x([0-9A-Fa-f]{8})\b', float_hex, text)
+    text = text.replace('denormal_fpenv(dynamic)', '"denormal-fp-math"="dynamic,dynamic"')
+    # This newer optimization promise is absent in LLVM 22. Dropping a promise
+    # weakens what the optimizer may assume; it does not change instructions.
+    text = re.sub(r'\bnocreateundeforpoison\b', '', text)
+    text = re.sub(r'\bmemory\([^)]*\btarget_mem\b[^)]*\)', '', text)
+    text = re.sub(r'\b(uitofp|sitofp|fptoui|fptosi)\s+(?:(?:nnan|ninf|nsz|arcp|contract|afn|reassoc|fast)\s+)+',
+                  r'\1 ', text)
+    # LLVM 24 permits short decimal floats that the older reader rejects.
+    # Restrict conversion to unquoted literals whose nearest IR type is float/half;
+    # double literals and string attributes retain their original spelling.
+    result = []
+    decimal = re.compile(r'(?<![\w.])[-+]?\d+\.\d+(?:[eE][-+]?\d+)?(?![\w.])')
+    for line in text.splitlines():
+        pieces = re.split(r'("(?:[^"\\]|\\.)*")', line)
+        for index in range(0, len(pieces), 2):
+            piece = pieces[index]
+            def convert(match):
+                types = re.findall(r'\b(float|double|half|bfloat|fp128|i\d+)\b', piece[:match.start()])
+                if not types or types[-1] not in ('float', 'half'):
+                    return match[0]
+                if types[-1] == 'half':
+                    bits = struct.unpack('>H', struct.pack('>e', float(match[0])))[0]
+                    return f'0xH{bits:04X}'
+                bits = struct.unpack('>I', struct.pack('>f', float(match[0])))[0]
+                return float_hex(re.match(r'(.*)', f'{bits:08X}'))
+            pieces[index] = decimal.sub(convert, piece)
+        result.append(''.join(pieces))
+    return '\n'.join(result) + '\n'
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('input', type=Path)
+    parser.add_argument('output', type=Path)
+    args = parser.parse_args()
+    args.output.write_text(compatible_ir(args.input.read_text()))