fix(vk): keep sparse textures off the GPU unswizzle and disturb descriptors at its bind #925

Open
jcabarca wants to merge 2 commits from jcabarca/Longshot:fix/vk-unswizzle-sparse into main
Contributor

Type: fix · Risk: low · Tested on: Windows, AMD Radeon RX 9070 XT · Needs: none

Why

The GPU unswizzle stored large textures into sparse images whose blocks had no memory bound yet; stores into an unbound sparse block are dropped, so those textures stayed black or empty. It also left the draw state thinking its compute descriptors were still bound when a level's view failed and the CPU path took over.

How to reproduce

Seen on: not seen in the game: found by reading upload_unswizzle_gpu() in gpu/vk/vk_texture.cpp; it happens for any sparse texture of 8 MiB or more that takes the GPU unswizzle
Settings and switches: defaults
Steps: game-free: python -I -B tests/test_unswizzle_gpu_guards.py --source <main checkout> (the test from this PR); it reads upload_unswizzle_gpu()
Expected: sparse textures take the CPU path, which binds their blocks; descriptors_disturbed() is called right after unsw_pipe is bound
Actual: on main sparse textures take the GPU path, and descriptors_disturbed() comes only at the end, after the return false of a failed view; the test fails with both problems

What changed

upload_unswizzle_gpu() returns false (not a texture for it) for sparse textures, and calls descriptors_disturbed() right after it binds unsw_pipe instead of at its end.

  • vk: upload_unswizzle_gpu() in gpu/vk/vk_texture.cpp:
    • tex.sparse joins the first guard, with the other kinds of texture it already refuses (ASTC, BC, depth, linear, not 2D, no storage usage).
    • descriptors_disturbed() moved from after the last full_barrier(cmd) to right after vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe).
  • tests: tests/test_unswizzle_gpu_guards.py (new).

The bug, step by step:

  1. upload_inner() tries upload_unswizzle_gpu() first for a big 2D texture: a compute shader reads the swizzled guest data and stores the texels into a storage view of the image.
  2. A sparse image has memory only in the blocks sparse_flush() has bound. The CPU path queues and binds the blocks it writes (texture_resident_queue, texture_resident_flush); the GPU unswizzle binds nothing.
  3. A store into an unbound sparse block is discarded, so the texture's texels never land.
  4. Separately: the function binds unsw_pipe and pushes its descriptors on the upload command buffer, which is the recording's command buffer (upload_cmd()). If a level's storage view then fails, it returns false and the CPU path takes over, but descriptors_disturbed() was only reached at the very end, so the draw state's push-descriptor cache (pushed()) still believed its own compute bindings were there.
  5. The next compute dispatch could then skip re-pushing its descriptors and run with the unswizzle's bindings.

The rules: the first problem is a dropped write, not a broken rule. The second can leave a dispatch with descriptors pushed for another pipeline layout, which VUID-vkCmdDispatch-None-08600 covers, from Khronos validusage.json: "If a a bound shader was created as a VkShaderEXT without the VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT flag or as part of a pipeline without the VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT flag, and that shader statically uses a set n, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline or the VkDescriptorSetLayout array used to create the current VkShaderEXT , as described in Pipeline Layout Compatibility"

Before:

    if (tex.type != VK_IMAGE_TYPE_2D || tex.astc || tex.bc || !(tex.usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
        is_bc(tex.format) || is_astc(tex.format) || is_depth_format(tex.format) || nvn_tex_is_linear(&tex.d))
        return false;
    ...
    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe);
    for (uint32_t level = 0; level < tex.levels; level++) {
        ...
    }
    full_barrier(cmd);
    descriptors_disturbed();
    return true;

