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.

docs/windows-local-package.md

@@ -1,6 +1,150 @@
 # Local gfx1101 drop-in package
 
-## Current local development package: v4
+## Current local development package: v14 (2026-10-17)
+
+`build/d4r-windows-gfx1101-local-v14.zip`, 133,240,107 bytes, SHA256
+`2f88dec3b4086371efefa8fbfa316c3f7b86fb7858ca1c1bdee63146056f7edf`.
+Every manifest hash and the exact ZIP entry set verify. It adds strict DS lane exchange in all eleven K objects
+and FSR-only RGBA32F output with temporal format switching. The original FSR denoiser payload is unchanged;
+compiler/subgroup/rounding trials produced no reliable gain. v13 and older packages remain preserved.
+
+Actual fresh extraction, architecture loader and player INI: K control/candidate/candidate/control passes 64 exact
+frames per size. Warmed CPU interop medians are 3.900 -> 3.3915 ms at 1080p and 5.4015 -> 4.820 ms at 1440p,
+about 13%/11% faster. These include CPU synchronization/copies/NGX and are separate from standalone HIP GPU
+timestamps (1.812/2.885 ms). The HIP runner/private model is not in the ZIP.
+
+FSR-only test through the fresh loader passes 24 moving-camera frames with alternating float guides and half/float
+output, typeless D32S8 and preserved stencil. Every output component equals the same-frame composed half result,
+widened independently where needed. FSR+SR dynamic regression passes another 24 frames, retained resources and
+minimum-bound rejections. Native RR passes six exact camera/reset frames with contracts and enhanced/inherited
+states. Evidence: `build/k-ds-local-v14-{1080,1440}-v1/`, `build/fsr-local-v14-format-switch-v1/`,
+`build/fsr-local-v14-dynamic-sr-v1/`, `build/rr-native-local-v14-regression-v1/`.
+
+All execution is synthetic on gfx1101. Full install.bat was not rerun, and no game, driver/security/GPU setting,
+commit, branch, PR or publication was involved. Linux targets, FSR denoiser speed, broader encodings/alpha/reference
+quality and the original remaining parity gaps are not declared complete. This ends the user's narrowed pass.
+
+## Preserved v13 package evidence
+
+`build/d4r-windows-gfx1101-local-v13.zip`, 133,239,594 bytes, SHA256
+`b2ff1157e27b9353afcf287fa8df011c7efa119ac4e26ab7746166ff87b05b34`.
+Every manifest hash verifies. This is v12 plus FSR/SR dynamic render-size support within the loaded SR library's
+queried bounds. Below-minimum sizes reject before command recording. The three fixed K objects remain included;
+the HIP standalone K engine/model is still outside the package. All older packages remain preserved.
+
+Fresh-extracted architecture loader/INI passes 24 moving-camera dynamic FSR+SR frames, including both below-minimum
+axis rejections, retained input resources and all SR submissions (`build/fsr-rr-local-v13-dynamic-bounds-v1/`).
+Native RR regression passes six exact camera/reset frames with contracts and enhanced/inherited states
+(`build/rr-native-local-v13-dynamic-regression-v1/`). These are synthetic tests with separately staged dependencies.
+
+Full `install.bat` was not rerun: the NGX core is absent from the download cache and would require the 945 MiB
+driver archive. No driver runs, game interaction, commit or publication occurred. See `windows-fsr-rr.md` and the
+newest checklist entry for exact synthetic coverage and remaining limits. Real-game/reference-quality and Linux
+performance parity remain unverified.
+
+## Preserved v8 package evidence
+
+`build/d4r-windows-gfx1101-local-v8.zip` is 130,975,742 bytes; SHA256
+`962530d1a914268cc6f9d2ec908185f8e4d9e5baafca6800d77ebc3281a647fe`.
+It adds GPU RGBA32F RR output conversion and temporal RGBA16F/RGBA32F output
+switching to v7 coverage. Packaged loader/INI E passes 12 exact evaluations
+across two live features, inverted D32S8 and unchanged stencil. Float32 results
+match widened standalone half output; this is synthetic engine consistency,
+not NVIDIA reference quality or game/timing parity.
+
+Installer still installs pinned SR, RR DLL and NGX core through bundled Python,
+with optional D/E model generation/deployment. No NVIDIA DLL, private K override
+or generated model is bundled. Every ZIP manifest hash verifies. Evidence:
+`build/d4r-windows-gfx1101-local-v8.validation.json` and
+`build/rr-ngx-local-v8-output-switch-e-v1/summary.json`. Other output encodings,
+external exposure, FSR execution, K timing parity and original engine gaps remain.
+
+## Preserved v7 package evidence
+
+`build/d4r-windows-gfx1101-local-v7.zip` is 130,973,094 bytes; SHA256
+`b7c68e6f6148c648b6e8e6f47362e0d5f0f6c6796d651d1e762a80d8f07e8d54`.
+It retains the v6 native Python installer/clean portable tools and adds native
+RR dynamic render-size handling. NVIDIA SR/RR/core DLLs still download locally;
+no NVIDIA binary, private K override or RR model is bundled. All final manifest
+hashes verify. Older ZIPs are preserved.
+
+Native RR supports per-frame render dimensions from 64 pixels through creation
+size, with fixed output size and implicit history reset on dimension changes.
+Model weights/pipelines and the shared packet/fence remain loaded. Packaged
+loader/INI E tests pass 16 exact evaluations across two live features and changing
+sizes, both with resized input textures and retained creation-sized textures.
+Six static D depth/format-switch frames also pass. These are synthetic engine
+consistency checks, not NVIDIA reference quality, real-game RR or timing parity.
+See `windows-rr-interop.md` for coverage and limitations. Evidence:
+`build/d4r-windows-gfx1101-local-v7.validation.json` and
+`build/rr-ngx-local-v7-dynamic-two-e-v1/`,
+`build/rr-ngx-local-v7-max-dynamic-two-e-v1/`, and
+`build/rr-ngx-local-v7-static-regression-v2/`.
+
+## Preserved v6 package evidence
+
+`build/d4r-windows-gfx1101-local-v6.zip` is 130,970,436 bytes; SHA256
+`a144185823af334483543d4989584d65cfa0418049e56fb8e58410b91ae8700b`.
+It adds the pristine portable-tools v2 inputs and native Python dependency
+installer to the verified runtime. Every ZIP manifest hash verifies. No NVIDIA
+DLL, private K override or generated RR model is bundled. All earlier ZIPs,
+including intermediate v5, remain preserved. V5 lacks the final README update;
+use v6 for the documented installer flow.
+
+Extract beside the game executable and run `install.bat`. The batch wrapper
+uses bundled isolated Python, without PowerShell, system Python or Git Bash.
+It installs pinned SR 310.9.1 at `d4r/dlss/nvngx_dlss.dll`, RR 310.9.1 at
+`d4r/rr/nvngx_dlssd.dll`, and 617.14 core at `d4r/ngx/_nvngx.dll`. Driver archive
+is only extracted, never executed. The Python installer retains the exact
+existing PowerShell installer URLs and SHA256 pins. Hash identity excludes old
+596.36 core fixtures.
+
+Choose N to retain existing RR settings. Optional D/E selection builds and
+enables a private exact gfx1101 model. Tool inputs copy by manifest into the
+external cache; generated products remain there and in a versioned private
+runtime model directory. Existing models remain intact. Configuration selection
+preserves comments/BOM/newlines and creates an exact external INI backup.
+Model failure leaves verified DLLs installed and does not select an incomplete
+model. Automatic RR building currently requires a gfx1101-only package.
+
+DLL replacement first stages and verifies all changes and external original
+backups. Replacement failure rolls back applied entries; concurrent edits are
+preserved. Reruns skip matching DLLs and reuse only verified model products.
+`install.bat --yes --offline --cache-root PATH --backup-root PATH` supports
+preverified DLL caches. Add `--rr-preset D` or `E` and `--enable-rr` for model
+generation/selection without the interactive prompts. Cache and backups must
+stay outside the game directory.
+
+Validation uses ignored mock game folders only:
+
+- Eight CPU tests cover preservation, rollback including newly created files,
+  concurrent edits, cache rejection, pin parity and manifest-only tool copying.
+- Actual v5 batch wrapper builds/deploys D in 48 steps, verifies 66 model
+  products, exact DLL/INI backups, unrelated-file preservation and an unchanged
+  repeat. E also completes its actual 48-step installer path.
+- Actual v6 ZIP interactive default installs all three pinned DLLs while
+  declining model generation leaves INI unchanged. E cache reuse/deployment,
+  repeat safety and tampered-tool rejection with unchanged runtime hashes pass.
+- Native downloader fetches verified official 7-Zip, reuses the hash-verified
+  617.14 driver archive and extracts a core matching its exact pin. No driver runs.
+- Installer-deployed E selected solely through INI passes six exact synthetic
+  NGX hardware-depth frames through the packaged architecture loader, with
+  optional guides, enhanced/inherited access and stencil preservation. This is
+  engine consistency, not NVIDIA quality reference or real-game RR evidence.
+
+Evidence: `build/native-installer-v1/validation.json`,
+`build/native-installer-v2/validation.json`,
+`build/native-installer-download-v1/validation.json`,
+`build/rr-ngx-native-installer-e-v1/summary.json`, and
+`build/d4r-windows-gfx1101-local-v6.validation.json`. The final v6 fixture also
+passes the same six exact E frames:
+`build/rr-ngx-local-v6-installer-e-v1/summary.json`. Modified PowerShell release
+packager passed static parser validation; its fixture suite was not rerun under
+the recorded script policy. No policy bypass, game access, commit, publication
+or system setting change occurred. FSR execution, broad game/quality validation,
+K timing parity and remaining original engine requirements remain open.
+
+## Preserved v4 package evidence
 
 `build/d4r-windows-gfx1101-local-v4.zip` is 90,720,715 bytes; SHA256
 `74fbb4c78dba3e616b9bbba7dc1fe4cddf0a17855968b174f8ea69968d873dfc`.
