TL;DR: Add an experimental FSR Ray Regeneration backend on Windows, run the K

network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.

Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling

FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
  compose compute shaders. They run AMD's FidelityFX denoiser
  (amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
  vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
  patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
  backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
  runs an internal Super Sampling stage (feature 1) to upscale. If SR is
  unavailable and output != render size, the frame fails; it is never
  returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
  FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
  matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
  compile script.

Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
  because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
  (VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
  intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
  D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
  replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
  longer require near2rnd == out2rnd. Both values must still be in (0, 1].

K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
  (D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
  its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
  wave could overwrite its hb rows while a slower wave still read them for a
  later head, giving rare wrong results on gfx1101 (enc0 outputs differing
  between identical launches).

Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
  install_dependencies.py to install pinned NVIDIA dependencies with staged,
  hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
  on some synthetic runs, but player temporal exactness is unresolved.

Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
  benchmark_k_hip, build_capture_runtime, test_k_model and the
  zluda-k-output-capture patch. Captured weights and models are private
  local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
  prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.

Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
  rr-model-cache docs. Add windows-parity-handoff.md and
  windows-parity-continuation-prompt.md.

tools/windows/benchmark_k_interop.py

@@ -11,6 +11,7 @@ from pathlib import Path
 import re
 import statistics
 import subprocess
+import shutil
 
 
 def main():
@@ -24,9 +25,17 @@ def main():
                         help='diagnostic CPU stage logging; adds overhead to timings')
     parser.add_argument('--candidate-native', type=lambda s: Path(s).resolve(),
                         help='compare an experimental native directory instead of input batching')
+    parser.add_argument('--control-native', type=lambda s: Path(s).resolve(),
+                        help='use an explicit verified control kernel directory while retaining runtime dependencies')
+    parser.add_argument('--player-config', action='store_true', help='select batching/native paths through staged player INI')
+    parser.add_argument('--sequence', choices=('abba', 'controls', 'batches'), default='abba',
+                        help='paired comparison, or repeated identical settings to diagnose baseline determinism')
+    parser.add_argument('--reset-every-frame', action='store_true', help='diagnose history dependence; not representative temporal performance')
     parser.add_argument('--profile-kernels', action='store_true',
                         help='diagnostic deferred GPU events, allowing legacy-stream dependencies; timings are instrumented')
     args = parser.parse_args()
+    if args.player_config and (args.profile_stages or args.profile_kernels):
+        parser.error('player mode clears diagnostic profiling flags; use a separate instrumented run')
     if args.frames < 8 or args.frames > 120:
         parser.error('frames must be 8..120')
     if not re.fullmatch(r'[1-9][0-9]*x[1-9][0-9]*', args.resolution):
@@ -50,6 +59,21 @@ def main():
     native = runtime / 'native'
     if (native / 'gfx1101').is_dir():
         native = native / 'gfx1101'
+    if args.control_native:
+        native = args.control_native
+    report['playerConfig'] = args.player_config
+    report['sequence'] = args.sequence
+    report['resetEveryFrame'] = args.reset_every_frame
+    module = args.shim
+    if args.player_config:
+        runtime = args.output / 'player'
+        shutil.copytree(args.runtime, runtime)
+        module = runtime / 'd4r_nvngx.dll'
+        shutil.copy2(args.shim, module)
+        for source, relative in ((args.core, 'ngx/_nvngx.dll'), (args.dlss, 'dlss/nvngx_dlss.dll')):
+            destination = runtime / relative
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source, destination)
     nvapi = runtime / 'nvapi/nvapi64.dll'
     if not nvapi.is_file():
         nvapi = runtime / 'nvapi/gfx1101/nvapi64.dll'
@@ -82,7 +106,8 @@ def main():
                    D4R_ZLUDA_PROFILE_EVERY='1')
     try:
         reference = None