After:

    // (not a sparse image: nothing here binds its blocks, and a store into an unbound one is dropped)
    if (tex.type != VK_IMAGE_TYPE_2D || tex.astc || tex.bc || tex.sparse || !(tex.usage & VK_IMAGE_USAGE_STORAGE_BIT) ||
        is_bc(tex.format) || is_astc(tex.format) || is_depth_format(tex.format) || nvn_tex_is_linear(&tex.d))
        return false;
    ...
    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe);
    descriptors_disturbed();   // (also when a view fails and the CPU path takes over)
    for (uint32_t level = 0; level < tex.levels; level++) {
        ...
    }
    full_barrier(cmd);
    return true;

Measurements

Verdict: it fixes the bug: tests/test_unswizzle_gpu_guards.py fails on main (both problems) and passes with this PR, in both interleaved runs. Sparse textures of 8 MiB or more now unswizzle on the CPU, as smaller ones already do; that is slower than the GPU path for those textures, but the GPU path's result was lost anyway.

Hardware: AMD Radeon RX 9070 XT, Windows; the test itself is game-free (it reads source, it does not use the GPU); Python 3.12
Scene: none, game-free
Method: tests/test_unswizzle_gpu_guards.py from this PR with --source set to each side's checkout, 2 runs each, interleaved (main, PR, main, PR); the result is pass/fail, so the median is the result both runs gave
How to reproduce: python -I -B tests/test_unswizzle_gpu_guards.py --source <checkout> for each side

Before: main @ b8d2b04e After: this PR @ 733a4bd6
tests/test_unswizzle_gpu_guards.py, run 1 fails passes
tests/test_unswizzle_gpu_guards.py, run 2 fails passes
Median fails passes
run 1, main @ b8d2b04e:
a sparse texture is unswizzled on the GPU into blocks no memory is bound to
a failed view returns false after unsw_pipe is bound without descriptors_disturbed()
exit 1
run 1, this PR @ 733a4bd6:
GPU unswizzle: sparse textures left to the CPU path, descriptors disturbed at the bind: ok
exit 0
run 2, main @ b8d2b04e:
a sparse texture is unswizzled on the GPU into blocks no memory is bound to
a failed view returns false after unsw_pipe is bound without descriptors_disturbed()
exit 1
run 2, this PR @ 733a4bd6:
GPU unswizzle: sparse textures left to the CPU path, descriptors disturbed at the bind: ok
exit 0

What the test checks:

  • The guard before the first return false; of upload_unswizzle_gpu() tests tex.sparse.
  • After vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe);, descriptors_disturbed(); comes before the first return false;.

Flags and settings

None.

Testing

Tested: on this branch, Windows, Python 3.12: test_unswizzle_gpu_guards passes (fails on main), and the other check that reads upload_unswizzle_gpu() passes: test_image_view_retry.

Built and played: this commit builds on Windows (llvm-mingw back end) and on Linux (longshot_vk.so, without and with AMD FSR 4). Played on Windows, AMD Radeon RX 9070 XT: the game runs normally.

Not tested: a big sparse texture uploaded in the game and looked at: not checked in the game (which textures are sparse and 8 MiB or more was not traced). Linux was built, not run.

Must be tested: None: the change is the same on every GPU and OS, and the game-free test covers it.

Risks

What could break: big sparse textures take the CPU unswizzle, which is slower than the GPU one; the first upload of such a texture may take longer. Non-sparse textures are unchanged. Draws after a successful GPU unswizzle re-push their descriptors as before; after a failed one they now do too.

Turning it off: revert the commit.

Compatibility: Nothing changes.

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched). (no issue fits)
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named). (the checks that read the changed code, on this PR, Windows: test_unswizzle_gpu_guards, test_image_view_retry, all pass)
  • No game files, dumps, build output or generated files.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • A game-free test added for the fix, failing on main and passing here. (tests/test_unswizzle_gpu_guards.py)
  • A check under tests/ that reads changed source updated in this PR, not weakened. (tests/test_unswizzle_gpu_guards.py added; no check removed)
  • Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (built on Windows with llvm-mingw and on Linux, longshot_vk.so without and with AMD FSR 4; no OS-specific code or paths)