@@ -96,3 +240,38 @@ depth and high-resolution motion vectors; other variants retain the normal path.
 The workflow output under `build/k-native-cache-workflow/native` is byte-identical
 to the previously validated 17-object candidate. The new player-mode smoke loaded
 that directory. These NVIDIA-derived objects stay local and are absent from V3.
+
+## Local v9: experimental FSR RR payload (2026-10-17)
+
+`build/d4r-windows-gfx1101-local-v9.zip`, 133,200,126 bytes, SHA256
+`332719443a9b050e6a5b479816a81fb4d3e482a8956e2c20f2596904f7f6152d`. Built by `tools/windows/refresh_local_package.py`
+from the verified v8 ZIP (`--fsr-payload build/fsr-payload-v1`); all manifest hashes verified; v2-v8 preserved.
+
+Added over v8: the shim with the FSR RR backend and its Super Sampling stage (`d4r/_nvngx_gfx1101.dll`);
+`d4r/fsr/d4r_vkd3d_core.dll` (vkd3d-proton built by `tools/windows/build_fsr_payload.py`, LGPL-2.1, source offer
+and patches in `d4r/fsr/SOURCE.txt` and `d4r/fsr/patches/`) and `d4r/fsr/amdxc64.dll` (d4r's capability shim, not AMD
+software); vkd3d-proton, dxil-spirv and dxbc-spirv licence texts in `d4r/licenses/`; `install.bat` with an [F]SR
+choice and `install-dependencies.py --enable-fsr` / `--install-fsr` (AMD's denoiser, SHA256 `48f1e588...`, is
+downloaded hash-verified, backed up and rolled back like the NVIDIA DLLs, and `Backend = fsr` is written to
+`d4r.ini` with an external backup); `d4r.ini` key `[RayReconstruction] FsrDenoiser`; README text.
+
+Still not bundled: NVIDIA DLLs, any RR/K model, AMD's denoiser. FSR RR is off by default.
+
+Verification (synthetic only, no game): ZIP extracted fresh and `test_fsr_rr_ngx.py` run against the extracted files
+(`build/fsr-rr-ngx-upscale-v9-v1`: PASS, SR used, RMSE 0.289 vs 0.581 noisy input); release-package test PASS
+cases=7 including FSR payload accept/reject cases (`build/release-package-fsr-v1`); installer unit tests 12 OK;
+player-config test PASS cases=2; installer FSR path run for real on the extracted copy (AMD DLL downloaded,
+hash matched, installed, single `Backend` line changed, backup equals original, second run changes nothing).
+A full `install.bat` run was not repeated: the NGX core is not in the local download cache and would pull the
+945 MiB driver archive. The new K work (HIP network, authentic K model) is NOT in v9.
+
+## Local v11: v9 plus FSR tuning, GPU timing and dynamic-size refusal (2026-10-17)
+
+`build/d4r-windows-gfx1101-local-v11.zip`, 133,236,207 bytes, SHA256
+`ba91dd6cc178865244c9903a461f213cdcacf38bcf6905e919ba5e8ee652b228`; built the same way as v9 (verified v8 base,
+`--fsr-payload build/fsr-payload-v1`), all hashes verified. v9 and an intermediate v10 are preserved but superseded.
+Differences from v9: `d4r.ini` keys `FsrStabilityBias` (default auto) and `FsrDetail`; the shim's GPU-timestamp log
+(`D4R_FSR_RR_LOG`), motion/depth dump diagnostic, tuning keys, exposure handled by the SR stage, and a clean refusal
+of render sizes below the creation size. Validated from a fresh extraction with `test_fsr_rr_ngx.py`: static
+same-size 0.127 (noisy 0.485), moving 640x360 -> 1280x720 0.2135 (noisy 0.554), moving same-size 0.1069 (noisy 0.486);
+all use SR. Synthetic only, no game. The HIP K network and authentic K model are NOT in this package.