-        for index, batched in enumerate((False, True, True, False)):
+        variants = {'abba': (False, True, True, False), 'controls': (False,) * 4, 'batches': (True,) * 4}
+        for index, batched in enumerate(variants[args.sequence]):
             label = ('native-candidate' if args.candidate_native else 'batch') if batched else 'control'
             output = args.output / f'{index}-{label}'
             output.mkdir()
@@ -92,17 +117,32 @@ def main():
             else:
                 env.pop('D4R_BATCH_INPUT_COPIES', None)
             env['D4R_ZLUDA_NATIVE_DIR'] = str(args.candidate_native if batched and args.candidate_native else native)
-            command = [str(args.probe), '--module', str(args.shim), '--hip-root', str(runtime / 'hip'),
+            if args.player_config:
+                config = (Path(__file__).resolve().parents[2] / 'packaging/windows/d4r.ini').read_text()
+                config = re.sub(r'(?m)^BatchInputCopies\s*=\s*(?:true|false)\s*$',
+                                'BatchInputCopies = ' + str(batched and not args.candidate_native).lower(), config)
+                selected_native = args.candidate_native if batched and args.candidate_native else native
+                config = config.replace('NativeDir = auto', 'NativeDir = ' + str(selected_native))
+                (runtime / 'd4r.ini').write_text(config)
+            command = [str(args.probe), '--module', str(module), '--hip-root', str(runtime / 'hip'),
                        '--cuda-dll', str(runtime / 'zluda/nvcuda.dll'), '--ngx-core', str(args.core),
                        '--dlss-dll', str(args.dlss), '--nvapi-dll', str(nvapi),
                        '--ngx-abi', 'project', '--interop-mode', 'command-list', '--preset', '11',
                        '--ngx-output-resolution', args.resolution,
                        '--ngx-input-resolution', args.input_resolution, '--iterations', str(args.frames)]
+            if args.player_config:
+                command += ['--player-mode', '1']
+            if args.reset_every_frame:
+                command += ['--reset-every-frame', '1']
             with (output / 'stdout.log').open('wb') as out, (output / 'stderr.log').open('wb') as err:
                 result = subprocess.run(command, env=env, stdout=out, stderr=err, timeout=180)
+            if args.player_config and (runtime / 'd4r_nvngx.log').exists():
+                shutil.copy2(runtime / 'd4r_nvngx.log', output / 'player.log')
             text = (output / 'stdout.log').read_text(errors='replace')
             if result.returncode or 'PASS D3D12_DLSS' not in text:
                 raise RuntimeError(f'run {index} failed ({result.returncode}); inspect {output}')
+            if args.reset_every_frame and 'D3D12_RESET every_frame=1' not in text:
+                raise RuntimeError('Requested reset diagnostic was not applied')
             iw, ih = map(int, args.input_resolution.split('x'))
             expected_size = f'D3D12_NGX_DIMENSIONS input={iw}x{ih} output={ow}x{oh}'
             if expected_size not in text or f'D4R_INTEROP async=0 batch_inputs={int(batched and not args.candidate_native)}' not in text:
@@ -118,6 +158,9 @@ def main():
             if reference is None:
                 reference = hashes
             elif hashes != reference:
+                report['mismatchRun'] = index
+                report['differentFrames'] = [name for name, digest in hashes.items() if reference.get(name) != digest]
+                report['mismatchedOutputHashes'] = hashes
                 raise RuntimeError(f'run {index}: output differs from control')
             report['runs'].append({'batch': batched and not bool(args.candidate_native),
                                    'candidate': batched, 'allFrameMs': times,
@@ -125,6 +168,8 @@ def main():
             print(f'run={index} variant={label} warmed_cpu_interop_ms={statistics.median(times[4:]):.3f}', flush=True)
         for mode in (False, True):
             values = [t for row in report['runs'] if row['candidate'] == mode for t in row['allFrameMs'][4:]]
+            if not values:
+                continue
             key = ('candidateMedianMs' if args.candidate_native else 'batchMedianMs') if mode else 'controlMedianMs'
             report[key] = statistics.median(values)
         report['passed'] = True