**Type:** fix · **Risk:** low · **Tested on:** Windows, AMD Radeon RX 9070 XT · **Needs:** none ## Why The GPU unswizzle stored large textures into sparse images whose blocks had no memory bound yet; stores into an unbound sparse block are dropped, so those textures stayed black or empty. It also left the draw state thinking its compute descriptors were still bound when a level's view failed and the CPU path took over. ## How to reproduce **Seen on:** not seen in the game: found by reading `upload_unswizzle_gpu()` in `gpu/vk/vk_texture.cpp`; it happens for any sparse texture of 8 MiB or more that takes the GPU unswizzle **Settings and switches:** defaults **Steps:** game-free: `python -I -B tests/test_unswizzle_gpu_guards.py --source <main checkout>` (the test from this PR); it reads `upload_unswizzle_gpu()` **Expected:** sparse textures take the CPU path, which binds their blocks; `descriptors_disturbed()` is called right after `unsw_pipe` is bound **Actual:** on main sparse textures take the GPU path, and `descriptors_disturbed()` comes only at the end, after the `return false` of a failed view; the test fails with both problems ## What changed `upload_unswizzle_gpu()` returns `false` (not a texture for it) for sparse textures, and calls `descriptors_disturbed()` right after it binds `unsw_pipe` instead of at its end. - vk: `upload_unswizzle_gpu()` in `gpu/vk/vk_texture.cpp`: - `tex.sparse` joins the first guard, with the other kinds of texture it already refuses (ASTC, BC, depth, linear, not 2D, no storage usage). - `descriptors_disturbed()` moved from after the last `full_barrier(cmd)` to right after `vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe)`. - tests: `tests/test_unswizzle_gpu_guards.py` (new). The bug, step by step: 1. `upload_inner()` tries `upload_unswizzle_gpu()` first for a big 2D texture: a compute shader reads the swizzled guest data and stores the texels into a storage view of the image. 2. A sparse image has memory only in the blocks `sparse_flush()` has bound. The CPU path queues and binds the blocks it writes (`texture_resident_queue`, `texture_resident_flush`); the GPU unswizzle binds nothing. 3. A store into an unbound sparse block is discarded, so the texture's texels never land. 4. Separately: the function binds `unsw_pipe` and pushes its descriptors on the upload command buffer, which is the recording's command buffer (`upload_cmd()`). If a level's storage view then fails, it returns `false` and the CPU path takes over, but `descriptors_disturbed()` was only reached at the very end, so the draw state's push-descriptor cache (`pushed()`) still believed its own compute bindings were there. 5. The next compute dispatch could then skip re-pushing its descriptors and run with the unswizzle's bindings. The rules: the first problem is a dropped write, not a broken rule. The second can leave a dispatch with descriptors pushed for another pipeline layout, which VUID-vkCmdDispatch-None-08600 covers, from Khronos `validusage.json`: "If a a bound shader was created as a VkShaderEXT without the VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT flag or as part of a pipeline without the VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT flag, and that shader statically uses a set n, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline or the VkDescriptorSetLayout array used to create the current VkShaderEXT , as described in Pipeline Layout Compatibility" Before: ```cpp if (tex.type != VK_IMAGE_TYPE_2D || tex.astc || tex.bc || !(tex.usage & VK_IMAGE_USAGE_STORAGE_BIT) || is_bc(tex.format) || is_astc(tex.format) || is_depth_format(tex.format) || nvn_tex_is_linear(&tex.d)) return false; ... vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe); for (uint32_t level = 0; level < tex.levels; level++) { ... } full_barrier(cmd); descriptors_disturbed(); return true; ``` After: ```cpp // (not a sparse image: nothing here binds its blocks, and a store into an unbound one is dropped) if (tex.type != VK_IMAGE_TYPE_2D || tex.astc || tex.bc || tex.sparse || !(tex.usage & VK_IMAGE_USAGE_STORAGE_BIT) || is_bc(tex.format) || is_astc(tex.format) || is_depth_format(tex.format) || nvn_tex_is_linear(&tex.d)) return false; ... vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe); descriptors_disturbed(); // (also when a view fails and the CPU path takes over) for (uint32_t level = 0; level < tex.levels; level++) { ... } full_barrier(cmd); return true; ``` ## Measurements **Verdict:** it fixes the bug: `tests/test_unswizzle_gpu_guards.py` fails on main (both problems) and passes with this PR, in both interleaved runs. Sparse textures of 8 MiB or more now unswizzle on the CPU, as smaller ones already do; that is slower than the GPU path for those textures, but the GPU path's result was lost anyway. Hardware: AMD Radeon RX 9070 XT, Windows; the test itself is game-free (it reads source, it does not use the GPU); Python 3.12 Scene: none, game-free Method: `tests/test_unswizzle_gpu_guards.py` from this PR with `--source` set to each side's checkout, 2 runs each, interleaved (main, PR, main, PR); the result is pass/fail, so the median is the result both runs gave How to reproduce: `python -I -B tests/test_unswizzle_gpu_guards.py --source <checkout>` for each side | | Before: main @ b8d2b04e | After: this PR @ 733a4bd6 | |---|---|---| | `tests/test_unswizzle_gpu_guards.py`, run 1 | fails | passes | | `tests/test_unswizzle_gpu_guards.py`, run 2 | fails | passes | | Median | fails | passes | ``` run 1, main @ b8d2b04e: a sparse texture is unswizzled on the GPU into blocks no memory is bound to a failed view returns false after unsw_pipe is bound without descriptors_disturbed() exit 1 run 1, this PR @ 733a4bd6: GPU unswizzle: sparse textures left to the CPU path, descriptors disturbed at the bind: ok exit 0 run 2, main @ b8d2b04e: a sparse texture is unswizzled on the GPU into blocks no memory is bound to a failed view returns false after unsw_pipe is bound without descriptors_disturbed() exit 1 run 2, this PR @ 733a4bd6: GPU unswizzle: sparse textures left to the CPU path, descriptors disturbed at the bind: ok exit 0 ``` What the test checks: - The guard before the first `return false;` of `upload_unswizzle_gpu()` tests `tex.sparse`. - After `vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, unsw_pipe);`, `descriptors_disturbed();` comes before the first `return false;`. ### Flags and settings None. ## Testing **Tested:** on this branch, Windows, Python 3.12: `test_unswizzle_gpu_guards` passes (fails on main), and the other check that reads `upload_unswizzle_gpu()` passes: `test_image_view_retry`. **Built and played:** this commit builds on Windows (llvm-mingw back end) and on Linux (`longshot_vk.so`, without and with AMD FSR 4). Played on Windows, AMD Radeon RX 9070 XT: the game runs normally. **Not tested:** a big sparse texture uploaded in the game and looked at: not checked in the game (which textures are sparse and 8 MiB or more was not traced). Linux was built, not run. **Must be tested:** None: the change is the same on every GPU and OS, and the game-free test covers it. ## Risks **What could break:** big sparse textures take the CPU unswizzle, which is slower than the GPU one; the first upload of such a texture may take longer. Non-sparse textures are unchanged. Draws after a successful GPU unswizzle re-push their descriptors as before; after a failed one they now do too. **Turning it off:** revert the commit. **Compatibility:** Nothing changes. ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). (no issue fits) - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). (the checks that read the changed code, on this PR, Windows: `test_unswizzle_gpu_guards`, `test_image_view_retry`, all pass) - [x] No game files, dumps, build output or generated files. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [x] A game-free test added for the fix, failing on `main` and passing here. (`tests/test_unswizzle_gpu_guards.py`) - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. (`tests/test_unswizzle_gpu_guards.py` added; no check removed) - [x] Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (built on Windows with llvm-mingw and on Linux, `longshot_vk.so` without and with AMD FSR 4; no OS-specific code or paths)
fix(vk): keep sparse textures off the GPU unswizzle and disturb descriptors at its bind
Some checks failed
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 3s
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
733a4bd670
upload_unswizzle_gpu stored into sparse images whose blocks nothing had bound yet (the stores were dropped); they now take the CPU path, which binds them. It also bound unsw_pipe and pushed descriptors but called descriptors_disturbed() only at the end, so a failed view returned false to the CPU path with the draw state unaware; it is now called right after the bind. tests/test_unswizzle_gpu_guards.py checks both.

Assisted-by: GitHub Copilot
jcabarca changed title from WIP: fix(vk): keep sparse textures off the GPU unswizzle and disturb descriptors at its bind to fix(vk): keep sparse textures off the GPU unswizzle and disturb descriptors at its bind 2026-11-15 21:00:23 +00:00
Member

Code-only review of 733a4bd670; informational findings, with final approval left to another reviewer.

No introduced correctness defect found in the two runtime changes. The early sparse guard preserves the existing CPU upload route that queues residency before copies. Moving descriptors_disturbed() immediately after the compute bind covers failed view creation as well as successful completion; it clears both cached command-buffer identities, so subsequent descriptor binding cannot trust the previous cache entry.

The remaining gap is targeted validation. The reported Windows RX 9070 XT playthrough and Windows/Linux builds are useful, but the description explicitly says no large sparse upload was traced. The new test checks source tokens and ordering; it does not exercise sparse residency or failed-view fallback. In particular, replacing || tex.sparse with || !tex.sparse would still satisfy its sparse-token assertion. A behavioral fixture should check sparse rejection before any GPU bind and descriptor invalidation when view creation fails, including failure after an earlier mip dispatched. For runtime evidence, identify an affected sparse upload and check its resulting texture and first-upload hitch behavior; a general playthrough does not establish that this path ran.

Merge coordination: #671 fixes sparse BC image-creation usage, while this PR excludes sparse images from the uncompressed GPU unswizzle path. These are complementary, not duplicate fixes.

Read the complete diff, upload fallback/residency and descriptor-cache code, and the view-retry test. No tests, builds, or game runs were performed in this review.

Code-only review of 733a4bd6709af74e10b750012a3473bb407b8c1d; informational findings, with final approval left to another reviewer. No introduced correctness defect found in the two runtime changes. The early sparse guard preserves the existing CPU upload route that queues residency before copies. Moving `descriptors_disturbed()` immediately after the compute bind covers failed view creation as well as successful completion; it clears both cached command-buffer identities, so subsequent descriptor binding cannot trust the previous cache entry. The remaining gap is targeted validation. The reported Windows RX 9070 XT playthrough and Windows/Linux builds are useful, but the description explicitly says no large sparse upload was traced. The new test checks source tokens and ordering; it does not exercise sparse residency or failed-view fallback. In particular, replacing `|| tex.sparse` with `|| !tex.sparse` would still satisfy its sparse-token assertion. A behavioral fixture should check sparse rejection before any GPU bind and descriptor invalidation when view creation fails, including failure after an earlier mip dispatched. For runtime evidence, identify an affected sparse upload and check its resulting texture and first-upload hitch behavior; a general playthrough does not establish that this path ran. Merge coordination: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/671 fixes sparse BC image-creation usage, while this PR excludes sparse images from the uncompressed GPU unswizzle path. These are complementary, not duplicate fixes. Read the complete diff, upload fallback/residency and descriptor-cache code, and the view-retry test. No tests, builds, or game runs were performed in this review.
Merge branch 'main' into fix/vk-unswizzle-sparse
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 6s
5526a4d0d2
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 6s
This pull request doesn't have enough approvals yet. 0 of 1 approvals granted.
Some workflows are waiting to be reviewed.
This branch is out-of-date with the base branch
You are not authorized to merge this pull request.
View command line instructions

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'fix/vk-unswizzle-sparse:jcabarca-fix/vk-unswizzle-sparse'
git switch 'jcabarca-fix/vk-unswizzle-sparse'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!925
No description provided.