feat(steam): Play goes through the tile when Steam is up, so the Deck's controller is a controller #151

Open
omgitsgela wants to merge 31 commits from omgitsgela/LongshotLauncher:feat/play-through-steam-tile into main
Contributor

Status

Feature (fresh-install controller input), ready for review. Stacked on #130 (this forge will not take a cross-fork base, so the diff against main also carries #130's commits): review the routing commits, a4cf225 + d4e5545 + 6dcaf56 + 46ac7e7 + d727c90, 6bb9906, only. Merge #130 first and this PR's diff collapses to just those.

Why

On a fresh Deck, Steam Input only treats Longshot as a game when Steam launched it. Play from the launcher's own button starts the game direct, and under a running Steam the Deck's buttons then run Steam's default desktop layout — mouse and keyboard — which is the usual fresh-install complaint (the game's own host/steam_pads.h deliberately hides Steam's virtual gamepads and re-adds the physical one only under a real steam_input device, which exists only for Steam-launched games). So make Play go through Steam whenever that layer is available, and never touch global settings, controller configs, or sudo.

What changes

  • Core/SteamLaunchRoute.cs (new): the decision. Linux + outside a gamescope session + Steam up (SteamShortcuts.SteamUp, /proc scan) + our tile in its library (InLibrary) + that library loaded by the running Steam (LibraryLoaded: newest running Steam's start time vs the file's write time — Steam holds its library in memory from its own start, measured Deck 2026-11-15) → hand off steam://rungameid/<64-bit form of the tile's CARRIED id> via xdg-open. Carried, not freshly computed: after a launcher update the library tile keeps its id (found by marker) and a URI naming the new path's id addresses a tile Steam has never loaded; TileAppId already draws that distinction. The id rule — (unsigned appid << 32) | 0x02000000 — is the same GridId64 this class already uses for capsule names, verified working on the Deck by steam-for-linux#8580 and SteamTinkerLaunch#1117. Steam not up → direct (no Steam Input layer to want). Inside Game Mode → direct (desktop and gamescope are different seats). No tile yet / library not loaded → direct with a toast naming the reason. Refused URI → direct. Windows → direct.
  • App/LauncherService.cs (PlayFolder): ask the route after the saves/settings prep, fall back to the same GamePlay.StartInfo launch as before.
  • No-loop, self-describing handoff: each routed Play arms its own one-shot file in a handoff directory (<launcher-home>/play-handoff/, one file per Play, named by arm time), naming the build this Play asked for. The launched instance claims the oldest arm by rename (exactly one winner) and starts THAT folder. While an earlier Play's arm is still outstanding, a second Play goes direct rather than arm an unmatchable URI (a second controller-mapped launch beats a wrong-build or doubled one). The tile's launch-option path (--play) arrives with arrived: true and never routes, arm or no arm — the chain ends at an arrival by construction; only an open window's Play button routes. An explicit --play <folder> never consumes a pending handoff (it is the user's own request); a bare Play's arm carries no folder so the default stands, as before. Arms age out (5-minute ttl: the Deck's measured handoff arrived in seconds, but a cold AppImage on slow media mounts slower, and an arm that expires before its launch arrives would make that launch pick the wrong default build; the cost only lands when the opener silently failed, where staying direct is the safe side), a refused handoff clears what it armed, and a stranger's file in the same directory is never read as an arm (Ours). The arm must be published before the URI is ever asked: an arm that cannot be written (the review's probe: a plain file where the handoff directory goes) answers direct with the reason before the opener is consulted — an undispatchable URI is an unauditable launch. And the handoff directory must be the one the arriving instance will read: the tile starts the launcher file the library holds, under Steam's environment — LONGSHOT_LAUNCHER_HOME is not inherited across Steam, and a portable AppImage keeps its data beside itself. ArrivalHome reads the tile's Exe through the same layout rules the arriving instance uses (without the sender's variable), and Decide refuses routing unless the token names exactly that home's handoff — otherwise the routed launch comes up on a different registry's default (the review's actual-app probe: requested A, launched default C).
  • Delivery is checked, not assumed (the reviewer's P1): the opener's exit code is the answer (OpenWith), nonzero → direct fallback. An opener still working after the bounded wait counts as dispatched, not failed — answering failed there is how a game starts twice when Steam answers late. A missing opener answers null (absence, not refusal); the caller falls back either way.
  • The tile's --play arrives through PlayWithoutWindow, which runs before the instance lock is taken (Program.cs), so the routed instance never fights the open window's lock and never pokes it; the window keeps its claim exactly as before this feature (an earlier shape of this commit released the lock — the review's P1 — this does not).

Testing

python3 -I tests/test_launcher_core.py --dotnet ~/dotnet/dotnet: 1494 checks pass (24 new in RouteChecks: routed URI names the carried id in GridId64 form, and after a launcher update it still names the tile's carried id rather than the freshly computed one; SteamGameId → direct; inside a colon-separated gamescope session → direct (the guard recognizes gamescope among the colon-separated desktop ids, case-insensitively — a probe with gamescope:KDE returned RunGameId before the fix); no tile → direct + reason; Steam down → direct, nothing asked; library written after Steam started → direct + "not loaded" note (LibraryLoaded reads authored /proc stat/uptime and the marker's first-seen time, and a later rewrite of the file — what Steam itself does for play time — does not flip a loaded tile; the same rewrite does not rescue a truly-not-loaded one; the load epoch counts only the library-owning Steam clients — steam/steamrt/steamrt64 — a gamescope-session restart must not fake one, and a probe proved it did before the fix); refused URI → direct; a launch that arrived behind a nonzero exit is never answered with a second direct launch; a handoff that could not arm falls back direct and no URI is asked at all (asked == 0 pinned); OpenWith against real processes — exit 0 true, exit 4 false, missing opener null; Windows → direct; each Play arms its own file naming the exact requested folder, claimed once by rename, oldest-first with two arms outstanding; a Play while another's arm is outstanding goes direct with a note; a --play arrival never routes arm or no arm; stale arm claimed away; a very late arrival for a dead arm answers nothing rather than stealing a younger Play's arm, and the younger arm waits for its own launch; refused handoff clears what it armed; a stranger's file in the directory never counts as an arm; a bare Play's arm carries no folder; the token must name the arrival home — a handoff under any other home is refused before the URI is asked, a sender whose LONGSHOT_LAUNCHER_HOME is overridden still arms where the tile would arrive, and ArrivalHome resolves the tile's own layout (pinned to the XDG default beside Steam). python3 -I tests/test_release.py: OK. dotnet build App Release: 0 warnings, 0 errors. The routing commits have been through four review rounds. The round against d4e5545 returned FIX with P1s — the shared-slot crossover, the unrelated --play that took another Play's arm, the arrival that routed on, the mtime flip, the handoff armed where no arrival reads it, the URI dispatched over a failed arm, and the gamescope-faked load epoch — every one reproduced against the fixed Core and pinned in the suite. Against 46ac7e7: one verification pass returned SHIP with two P2s (stale arms crossing the FIFO claim order, the arm ttl expiring mid-flight — both closed in d727c90), and a later adversarial pass returned FIX with three P1s: a .taken claim casualty re-claimable by a second consumer (measured: 84 duplicate claims in 5,000 trials), an opener that dispatches then exits nonzero buying a second copy (real-app repro: launches A and DEFAULT on one save folder), and a URI dispatched over a failed arm (already closed in d727c90 before that verdict landed). All closed in 6bb9906: claim products (.taken/.played receipts) are never candidates again; with an arm in play a said-no opener falls back direct only on a proven standing arm, ambiguous stays routed; a foreign file at the handoff path is claimed once instead of wedging routing forever; plus that pass's P2 (a re-Add after Steam overwrote the entry away must not inherit the vanished tile's first-seen evidence) and P3 (a nonsense marker stamp crashed the load check — now clamped to the mtime fallback). A fourth adversarial pass against d727c90 is running and its findings will be pushed or answered in the thread.

Deck end-to-end (2026-11-16, Deck LCD, SteamOS 3.8.28, build 6bb9906 as the tile's Exe)

Measured on real hardware, in desktop mode with Steam up:

  • xdg-open steam://rungameid/14308674106319437824 (the 64-bit form of the tile's carried appid -963469494): Steam launched the tile — reaper SteamLaunch AppId=3331497802 (same id, signed), the AppImage arrived with --play and SteamGameId, and the game started.
  • Arrival never re-routes: the tile arrival armed no handoff (handoff directory stayed empty) and launched direct — the loop guard holds on real Steam, not just the harness.
  • Handoff chain: an arm written in the arrival home's play-handoff/ was claimed exactly once (arm file gone, .played receipt standing), and the arrival launched the armed folder — /home/deck/longshot-nvme/rt-stack2/longshot with cwd there — not the default build rt-main. The folder-carry works end to end.
  • Input: under the routed launch the game saw Steam Deck Controller (Valve vendor 17f6) with motion controls and steamdeck button prompts; 1 controller through SDL.
  • Honest caveat: the direct-launch control arm on THIS Deck also saw the real controller (Steam already running, SDL opens the evdev device directly), so I could not reproduce the mouse/keyboard trap locally — it rests on the game's own steam_pads rule (only a Steam-started game sees the steam_input device) and fresh-install reports. What routing guarantees here is the Steam Input layer on installs where that trap bites, at measured-zero cost on installs where it does not.
  • Tile repoint itself went through the launcher's own SteamShortcuts.Add (marker under the carried id → Update path): Exe moved to the new AppImage, appid/grid art/controller settings untouched, and Steam's own rewrite after restart kept the tile. Steam stop/start on desktop goes through [email protected] (Game Mode uses steam-launcher.service).
    Still unexercised: the GUI Play button path on the Deck's own screen (window → Decide → arm → URI), and Game Mode's controller layout under routing — next live pass.

Must be tested: Deck desktop mode (Test Farm: @Beanstalk steamdeck): launcher Play with Steam running → game runs as a game (buttons pad, not mouse); with Steam quit → still starts direct; the note appears when there is no tile.

Risks

xdg-open is best-effort: refused or absent → the previous direct launch. The 64-bit id rule comes from community issue threads, not Valve docs; it agrees with our own grid-id rule measured against a real Deck library, and a wrong id only means Steam declines and the direct fallback runs.

## Status Feature (fresh-install controller input), ready for review. **Stacked on #130** (this forge will not take a cross-fork base, so the diff against main also carries #130's commits): review the routing commits, `a4cf225` + `d4e5545` + `6dcaf56` + `46ac7e7` + `d727c90`, `6bb9906`, only. Merge #130 first and this PR's diff collapses to just those. ## Why On a fresh Deck, Steam Input only treats Longshot as a game when **Steam launched it**. Play from the launcher's own button starts the game direct, and under a running Steam the Deck's buttons then run Steam's *default desktop layout* — mouse and keyboard — which is the usual fresh-install complaint (the game's own `host/steam_pads.h` deliberately hides Steam's virtual gamepads and re-adds the physical one only under a real `steam_input` device, which exists only for Steam-launched games). So make Play go through Steam whenever that layer is available, and never touch global settings, controller configs, or sudo. ## What changes - `Core/SteamLaunchRoute.cs` (new): the decision. Linux + outside a gamescope session + Steam up (`SteamShortcuts.SteamUp`, /proc scan) + our tile in its library (`InLibrary`) + that library loaded by the running Steam (`LibraryLoaded`: newest running Steam's start time vs the file's write time — Steam holds its library in memory from its own start, measured Deck 2026-11-15) → hand off `steam://rungameid/<64-bit form of the tile's CARRIED id>` via xdg-open. Carried, not freshly computed: after a launcher update the library tile keeps its id (found by marker) and a URI naming the new path's id addresses a tile Steam has never loaded; `TileAppId` already draws that distinction. The id rule — `(unsigned appid << 32) | 0x02000000` — is the same `GridId64` this class already uses for capsule names, verified working on the Deck by steam-for-linux#8580 and SteamTinkerLaunch#1117. Steam not up → direct (no Steam Input layer to want). Inside Game Mode → direct (desktop and gamescope are different seats). No tile yet / library not loaded → direct with a toast naming the reason. Refused URI → direct. Windows → direct. - `App/LauncherService.cs` (PlayFolder): ask the route after the saves/settings prep, fall back to the same `GamePlay.StartInfo` launch as before. - No-loop, self-describing handoff: each routed Play arms **its own one-shot file** in a handoff directory (`<launcher-home>/play-handoff/`, one file per Play, named by arm time), naming **the build this Play asked for**. The launched instance claims the oldest arm by rename (exactly one winner) and starts THAT folder. While an earlier Play's arm is still outstanding, a second Play goes direct rather than arm an unmatchable URI (a second controller-mapped launch beats a wrong-build or doubled one). The tile's launch-option path (`--play`) arrives with `arrived: true` and **never routes, arm or no arm** — the chain ends at an arrival by construction; only an open window's Play button routes. An explicit `--play <folder>` never consumes a pending handoff (it is the user's own request); a bare Play's arm carries no folder so the default stands, as before. Arms age out (5-minute ttl: the Deck's measured handoff arrived in seconds, but a cold AppImage on slow media mounts slower, and an arm that expires before its launch arrives would make that launch pick the wrong default build; the cost only lands when the opener silently failed, where staying direct is the safe side), a refused handoff clears what it armed, and a stranger's file in the same directory is never read as an arm (`Ours`). **The arm must be published before the URI is ever asked**: an arm that cannot be written (the review's probe: a plain file where the handoff directory goes) answers direct with the reason *before* the opener is consulted — an undispatchable URI is an unauditable launch. **And the handoff directory must be the one the arriving instance will read**: the tile starts the launcher file the *library* holds, under *Steam's* environment — `LONGSHOT_LAUNCHER_HOME` is not inherited across Steam, and a portable AppImage keeps its data beside itself. `ArrivalHome` reads the tile's Exe through the same layout rules the arriving instance uses (without the sender's variable), and `Decide` refuses routing unless the token names exactly that home's handoff — otherwise the routed launch comes up on a different registry's default (the review's actual-app probe: requested A, launched default C). - Delivery is checked, not assumed (the reviewer's P1): the opener's **exit code** is the answer (`OpenWith`), nonzero → direct fallback. An opener still working after the bounded wait counts as dispatched, not failed — answering failed there is how a game starts twice when Steam answers late. A missing opener answers null (absence, not refusal); the caller falls back either way. - The tile's `--play` arrives through `PlayWithoutWindow`, which runs **before** the instance lock is taken (`Program.cs`), so the routed instance never fights the open window's lock and never pokes it; the window keeps its claim exactly as before this feature (an earlier shape of this commit released the lock — the review's P1 — this does not). ## Testing `python3 -I tests/test_launcher_core.py --dotnet ~/dotnet/dotnet`: **1494 checks pass** (24 new in `RouteChecks`: routed URI names the **carried** id in `GridId64` form, and after a launcher update it still names the tile's carried id rather than the freshly computed one; `SteamGameId` → direct; inside a colon-separated gamescope session → direct (the guard recognizes `gamescope` among the colon-separated desktop ids, case-insensitively — a probe with `gamescope:KDE` returned RunGameId before the fix); no tile → direct + reason; Steam down → direct, nothing asked; library written after Steam started → direct + "not loaded" note (`LibraryLoaded` reads authored /proc stat/uptime and the **marker's first-seen time**, and a later rewrite of the file — what Steam itself does for play time — does not flip a loaded tile; the same rewrite does not rescue a truly-not-loaded one; the load epoch counts only the **library-owning Steam clients** — `steam`/`steamrt`/`steamrt64` — a gamescope-session restart must not fake one, and a probe proved it did before the fix); refused URI → direct; a launch that arrived behind a nonzero exit is never answered with a second direct launch; a handoff that could not arm falls back direct **and no URI is asked at all** (`asked == 0` pinned); `OpenWith` against real processes — exit 0 true, exit 4 false, missing opener null; Windows → direct; each Play arms its own file naming the exact requested folder, claimed once by rename, oldest-first with two arms outstanding; a Play while another's arm is outstanding goes direct with a note; a `--play` **arrival never routes** arm or no arm; stale arm claimed away; **a very late arrival for a dead arm answers nothing rather than stealing a younger Play's arm, and the younger arm waits for its own launch**; refused handoff clears what it armed; a stranger's file in the directory never counts as an arm; a bare Play's arm carries no folder; **the token must name the arrival home** — a handoff under any other home is refused before the URI is asked, a sender whose `LONGSHOT_LAUNCHER_HOME` is overridden still arms where the tile would arrive, and `ArrivalHome` resolves the tile's own layout (pinned to the XDG default beside Steam). `python3 -I tests/test_release.py`: OK. `dotnet build App` Release: 0 warnings, 0 errors. The routing commits have been through **four** review rounds. The round against `d4e5545` returned FIX with P1s — the shared-slot crossover, the unrelated `--play` that took another Play's arm, the arrival that routed on, the mtime flip, the handoff armed where no arrival reads it, the URI dispatched over a failed arm, and the gamescope-faked load epoch — every one reproduced against the fixed Core and pinned in the suite. Against `46ac7e7`: one verification pass returned SHIP with two P2s (stale arms crossing the FIFO claim order, the arm ttl expiring mid-flight — both closed in `d727c90`), and a later adversarial pass returned FIX with three P1s: a `.taken` claim casualty re-claimable by a second consumer (measured: 84 duplicate claims in 5,000 trials), an opener that dispatches then exits nonzero buying a second copy (real-app repro: launches A **and** DEFAULT on one save folder), and a URI dispatched over a failed arm (already closed in `d727c90` before that verdict landed). All closed in `6bb9906`: claim products (`.taken`/`.played` receipts) are never candidates again; with an arm in play a said-no opener falls back direct only on a **proven** standing arm, ambiguous stays routed; a foreign file at the handoff path is claimed once instead of wedging routing forever; plus that pass's P2 (a re-Add after Steam overwrote the entry away must not inherit the vanished tile's first-seen evidence) and P3 (a nonsense marker stamp crashed the load check — now clamped to the mtime fallback). A fourth adversarial pass against `d727c90` is running and its findings will be pushed or answered in the thread. ## Deck end-to-end (2026-11-16, Deck LCD, SteamOS 3.8.28, build `6bb9906` as the tile's Exe) Measured on real hardware, in desktop mode with Steam up: - `xdg-open steam://rungameid/14308674106319437824` (the 64-bit form of the tile's carried appid `-963469494`): Steam launched the tile — `reaper SteamLaunch AppId=3331497802` (same id, signed), the AppImage arrived with `--play` **and SteamGameId**, and the game started. - **Arrival never re-routes**: the tile arrival armed no handoff (handoff directory stayed empty) and launched direct — the loop guard holds on real Steam, not just the harness. - **Handoff chain**: an arm written in the arrival home's `play-handoff/` was claimed exactly once (arm file gone, `.played` receipt standing), and the arrival launched **the armed folder** — `/home/deck/longshot-nvme/rt-stack2/longshot` with cwd there — not the default build `rt-main`. The folder-carry works end to end. - **Input**: under the routed launch the game saw `Steam Deck Controller` (Valve vendor 17f6) with motion controls and steamdeck button prompts; `1 controller through SDL`. - Honest caveat: the direct-launch control arm on THIS Deck also saw the real controller (Steam already running, SDL opens the evdev device directly), so I could not reproduce the mouse/keyboard trap locally — it rests on the game's own steam_pads rule (only a Steam-started game sees the steam_input device) and fresh-install reports. What routing guarantees here is the Steam Input layer on installs where that trap bites, at measured-zero cost on installs where it does not. - Tile repoint itself went through the launcher's own `SteamShortcuts.Add` (marker under the carried id → Update path): Exe moved to the new AppImage, appid/grid art/controller settings untouched, and Steam's own rewrite after restart kept the tile. Steam stop/start on desktop goes through `[email protected]` (Game Mode uses `steam-launcher.service`). Still unexercised: the GUI Play button path on the Deck's own screen (window → Decide → arm → URI), and Game Mode's controller layout under routing — next live pass. **Must be tested:** Deck desktop mode (Test Farm: @Beanstalk steamdeck): launcher Play with Steam running → game runs as a game (buttons pad, not mouse); with Steam quit → still starts direct; the note appears when there is no tile. ## Risks xdg-open is best-effort: refused or absent → the previous direct launch. The 64-bit id rule comes from community issue threads, not Valve docs; it agrees with our own grid-id rule measured against a real Deck library, and a wrong id only means Steam declines and the direct fallback runs.
The check reads HomeViewModel.cs and asks for the line without the third term #121
added, so the game-free suite has stopped at that check on main since then. It is
the check that is stale, not the behaviour it guards: Build is still off while the
check runs, while the launcher updates itself, and now also while old versions'
folders are deleted, which is what the source says.

Assisted-by: GPT-6 Astra
On a Deck, a build that only has a desktop shortcut is still a desktop chore: the
game has to be added to Steam by hand to be playable from the couch. This makes the
Ready screen offer the tile itself, and the untick take it away again.

Steam's own file, Steam's own rules. shortcuts.vdf in the exact grammar Steam's
writer uses (a type 0 section is 00 name 00 body 08, and a lone 08 closes every
map, not 00); the tile's appid as Steam computes it, crc32(Exe + AppName) with the
high bit set read signed, the rule ChimeraOS, Heroic and SteamTinkerLaunch all
write to. Keeping the id honest is what makes the tile the game's: Steam keys its
grid art, controller settings and play time off that id, so a tile made here and
one added in Steam's own dialog behave the same. Both were checked against the
file Steam wrote on a Deck: the real file parses, the ids it holds come out of the
rule, and the reference vdf library (which round-trips the real file byte for byte)
parses the fixtures here.

The tile starts the launcher's --play like the desktop and applications-menu
shortcuts, so it follows "Play starts this version" and an update's new folder.
Ours or theirs is decided by the id and a marker beside the file: a tile the user
made by hand in Steam under the same name is left exactly as they made it, and our
add and remove leave their file byte for byte identical. A launcher that updated
keeps the one tile, pointed at the newest copy, because the AppImage's name changes
with every release. Nothing is done to Steam itself without the user: the core can
ask Steam to quit through its own -shutdown, but only a caller that has asked the
user first passes that flag, so downloads are never cut.

Checks: SteamChecks.cs over fixtures made by tests/make_steam_vdf_fixture.py; every
new text in every catalog. The BusyChecks fix above is why the suite runs again.

Assisted-by: GPT-6 Astra
review: the tile is found by Steam's id, not by the name Longshot
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
0e1e9ee44a
The first cut looked a tile up by its name and then asked whether it was ours. A
tile the user made in Steam's own dialog under the name Longshot got past that in
two ways: the marker beside the file vouched for any id it was told to carry, and
the Ready screen's first call wrote a removal before anyone was asked. Both are
gone:

- identity is the appid alone (this launcher's, or the id the marker recorded), so
  Steam's own dialog's tile is a different id and is out of reach everywhere; Add
  refuses rather than putting a second tile of the same name in the grid, and says
  why, with the tick back to what the library holds
- the marker's id is checked as a rule could have written it, and a marker that
  cannot be read is no claim at all
- the Steam tick starts on like the desktop and menu ticks: an install leaves
  something to press; the first write only ever adds

Assisted-by: GPT-6 Astra
review round two: keys never double, a marker never outranks the tile it describes
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
0464d74fd6
A second review pass found real holes the first round's fixes left:

- Remove left the numbered keys as they were and Add keyed a new tile by the item
  count, so a library with a hole (an outside edit, an older Steam) could get two
  tiles under one key, and reading it back loses one that was not ours. Add now
  takes the first free key; a check makes the hole and asserts no key repeats
- the sidecar marker vouched for any id it carried, so a stale marker beside a
  tile the user re-pointed in Steam's Properties claimed that tile. The claim now
  holds only while the tile still points at the Exe the marker recorded, and the
  check relabels a tile byte for byte and proves it stays the user's
- Remove read the file before taking Steam down, so Steam's own quit-time flush
  was overwritten by the pre-shutdown snapshot; the order is down-then-read now
- Locate and the first library read ran outside the catch: a permissions fault
  there took the Ready screen down instead of hiding its tick. They are inside
  now, InLibrary answers false for an unreadable library rather than throwing,
  and an unasked screen never writes a Remove: the desktop-or-menu ticks changing
  after a failed Add cannot delete a tile the user did not untick
- a type-5 float parsed but wrote back as type 3, quietly retyping a field we do
  not own: refused instead, and the check proves a file holding one is left alone
- SteamUp's /proc scan parsed the whole path as a number, so it saw no process
  ever: fixed, given a proc root the checks can point at a fake, and the fake
  proves both the sighting and the absence; steam.sh -shutdown no longer
  redirects output it never drains (a talking helper deadlocked the wait)

Assisted-by: GPT-6 Astra
feat(linux): the Steam tile, desktop file and menu file all carry the Longshot logo
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
3d462bb50d
The Steam tile wrote icon "" and showed the blank default in Gaming mode; the
Deck's own EmulationStation tile proves the icon field is what Steam draws.
One logo file, written once under the launcher home, feeds all three Linux
shortcuts. The appid does not move (icon is not part of Steam's id rule), and
an older tile of ours gets the icon on the next write.

Also: the Ready-screen toast now tells users to restart the console, the one
apply path hardware proved works, and SteamShortcuts' comments stop claiming
a live reload that the Deck disproved.
review: a tile keeps the art it has, and a stale logo gets repaired
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
01c181ab3d
Three points from the delegated review of 3d462bb, all real, all edge cases:

- Update/Same treat an empty icon as claiming nothing: a caller whose logo write
failed no longer rewrites a working tile to point at a file that was never
written. The upgrade order that matters (tile first, logo later) is now its own
check, with the id pinned on both sides of it.
- EnsureLogo compares the file against the embedded logo and rewrites when they
differ, so a truncated png or a newer logo from a launcher update is repaired
instead of trusted forever.
- The restart notice no longer talks over a shortcuts-write failure: one toast
shows at a time, and the error outranks the note.

launcher core: 1418 checks passed; release OK.
fix(linux): the Steam tile names an .ico; the capsules, not the icon field, are the tile's art
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
6810eef2ee
Hardware, Deck LCD: a tile whose icon field pointed at longshot.png showed the blank
default after a full console restart, while every tile in the Deck's own library that
draws art names a .ico (EmulationStation's grid _icon.ico) and carries pre-baked
capsules in config/grid/ keyed by its appid. Heroic writes an .ico into the same field
for the same reason. The tile now names longshot.ico (the launcher's own Assets copy,
embedded and written beside the .png, repaired when it differs); the desktop and menu
files keep the .png, which KDE draws correctly. Grid art for the tile's appid is a
separate piece of work and is not in this commit.
feat(linux): the tile's real art: capsules in Steam's grid/, written only when missing
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
9206814a1f
Hardware + research, Deck LCD: a Gaming-mode library tile draws from pre-baked capsule
images in grid/ beside shortcuts.vdf, keyed by the tile's appid read UNSIGNED -
<id>p.png portrait 600x900 (the library tile itself), <id>.png landscape 920x430
(the recently-played row), _hero/_logo on the detail page. The icon field is only
the small overlay icon (Steam ROM Manager's source: "Steam shows the icon named in
shortcuts.vdf, not the grid's"; Heroic writes the same capsule names for the same
reason). Our tile showed the blank default because it had no capsules at all, not
because of the icon field. The Ready screen now drops the launcher's own artwork
(embedded, generated from the green logo) into grid/ for the appid the library tile
actually carries - write-if-absent, so a capsule the user chose in Steam's own UI
is never replaced.

Assisted-by: GPT-6 Astra
fix(linux): a shortcut's capsules answer to a SECOND name: (appid << 32) | 0x02000000
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
20ca2ea2dd
The Deck's own library settled the question. EmulationStation's working tile carries
its landscape capsule byte-identical under two names: 2827843537.png (the crc32 appid
from shortcuts.vdf, what the new library UI reads) and 12145495509653520384.png, which
is exactly (2827843537 << 32) | 0x02000000 — Steam ROM Manager's lengthenAppId, the
same 64-bit id Ice's filename_for_shortcut writes and the old Big Picture reads. Our
32-bit capsules alone left the tile blank on hardware; WriteArtwork now writes every
piece under both names. Check pinned to the Deck's numbers: GridId64(-1467123759)
must equal 12145495509653520384.

Assisted-by: GPT-6 Astra
review: a capsule slot the user holds is theirs under every name and every format
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
caeaf241d2
Delegated review of the capsule work, three findings, all real:

- "Never overwrite" was not atomic: File.Exists, then AtomicFile.Write renamed with
  overwrite:true, and Steam's own UI publishes capsules at any moment — the window
  between look and rename was us possibly renaming over art the user just chose.
  AtomicFile.WriteIfAbsent: same temp-then-publish, but the rename itself is the gate
  (MoveFileEx without REPLACE_EXISTING / rename O_EXCL), no mutex needed for a
  non-replacement.
- Formats: the Deck's grid/ shows Steam's own art in .jpg as readily as .png
  (4100769614p.jpg). A .png of ours beside a .jpg of theirs is a coin flip in Steam,
  so any file in a slot, ANY extension, means the slot is taken.
- The two names (32-bit and 64-bit) are one slot seen by two UIs: art held under
  either name is held, and we never fill only the other half. Caught by the suite,
  not by reading — the fixture now seeds a .jpg hero under the 32-bit name only, and
  neither name gets our .png.

The first review's minor (a failed .ico extraction still naming the tile at a missing
file) was already fixed at 9206814; re-verified here.

Assisted-by: GPT-6 Astra
review: a half-written temp is not a capsule the user chose
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
8ed8f1bab4
The capsule review's own fix had a hole in it, and my first attempt at closing
it made it worse, so both are worth recording.

WriteArtwork asks "does any file already sit in this slot" with the glob
<stem><suffix>.* — deliberately wide, because Steam's own library art is not
always .png (this Deck holds 4100769614p.jpg). But AtomicFile publishes as
<target>.<guid>.tmp and then renames. That temp matches the wide glob. A launch
interrupted between the write and the rename therefore leaves a file that reads
as "the user's art", the slot is declared held, and the tile stays blank on
every launch afterwards with no way back except deleting files by hand.

Fix: a .tmp never counts as holding a slot. It is left on disk rather than
removed. Removing it was my first instinct and it is wrong: the temp has the
same shape whatever wrote it, so a launcher that deletes temps in the grid
folder can break a capsule Steam is mid-saving. Deleting the user's in-flight
art to work around a stale file we did not create is the exact harm this
feature exists to avoid, and once any real file lands in the slot the temp is
inert anyway.

Two checks: the tile's art still lands when a temp sits in the slot, and a temp
we did not write survives us. Suite: 1435 checks.
merge: launcher main (the DirectWrite fixes #134/#137, the nightly note #133) into the Gaming-mode tile branch
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
94d6e948c5
art: the tiles carry the Longshot name as well as the glyph
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
e40bcbd1de
The Game Mode and desktop tiles showed the weapon glyph alone; the emulator's own start-up
screen signs its picture with LONGSHOT under the glyph, in Libertinus Serif Semibold (the
fallback face the start-up screen itself uses) in cream with 0.14 em of tracking and a gold
flourish rule. The four Steam slots now carry the same lockup: glyph top, word under it,
flourish under the word, on the same flat field.

Not hand-painted: scripts/make_artwork.py composes them from the shipped art and the start-up
screen's recipe (gpu/vk/vk_menu.cpp draw_startup), and App/Assets/steam/README-artwork.md says
where they come from and that a change means re-running the script, not opening a paint program.
The Libertinus OFL licence ships with the font.
art: the compositor reads originals, never its own output
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
5cfd3988d4
A review pass found the first version cut the glyph out of the shipped capsule files -
which after one run ARE its own output: a second run would recompose a recomposition, and
the soft glow would double into a fringe with every pass. The pre-wordmark art now ships
beside the slots as src_<slot>.png, and make_artwork.py reads only those and writes only
the slot files (a csproj Remove keeps the originals out of the binary: they are build
inputs, not AvaloniaResources).

The capsules also save RGB now, the logo keeps real alpha: a capsule with a near-opaque
alpha channel mis-renders under Steam's premultiplied scaling, and the first pass invented
89/255 alpha edges the source never had (the originals are RGB). The glyph cut clamps the
alpha it gives to the source's own, and the re-run over the unchanged originals reproduces
the slot files byte for byte (md5-checked).
fix(app): FontCheck asks where the launcher runs from, not where its assembly lies
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
227ea73633
The launcher ships as one file, and an assembly inside one has no path on
disk: the new .NET 10 SDK's analyzers made the read an error (IL3000), and
with warnings-as-errors the release job has failed since #137 merged
(actions 448/457, 'The launcher, both systems'). The folder the launcher
runs from is what 'its own' means in OtherModules anyway; the modules' own
filenames are still complete paths in a single-file app, so the report's
meaning stands.
review: the tile's carried id gets a check that can tell, and a late .ico retargets the tile
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
ed14920f34
The capsule test asked TileAppId for a library id and a computed id that the
fixture held equal: replacing the getter with a bare Entry.AppId left all
checks passing (a review found it by mutation). The new check runs where the
two differ - the marker names the tile, a renamed AppImage computes another
id - and fails under that same mutation, which I re-ran after writing it.

The Ready screen cached its placement on the first attempt: if the .ico write
failed once and succeeded on a retry, the tile was still offered iconless,
and an earlier success kept its path after a later failure. The offered
entry's icon now follows the .ico that actually landed this time.
Merge remote-tracking branch 'forge-fork/fix/single-file-fontcheck-il3000' into feat/steam-gamemode-tile
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
ae680ddffa
fix(steam): a half-written library is refused, never republished
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
b52d4ec3e6
Steam rewrites shortcuts.vdf whole on every change, so a crash or power loss
mid-write leaves the file cut off inside an entry. The parser used to accept
that and return what survived; Add/Remove then published only the survivors,
deleting every tile past the cut for good. A truncated root is now refused
with a clear message, and the file stands byte for byte: a read-only caller
(InLibrary, Tiles) reports the same refusal, and an empty file stays an empty
library, not a truncation, so Add can still start one.

SteamChecks: cuts the real fixture mid-tail and at the root terminator; every
entry before the cut must survive, Add/Remove/Tiles must all refuse, the file
must be untouched after each refusal, and an empty library must still take a
tile. Mutation-checked: delete the refusal and the cut-off cases fail.
test(steam): Steam's own trailing terminator parses, a cut-off does not
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
3b08399756
The Deck's real shortcuts.vdf ends with an extra 0x08 past the root close
(verified 2026-11-16 on hardware: four closing bytes at EOF, one for the
writer's virtual top level). Padding after the terminator is normal and must
still parse; the truncation refusal must not swallow it. Fixture: append a
terminator to the real fixture, Add must succeed, and exactly one Longshot
must read back. Suite: 1447 core checks.
feat(steam): Play goes through the tile when Steam is up, so the Deck's controller is a controller
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
a4cf22553c
A fresh Deck maps the buttons through Steam Input only for games Steam
launched: a longshot started direct under a running Steam gets Steam's
default desktop layout, mouse and keyboard, the Deck's pad dead as a
pad. The game's own host/steam_pads.h re-adds the physical gamepad only
under a real steam_input device, which only exists when Steam started
the game. So Play hands off to steam://rungameid/<the tile's 64-bit id>
(the lengthenAppId rule, checked against steam-for-linux#8580 and
SteamTinkerLaunch#1117, both working on the Deck) whenever Steam is up
and our tile is in its library. Steam not up, no tile yet, or the URI
refused: the direct launch, exactly as before, with a toast note when a
missing tile is the reason.

The routed tile's --play arrives through PlayWithoutWindow, BEFORE the
instance lock is taken: it never fights the open window's lock, and the
window keeps its claim (the review's P1 — an early shape released the
lock and left a writable GUI unclaimed). The handoff arms a one-shot
token; the launch it causes consumes it and starts direct, making a
second handoff impossible by construction even if Steam or the AppImage
runtime loses SteamGameId (not a delivery guarantee, the review's
point). SteamGameId, when present, short-circuits even earlier.

Assisted-by: Hermes Agent
fix(steam): a tile's id never moves, a re-pointed tile is not ours, and a file that is not a library is not rewritten
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
2f0a8dd705
Three of the adversarial review's majors, each reproduced against this
Core before the change and against it after (scratch console, the
reviewer's own shapes):

- Update rewrote the appid from the launcher's current path. Steam
  keeps a tile's id through a launcher move (the sidecar and TileAppId
  were built for that), so the entry's id moving every update orphaned
  exactly what keys off it: the grid art landed under the id nothing
  used and the controller settings under the old one. Probe: before and
  after an update the tile now carries the same id (-529626449), while
  the Exe still follows whoever last ticked the box. The sidecar gains a
  fourth field, the path the carried id was computed from, so the
  marker still vouches for the tile after the Exe moved on; three-field
  markers written before this stay valid.

- FindOurs claimed a tile on an id match alone. The user re-pointing
  our tile at their own script in Steam's Properties keeps Steam's id
  (Properties never changes it), so the next Add re-aimed their tile
  back at us and Remove took it away. Probe: after that edit Add and
  Remove both refuse, the file stays byte-for-byte, and the tile keeps
  running their wrapper.

- A file whose root closes before its entries (a stray leading 0x08,
  an interrupted write) parsed as a whole empty library, and ShortcutsOf
  then happily created a fresh one — publishing our tile rewrote the
  file and deleted every shortcut past the stray byte. The truncation
  guard catches maps that ran out of bytes; this catches entries the
  parse never saw: RequireLibrary refuses a non-empty file with no
  shortcuts map in it, file left alone. An empty file is still no
  library yet, and Add still starts one.

Assisted-by: Hermes Agent
merge: #130's tile branch, current head (the tile this routes through)
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
a7175cc8aa
fix(steam): the handoff carries the build, answers by exit code, names the carried id, and checks the library is loaded
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
d4e5545ee6
The adversarial review's P1s and P2, each reproduced against the fixed
Core (the suite grew 11 routing checks; 1473 in all):

- A routed Play named only the tile, and the tile runs bare --play: the
  launched instance picked Registry.Default, so a Play of a non-default
  build row silently launched another game (repro: requested selected-B,
  launched default-A). The one-shot handoff now names the folder this
  Play asked for; PlayWithoutWindow consumes it and the routed launch
  starts THAT. An explicit --play <folder> still outranks the handoff
  (the user's own request wins over our routing artifact), and a bare
  Play carries no folder so the default stands, exactly as before.

- Starting xdg-open was counted as launching: a missing handler, a
  refused portal, or Steam declining the URI left no game while the UI
  said it started (repro: fake opener exit 4, Decide still answered
  routed). The opener's answer is now its exit code (OpenWith), and a
  nonzero one falls back direct. An opener still working after the
  bounded wait counts as dispatched rather than failed: answering
  failed there is how a game starts twice when Steam answers late.

- The URI computed the id fresh from the launcher path while InLibrary
  can find an older tile through its sidecar: after an update the URI
  named an id Steam does not have (repro: InLibrary=True, URI differs
  from the stored tile's). The URI now uses TileAppId — the getter that
  already draws exactly that distinction.

- InLibrary checks disk, Steam holds its library in memory until it
  restarts (measured on the Deck 2026-11-15): routing straight after
  writing the tile hands a rungameid for a tile Steam never loaded.
  LibraryLoaded compares the newest running Steam's start time with the
  file's last write (/proc stat, comm-safe parsing); not-loaded routes
  direct with a note saying a restart makes later Plays route. When
  start times cannot be read it answers optimistically: the guard
  steers between two working paths, it never decides safety.

- Also never route from inside a gamescope session (desktop and Game
  Mode are different seats), and the no-loop guard no longer even
  consults SteamGameId first when the caller knows it consumed our own
  handoff.

Assisted-by: Hermes Agent
fix(steam): a launch that arrived behind a nonzero exit is not answered with a second direct launch
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
6dcaf56757
The review's integration probe against the real app measured it: a URI
handler that dispatches and then exits nonzero (xdg-open shapes do this
on real desktops) made Decide fall back direct while Steam had already
started the game — two copies, one save folder. The handoff token the
launched instance consumes is the evidence: when the arm landed and the
token has gone, the launch happened, and the answer stays routed (with
a bounded wait for a launch arriving late). A token that never armed —
a read-only home — says nothing, so its absence never counts as a
consumed launch; the direct fallback stands there. Pinned in the suite
(1475 checks: dispatched-then-exit-4 stays routed; a handoff that could
not arm falls back direct).

Assisted-by: Hermes Agent
fix(steam): a handoff can cross no other Play, a loaded tile stays loaded, and an arrival never routes
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
46ac7e7776
The round-two review probes, each reproduced before and pinned after
(suite 1483; App Release build clean; release test OK):

- The handoff was one shared slot: two Plays in quick succession
  crossed each other's folders (receiver one got B, receiver two found
  nothing and armed a THIRD URI), and two consumers could claim one
  token. Now: one arm file per Play in a handoff directory, claimed by
  rename (exactly one winner), claimed oldest-first (Steam services
  the URIs in ask order), and Decide refuses to route while an
  earlier Play's arm is still outstanding — a direct second launch
  with controller mapping beats a wrong-build or doubled one. A
  stranger's file in the same directory is never read as an arm.

- An explicit --play <folder> never consumes a pending handoff (the
  probe: an unrelated --play A took B's arm and the intended launch
  came up with the default build).

- A --play ARRIVAL never routes, arm or no arm, handoff or no
  handoff (the probe: a bare receiver that found no arm routed on and
  asked for a third launch). The chain ends at the arrival by
  construction; only an open window's Play button routes.

- LibraryLoaded compared the file's mtime, and Steam rewrites its own
  library file (play time, properties): one no-op rewrite bumped the
  mtime past Steam's own start and flipped a loaded tile to
  not-loaded — routing would have died on any Deck that has ever
  PLAYED the tile. The marker now carries when our tile FIRST entered
  the library (kept across rewrites), and that is the time compared;
  a marker without the field (older launcher) falls back to the mtime,
  wrong only in the conservative direction.

- XDG_CURRENT_DESKTOP is a colon-separated list; gamescope is matched
  among the parts, case-insensitive.

Assisted-by: Hermes Agent
fix(steam): the handoff is armed where the tile's launch will read it, and routing needs it published first
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
d727c90814
The surviving review findings, each reproduced before and pinned after
(suite 1488; App Release build clean; release test OK):

- P1 home binding. The tile launches the launcher file the LIBRARY
  holds under its id, in Steam's environment, not this clicker's; an
  instance started from the tile resolves its home from THAT
  environment (LONGSHOT_LAUNCHER_HOME is not inherited across Steam;
  a portable AppImage tile keeps data in <file>.home beside itself).
  A sender whose home is the variable had armed a handoff the tile's
  launch would never read, and the routed launch came up with another
  home's default registry (the review's actual-app probe: requested
  A, launched default C). ArrivalHome reads the tile's Exe, applies
  LauncherLayout (portable as the disk says) WITHOUT the variable,
  and Decide refuses routing unless the token names that home's
  handoff exactly.

- P1 arm publication. An arming failure was ignored and the URI went
  out anyway (the probe: a plain FILE where the handoff directory
  goes; two successive RunGameId decisions, no arm readable, the
  selected folder lost, and no delivery evidence when the opener lied
  about failing). A published arm is now a prerequisite: ArmToken's
  answer gates dispatch, and a failed arm goes direct with the reason
  before the opener is ever consulted.

- P1 load epoch. LibraryLoaded treated the newest gamescope process
  as proof the library was reloaded — gamescope is the compositor,
  not the client; a gamescope-session restart faked an epoch
  (review probe: false, then true merely after a newer gamescope
  appeared). The epoch comes from the library-owning client only
  (steam / steamrt / steamrt64); SteamUp keeps counting gamescope for
  up/down, which is a different question.

- P2 Add idempotency. Once the id is preserved, Same compared the
  FRESHLY computed appid against the entry's carried one, so after a
  launcher move every Add looked changed: identical bytes rewritten,
  the restart notice re-fired forever, and routing stayed direct on a
  false not-loaded. Same now takes the carried id.

- P2 the why never reached the player. Every Direct decision's Note
  was discarded by PlayFolder: the not-loaded, no-tile,
  outstanding-handoff, mismatched-home and unwritable-handoff
  explanations were computed and dropped. They now ride the returned
  text to the Play toast.

- P2 arm ttl and ordering. A launch slower than the ttl let its arm
  expire, so a very late arrival took a YOUNGER Play's arm and
  launched the wrong build (the review's ordering probe). Arms stay
  fresh for five minutes, and TakeHandoff answers nothing when the
  oldest arm it claimed has aged out, leaving the younger arm for its
  own launch.

Assisted-by: Hermes Agent
fix(steam): a claimed handoff can never be claimed twice, and a said-no opener cannot buy a second copy
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
6bb9906213
Round-three review against 46ac7e7 (its FIX list, re-checked against d727c90; the
arm-publication P1 was already closed there). The rest:

- TakeHandoff candidates now exclude claim products (.taken from a claim whose
  reader died, .played the receipt a successful claim writes). The review renamed
  .taken to .taken.taken and handed two consumers the same launch 84 times in
  5,000 trials; nothing with a claim suffix is ever a candidate again, and claim
  products sweep by their own name's time so the directory never grows.
- The opener's answer is three-state, and an arm in play changes what a refusal
  proves. With an arm out: direct fallback only on PROVEN no-launch (this Play's
  arm still standing unclaimed); a claimed arm behind a nonzero exit is
  ambiguous, and the wrong guess on ambiguous is two writers at one saves
  folder (the review's real-app repro: A and DEFAULT both ran), so ambiguous
  stays routed and a re-click goes direct past the ttl. With no arm out there is
  nothing to double: the stated refusal stands. No opener on PATH (null) still
  clears the arm and goes direct.
- A plain FILE where the handoff directory goes (an early experiment's shape)
  is claimed and answered once rather than wedging CreateDirectory for every
  later Play.
- Ordering preserved through the refactor: our own aged-out oldest arm answers
  nothing (a late arrival must not steal a younger Play's arm); a stranger's
  file is claimed away and skipped, not answered.
- Marker P2: a re-Add after Steam overwrote the entry away starts the
  first-seen clock fresh (prior marker must not vouch for a vanished tile; the
  review's probe said loaded to a Steam that never reloaded).
- Marker P3: a nonsense first-seen stamp (long.MaxValue parsed and threw in
  FromUnixTimeSeconds) falls back to the mtime path instead of crashing.

Tests: six new pins (re-Add clock freshness, nonsense and negative stamps, the
receipt is never claimable again); StandingArms helper tells standing arms from
claim products. Suite 1494 checks, App Release 0W/0E, release test OK.
Author
Contributor

Stack updated: the tile branch's main-merge is merged in (head now ea174fa). One real conflict, in PlayFolder's tail: main added the PerfReports/CrashReports before-play ticks, this branch added the routing Decide — resolution keeps BOTH in order: Decide runs first, a routed Play returns before any direct launch or tick, and the direct path keeps main's ticks verbatim. The routed instance arrives through the same PlayFolder(arrived: true) path, so it runs the perf/crash tick itself on its own machine, where the settings live. Verified together: App Release 0W/0E, suite 1581 checks (this branch's routing checks plus main's new PerfChecks/BuildReportChecks). Live Deck evidence in the description is unchanged by the merge (it was run at 6bb9906; the merge adds no routing behavior).

Stack updated: the tile branch's main-merge is merged in (head now `ea174fa`). One real conflict, in `PlayFolder`'s tail: main added the `PerfReports`/`CrashReports` before-play ticks, this branch added the routing `Decide` — resolution keeps BOTH in order: `Decide` runs first, a routed Play returns before any direct launch or tick, and the direct path keeps main's ticks verbatim. The routed instance arrives through the same `PlayFolder(arrived: true)` path, so it runs the perf/crash tick itself on its own machine, where the settings live. Verified together: App Release 0W/0E, suite **1581 checks** (this branch's routing checks plus main's new `PerfChecks`/`BuildReportChecks`). Live Deck evidence in the description is unchanged by the merge (it was run at `6bb9906`; the merge adds no routing behavior).
fix(steam): a symlinked tile arrives as its TARGET, and an expired arm no longer sacrifices the next Play
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
a15ba24ba1
Round-four adversarial review against d727c90 (verdict: fix), both findings
re-verified against the current heads before touching anything:

- P1 (real at ea174fa, Core/LauncherLayout.cs:36): the AppImage runtime resolves a
  symlink to its target BEFORE it sets $APPIMAGE, and the <name>.home it uses is the
  TARGET's (the reviewer ran the exact runtime this repo pins and read its env:
  APPIMAGE=real.AppImage, HOME=real.AppImage.home for a stable.AppImage alias tile).
  LauncherLayout.Of checked alias+".home", so a symlinked portable tile read as plain
  and ArrivalHome predicted the XDG home while the arrival read the target's .home:
  routing armed where nothing would ever look (the exact home-binding P1 class, one
  entrance earlier). Fix: RealPath() resolves the link (final target) before portable
  detection and for the layout's own file; non-links and unreadable links pass through
  unchanged.
- P2: reversing this branch's own round-three answer, on the reviewer's measured
  repro. The stop-at-dead-arm rule answered null when the OLDEST arm had aged out —
  which sacrifices the NEXT Play's real delivery whenever the old launch was silently
  lost (Steam accepted the URI, never launched: the common failure). The stolen-arm
  scenario it guarded needs an arrival >ttl (300s) late; measured Deck handoffs arrive
  in seconds (proven live 2026-11-16). TakeHandoff now sweeps the dead arm and keeps
  going to the younger one. Dead arm gone either way; Outstanding never blocks on it.

Tests: symlink pins (layout kind + PortableHome through the link, the alias standing
in the library as Exe, ArrivalHome == target's .home), ordering pins rewritten (expired
+ younger arm => the younger arm answers). Mutation probe: reverting the resolve fails
the pin exactly and only there. Suite 1585 checks; App Release 0W/0E; release test OK.
Author
Contributor

Round-four adversarial review (against d727c90, re-verified against this head before touching anything) returned two findings; both closed at a15ba24:

P1 — symlinked tiles were real. The reviewer ran the exact AppImage runtime this repo pins and read its actual environment: for a stable.AppImage alias whose target has real.AppImage.home, the runtime sets APPIMAGE/HOME off the target — the runtime resolves the link before setting anything. Our ArrivalHome asked alias+".home", saw none, predicted the XDG home, and would have armed where the arrival never looks (the same home-binding P1 class, entering through a door we hadn't tried). Fix: LauncherLayout.Of now resolves the link (final target) before portable detection and for the layout's own file; non-links and unreadable links pass through unchanged. Pinned: layout kind + PortableHome through the link, the alias standing in the library as the tile Exe, and ArrivalHome == target's .home.

P2 — reversing our own round-three answer on measured odds. The stop-at-dead rule answered null when the oldest claimed arm had aged out; the review's probe shows that sacrifices the next Play's real delivery when the old launch was silently lost (URI accepted, never launched — the common failure). The stolen-arm scenario it guarded needs an arrival >ttl (300 s) late; measured Deck handoffs arrive in seconds (live evidence in the description). TakeHandoff now sweeps the dead arm and keeps going to the younger one. Ordering pins rewritten to match.

Suite 1585 checks, App Release 0W/0E, release test OK; mutation probe: reverting the symlink resolve fails the pin exactly and only there.

Round-four adversarial review (against `d727c90`, re-verified against this head before touching anything) returned two findings; both closed at `a15ba24`: **P1 — symlinked tiles were real.** The reviewer ran the exact AppImage runtime this repo pins and read its actual environment: for a `stable.AppImage` alias whose target has `real.AppImage.home`, the runtime sets `APPIMAGE`/`HOME` off the **target** — the runtime resolves the link before setting anything. Our `ArrivalHome` asked `alias+".home"`, saw none, predicted the XDG home, and would have armed where the arrival never looks (the same home-binding P1 class, entering through a door we hadn't tried). Fix: `LauncherLayout.Of` now resolves the link (final target) before portable detection and for the layout's own file; non-links and unreadable links pass through unchanged. Pinned: layout kind + `PortableHome` through the link, the alias standing in the library as the tile Exe, and `ArrivalHome == target's .home`. **P2 — reversing our own round-three answer on measured odds.** The stop-at-dead rule answered null when the oldest claimed arm had aged out; the review's probe shows that sacrifices the *next* Play's real delivery when the old launch was silently lost (URI accepted, never launched — the common failure). The stolen-arm scenario it guarded needs an arrival >ttl (300 s) late; measured Deck handoffs arrive in seconds (live evidence in the description). TakeHandoff now sweeps the dead arm and keeps going to the younger one. Ordering pins rewritten to match. Suite **1585 checks**, App Release 0W/0E, release test OK; mutation probe: reverting the symlink resolve fails the pin exactly and only there.
fix(telemetry): a Play routes through Steam only when the settings just persisted
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Compile and test (pull_request) Blocked by required conditions
768eaa7978
Round-four merge review (reproduced with the real Release assemblies): the Settings
setters change this window's values even when the save fails, a direct Play honors
them, but a routed Play runs the perf/crash tick in the ARRIVAL instance, which
reads the settings FILE — with a failed save the arrival stamped consent this
window had just turned OFF (send=1 against the player's live choice).

Decide now takes a persist hook: routing requires a successful settings save
immediately before any arm or dispatch; on failure this Play stays direct, where
the in-memory values are already the player's current ones. The ticks deliberately
stay AFTER Decide: moving them above would let a routed Play tick twice (sender AND
arrival — two sends per Play; the exactly-once contract from the merge review is
preserved). Arrivals pass no persist (they never touch the settings file; pinned).

Suite 1588 checks (three new pins); mutation probe: disabling the gate fails the
refused-persist pin exactly. App Release 0W/0E; release test OK.
HumanBean left a comment

Verdict: Request changes. Routing Play through the tile does fix the Deck's controller. But when Steam takes the link and launches nothing, the player gets no game and a notice saying it went through Steam. It also routes through whatever launcher file the tile points at, not this one. And it changes how the game starts on every Linux desktop with Steam running, with costs nobody measured (the overlay, Steam's environment).

What it does for players: on a Steam Deck in desktop mode with Steam up, Play starts the game through the Longshot tile, so Steam Input maps the Deck's controls as a gamepad rather than a mouse and keyboard. The handoff code is careful about races. It makes things better for Deck players whose controls hit that trap, though the description says that trap couldn't be reproduced on the test Deck. As written, it also costs desktop Linux players and adds failure modes that start no game.

Reviewed: 768eaa79 (head) against 721d39de, #130's head minus its last docs-only commit b5dda673 (diffing from b5dda673 itself adds only that FontCheck comment). Read in full: Core/SteamLaunchRoute.cs; the changes to App/LauncherService.cs, App/Program.cs, Core/LauncherLayout.cs and Core/SteamShortcuts.cs (TileLauncherPath, MarkerFirstSeen, ClaimOf, Add, Same, LibraryLoaded), with the code they rely on (Locate, FindOurs, InLibrary, TileAppId, SteamUp, HomeViewModel.Play, Program.Main). Skimmed: tests/launcher_core/RouteChecks.cs (names and comments), the lock files. Nothing run (a code review).
Fixed in this review: nothing.
Checked and fine:

  • The URI names the tile's carried id (TileAppId), not the fresh one, and GridId64 is the same rule the grid art uses. #130's id bug doesn't reach the URI.
  • Same() now compares the carried id. That fixes #130's Blocking 3 (#130 should take this fix, since the bug is #130's).
  • "Play starts this version": the arm carries the folder Play asked for. The arrival takes the oldest arm by rename (one winner) and starts that folder. An explicit --play <folder> never takes an arm, and an arrival never routes again, so there is no loop.
  • Launch options: the arrival starts the game with the same GamePlay.StartInfo and the settings file, and persist makes a Play whose settings save failed go direct. The Intel options are per-PC and Windows-only, so they're unaffected.
  • Windows, Game Mode (gamescope in XDG_CURRENT_DESKTOP), SteamGameId set, Steam down, no tile, library not reloaded, no opener, and a refusal with the arm still standing all fall back to the direct start.
  • /proc/<pid>/stat parsing counts fields from the last ), so starttime is rest[19].
  • PlayWithoutWindow runs before the instance lock, so the window keeps its lock.
  • LauncherLayout.Of resolving a symlink changes nothing for the launcher's own layout (the runtime's $APPIMAGE is already the target).

Blocking (to change before merge)

  1. Steam takes the link, launches nothing, and the player is told it went through Steam (Core/SteamLaunchRoute.cs:194). xdg-open exiting 0 only means the steam script passed the link on. Cases where nothing then starts:

    • Steam is up but on its sign-in screen.
    • A different account is signed in. Locate picks the newest userdata/*/config folder, which is not always the signed-in account (#130's suggestion). The tile is then in another account's library.
    • The tile's file is gone (Blocking 2).
    • Only gamescope is running. SteamUp counts gamescope, and LibraryLoaded answers "loaded" when it finds no Steam process (Core/SteamShortcuts.cs:721). xdg-open then cold-starts Steam, and the UI thread waits up to 15 s.

    In each case PlayFolder returns ViaTileNote and the Home shows "Starting Longshot…" with no game. If Steam acts on the link later (after sign-in), the arrival starts a game anyway. Within 300 s it takes the stale arm, possibly next to the direct copy the player started by pressing Play again, which is the two-copies-on-one-save case the code works hardest to avoid. After 300 s it starts the default build.

    Fix: confirm the delivery. After dispatch, wait off the UI thread (about 20–30 s) for this arm's .played receipt. If it doesn't come, cancel the arm by renaming it to a claim product. If that rename succeeds, nobody can claim the arm any more, so start direct with a note. If it fails, the arm was claimed, so the game is on its way. This also makes the 300 s Outstanding window and the late-arrival ordering unneeded. And don't count gamescope alone as Steam up for routing.

  2. Play goes through whatever launcher file the tile holds, not this launcher (Core/SteamLaunchRoute.cs:132). InLibrary finds the tile through the marker, which records the Exe the last Add wrote. Take a player who downloads a new AppImage under a new name and opens it. Until a Ready screen re-points the tile (after #130's untick and portable fixes, maybe never), the tile still starts the old file. Decide only checks that the old file's home matches the token. Then:

    • an old launcher from before this PR ignores the arm and starts the default build, not the one Play asked for;
    • a deleted old file starts nothing (Blocking 1).

    Fix: route only when TileLauncherPath(tile), links resolved, is the same file as LauncherPath. Otherwise go direct, with a note saying a Ready screen updates the tile.

  3. Every Linux desktop with Steam running now has its game started by Steam, and nothing measured what that costs (Core/SteamLaunchRoute.cs:107). #130 adds the tile at every Ready screen on any Linux PC with Steam. With this PR, Play on those PCs goes through Steam whenever Steam is up, so:

    • Steam's overlay is loaded into the game (LD_PRELOAD and its Vulkan layer);
    • Steam Input takes the controllers it is set to handle (PlayStation and Switch pads by default);
    • the game gets Steam's environment rather than the launcher's, so variables the player started the launcher with (MANGOHUD, RADV_*, LONGSHOT_*) are dropped.

    The only Steam-routed run is on a Deck in desktop mode. Nobody measured frame time with the overlay layer, on the Deck or a desktop. A desktop player who wants a direct start can only delete the tile, and #130 brings it back.

    Fix: route on the Steam Deck only, where the controller trap is (SteamOS, or the Valve board in /sys/class/dmi/id/board_vendor). Keep desktops direct. Post a routed-against-direct frame-time run in one heavy area on the Deck.

  4. The new texts are in no catalog, and they talk about a Deck and a console on a desktop (Core/SteamLaunchRoute.cs:40). The seven notes in Decide are bare English, without Tr.T, so translations.py can't even find them (#130 was held on missing translations). ViaTileNote goes to the Home's Notice on every routed Play (App/LauncherService.cs:280). That is the panel with Dismiss and Copy report, so a launch that worked looks like a problem. NotLoadedNote repeats #130's "restarting the console".

    Fix: wrap them in Tr.T, add them to the 12 catalogs, say "Restart Steam", and drop the success note (the "Starting Longshot" toast already says it).

  5. The stack merge reverts main's lock files (App/packages.lock.json:49). Merge ea174fa took the routing side's App/packages.lock.json and Core/packages.lock.json, so the head drops Microsoft.NET.ILLink.Tasks and the net10.0/win-x64 target that main's #158 added (and #130 keeps). The description doesn't mention it, and CI restores in locked mode. Take #130's or main's lock files.

Suggestions

  • Decide runs on the UI thread from HomeViewModel.Play. OpenWith waits up to 15 s, and /proc is scanned twice. Move it into a task (Blocking 1's wait needs that anyway).
  • The handoff protocol is 435 lines, with arms, receipts, legacy-file claims, sweeps and a ttl, after four review rounds. With Blocking 1's rename-to-cancel, most of the ordering and ttl reasoning could go, leaving: arm → dispatch → claimed or cancelled.
  • Move the Same() carried-id fix and its check into #130, where the bug is.

How it relates to #130's review

  • Portable rule (#173): this PR routes through any tile in the library, so #130's auto-added tile now also takes over how Play launches. That raises the stakes of #130's Blocking 1. ArrivalHome handles a portable home correctly.
  • Removed tile comes back: this makes it worse. Removing the tile is the only way to keep Play direct, and #130 re-adds it.
  • Same(): fixed here (see above).
  • Translations: this PR adds seven more untranslated texts (Blocking 4).

Testing:

  • The author, on a Deck LCD in desktop mode at 6bb9906: a rungameid launch of the tile, a handoff claimed once with the armed folder started, no re-route on arrival, and the controller seen as a Steam Deck pad.
  • The author ran the game-free suite: 1588 checks at the head.
  • Still missing:
    • the window's Play button path on the Deck (the description says so);
    • Game Mode;
    • a desktop Linux PC with Steam;
    • Steam up but not signed in;
    • frame time routed against direct.
  • CI at 768eaa79 is waiting to start.

Overlaps and merge order: stacked on #130, which has changes requested. #130 merges first, then this PR is rebased onto main so its diff is only the routing commits. This PR doesn't merge with main as it stands.

**Verdict: Request changes.** Routing Play through the tile does fix the Deck's controller. But when Steam takes the link and launches nothing, the player gets no game and a notice saying it went through Steam. It also routes through whatever launcher file the tile points at, not this one. And it changes how the game starts on every Linux desktop with Steam running, with costs nobody measured (the overlay, Steam's environment). What it does for players: on a Steam Deck in desktop mode with Steam up, Play starts the game through the Longshot tile, so Steam Input maps the Deck's controls as a gamepad rather than a mouse and keyboard. The handoff code is careful about races. It makes things better for Deck players whose controls hit that trap, though the description says that trap couldn't be reproduced on the test Deck. As written, it also costs desktop Linux players and adds failure modes that start no game. **Reviewed:** 768eaa79 (head) against 721d39de, #130's head minus its last docs-only commit b5dda673 (diffing from b5dda673 itself adds only that FontCheck comment). Read in full: `Core/SteamLaunchRoute.cs`; the changes to `App/LauncherService.cs`, `App/Program.cs`, `Core/LauncherLayout.cs` and `Core/SteamShortcuts.cs` (`TileLauncherPath`, `MarkerFirstSeen`, `ClaimOf`, `Add`, `Same`, `LibraryLoaded`), with the code they rely on (`Locate`, `FindOurs`, `InLibrary`, `TileAppId`, `SteamUp`, `HomeViewModel.Play`, `Program.Main`). Skimmed: `tests/launcher_core/RouteChecks.cs` (names and comments), the lock files. Nothing run (a code review). **Fixed in this review:** nothing. **Checked and fine:** - The URI names the tile's **carried** id (`TileAppId`), not the fresh one, and `GridId64` is the same rule the grid art uses. #130's id bug doesn't reach the URI. - `Same()` now compares the carried id. That fixes #130's Blocking 3 ([#130](https://git.magicbean.dev/MagicBeanDev/LongshotLauncher/pulls/130) should take this fix, since the bug is #130's). - "Play starts this version": the arm carries the folder Play asked for. The arrival takes the oldest arm by rename (one winner) and starts that folder. An explicit `--play <folder>` never takes an arm, and an arrival never routes again, so there is no loop. - Launch options: the arrival starts the game with the same `GamePlay.StartInfo` and the settings file, and `persist` makes a Play whose settings save failed go direct. The Intel options are per-PC and Windows-only, so they're unaffected. - Windows, Game Mode (`gamescope` in `XDG_CURRENT_DESKTOP`), `SteamGameId` set, Steam down, no tile, library not reloaded, no opener, and a refusal with the arm still standing all fall back to the direct start. - `/proc/<pid>/stat` parsing counts fields from the last `)`, so `starttime` is `rest[19]`. - `PlayWithoutWindow` runs before the instance lock, so the window keeps its lock. - `LauncherLayout.Of` resolving a symlink changes nothing for the launcher's own layout (the runtime's `$APPIMAGE` is already the target). **Blocking** (to change before merge) 1. **Steam takes the link, launches nothing, and the player is told it went through Steam** (`Core/SteamLaunchRoute.cs:194`). `xdg-open` exiting 0 only means the `steam` script passed the link on. Cases where nothing then starts: - Steam is up but on its sign-in screen. - A different account is signed in. `Locate` picks the newest `userdata/*/config` folder, which is not always the signed-in account (#130's suggestion). The tile is then in another account's library. - The tile's file is gone (Blocking 2). - Only gamescope is running. `SteamUp` counts gamescope, and `LibraryLoaded` answers "loaded" when it finds no Steam process (`Core/SteamShortcuts.cs:721`). `xdg-open` then cold-starts Steam, and the UI thread waits up to 15 s. In each case `PlayFolder` returns `ViaTileNote` and the Home shows "Starting Longshot…" with no game. If Steam acts on the link later (after sign-in), the arrival starts a game anyway. Within 300 s it takes the stale arm, possibly next to the direct copy the player started by pressing Play again, which is the two-copies-on-one-save case the code works hardest to avoid. After 300 s it starts the default build. Fix: confirm the delivery. After dispatch, wait off the UI thread (about 20–30 s) for this arm's `.played` receipt. If it doesn't come, cancel the arm by renaming it to a claim product. If that rename succeeds, nobody can claim the arm any more, so start direct with a note. If it fails, the arm was claimed, so the game is on its way. This also makes the 300 s `Outstanding` window and the late-arrival ordering unneeded. And don't count gamescope alone as Steam up for routing. 2. **Play goes through whatever launcher file the tile holds, not this launcher** (`Core/SteamLaunchRoute.cs:132`). `InLibrary` finds the tile through the marker, which records the Exe the last `Add` wrote. Take a player who downloads a new AppImage under a new name and opens it. Until a Ready screen re-points the tile (after #130's untick and portable fixes, maybe never), the tile still starts the old file. `Decide` only checks that the old file's home matches the token. Then: - an old launcher from before this PR ignores the arm and starts the **default** build, not the one Play asked for; - a deleted old file starts nothing (Blocking 1). Fix: route only when `TileLauncherPath(tile)`, links resolved, is the same file as `LauncherPath`. Otherwise go direct, with a note saying a Ready screen updates the tile. 3. **Every Linux desktop with Steam running now has its game started by Steam, and nothing measured what that costs** (`Core/SteamLaunchRoute.cs:107`). #130 adds the tile at every Ready screen on any Linux PC with Steam. With this PR, Play on those PCs goes through Steam whenever Steam is up, so: - Steam's overlay is loaded into the game (`LD_PRELOAD` and its Vulkan layer); - Steam Input takes the controllers it is set to handle (PlayStation and Switch pads by default); - the game gets Steam's environment rather than the launcher's, so variables the player started the launcher with (`MANGOHUD`, `RADV_*`, `LONGSHOT_*`) are dropped. The only Steam-routed run is on a Deck in desktop mode. Nobody measured frame time with the overlay layer, on the Deck or a desktop. A desktop player who wants a direct start can only delete the tile, and #130 brings it back. Fix: route on the Steam Deck only, where the controller trap is (SteamOS, or the Valve board in `/sys/class/dmi/id/board_vendor`). Keep desktops direct. Post a routed-against-direct frame-time run in one heavy area on the Deck. 4. **The new texts are in no catalog, and they talk about a Deck and a console on a desktop** (`Core/SteamLaunchRoute.cs:40`). The seven notes in `Decide` are bare English, without `Tr.T`, so `translations.py` can't even find them (#130 was held on missing translations). `ViaTileNote` goes to the Home's `Notice` on **every** routed Play (`App/LauncherService.cs:280`). That is the panel with Dismiss and Copy report, so a launch that worked looks like a problem. `NotLoadedNote` repeats #130's "restarting the console". Fix: wrap them in `Tr.T`, add them to the 12 catalogs, say "Restart Steam", and drop the success note (the "Starting Longshot" toast already says it). 5. **The stack merge reverts main's lock files** (`App/packages.lock.json:49`). Merge ea174fa took the routing side's `App/packages.lock.json` and `Core/packages.lock.json`, so the head drops `Microsoft.NET.ILLink.Tasks` and the `net10.0/win-x64` target that main's [#158](https://git.magicbean.dev/MagicBeanDev/LongshotLauncher/pulls/158) added (and #130 keeps). The description doesn't mention it, and CI restores in locked mode. Take #130's or main's lock files. **Suggestions** - `Decide` runs on the UI thread from `HomeViewModel.Play`. `OpenWith` waits up to 15 s, and `/proc` is scanned twice. Move it into a task (Blocking 1's wait needs that anyway). - The handoff protocol is 435 lines, with arms, receipts, legacy-file claims, sweeps and a ttl, after four review rounds. With Blocking 1's rename-to-cancel, most of the ordering and ttl reasoning could go, leaving: arm → dispatch → claimed or cancelled. - Move the `Same()` carried-id fix and its check into #130, where the bug is. **How it relates to #130's review** - Portable rule ([#173](https://git.magicbean.dev/MagicBeanDev/LongshotLauncher/pulls/173)): this PR routes through any tile in the library, so #130's auto-added tile now also takes over how Play launches. That raises the stakes of #130's Blocking 1. `ArrivalHome` handles a portable home correctly. - Removed tile comes back: this makes it worse. Removing the tile is the only way to keep Play direct, and #130 re-adds it. - `Same()`: fixed here (see above). - Translations: this PR adds seven more untranslated texts (Blocking 4). **Testing:** - The author, on a Deck LCD in desktop mode at 6bb9906: a `rungameid` launch of the tile, a handoff claimed once with the armed folder started, no re-route on arrival, and the controller seen as a Steam Deck pad. - The author ran the game-free suite: 1588 checks at the head. - Still missing: - the window's Play button path on the Deck (the description says so); - Game Mode; - a desktop Linux PC with Steam; - Steam up but not signed in; - frame time routed against direct. - CI at 768eaa79 is waiting to start. **Overlaps and merge order:** stacked on [#130](https://git.magicbean.dev/MagicBeanDev/LongshotLauncher/pulls/130), which has changes requested. #130 merges first, then this PR is rebased onto main so its diff is only the routing commits. This PR doesn't merge with main as it stands.
@ -252,0 +277,4 @@
handoff: fromHandoff, folder: folder, arrived: arrived,
persist: arrived ? null : TrySaveSettings);
if (route.Route == SteamLaunchRoute.Kind.RunGameId)
return said == null ? route.Note : said + " " + route.Note;
Owner

ViaTileNote ends up in the Home's Notice (the problem panel, with Dismiss and Copy report) on every routed Play, so a launch that worked looks like a problem. The "Starting Longshot" toast is enough. Return said only.

`ViaTileNote` ends up in the Home's `Notice` (the problem panel, with Dismiss and Copy report) on every routed Play, so a launch that worked looks like a problem. The "Starting Longshot" toast is enough. Return `said` only.
@ -47,12 +47,6 @@
"NWayland": "0.11.0"
}
},
Owner

Merge ea174fa took the routing side's lock files here and in Core/packages.lock.json, which drops Microsoft.NET.ILLink.Tasks and the net10.0/win-x64 target that main's #158 added (and #130 keeps). Take #130's lock files.

Merge ea174fa took the routing side's lock files here and in `Core/packages.lock.json`, which drops `Microsoft.NET.ILLink.Tasks` and the `net10.0/win-x64` target that main's #158 added (and #130 keeps). Take #130's lock files.
@ -0,0 +37,4 @@
/// it was armed. TakeHandoff reads and consumes it; there is one handoff per Play
public sealed record Handoff(string? Folder, long ArmedUnix);
public const string ViaTileNote = "The game was started through Steam's tile, so the Deck's controller works as a controller.";
Owner

These notes, and the five in Decide, are bare English with no Tr.T, so they are in no catalog. They also say "the Deck's controller" and "restarting the console" on a desktop. "Restart Steam" covers both.

These notes, and the five in `Decide`, are bare English with no `Tr.T`, so they are in no catalog. They also say "the Deck's controller" and "restarting the console" on a desktop. "Restart Steam" covers both.
@ -0,0 +104,4 @@
// the environment saying SteamGameId: the fast path for the same fact
if (!string.IsNullOrEmpty(env("SteamGameId"))) return Decision.Direct();
// no Steam running: direct, which is also what makes Steam's own runtime absent
if (!SteamShortcuts.SteamUp(proc)) return Decision.Direct();
Owner

This routes on every Linux PC with Steam running, not just the Deck. On a desktop the game then gets Steam's overlay (LD_PRELOAD and its Vulkan layer), Steam Input on PlayStation and Switch pads, and Steam's environment in place of the launcher's (MANGOHUD, RADV_* and LONGSHOT_* set at launch are dropped). None of that has been measured, and the only way back is deleting the tile, which #130 re-adds. Limit routing to the Deck (SteamOS, or the Valve board in /sys/class/dmi/id/board_vendor).

This routes on every Linux PC with Steam running, not just the Deck. On a desktop the game then gets Steam's overlay (`LD_PRELOAD` and its Vulkan layer), Steam Input on PlayStation and Switch pads, and Steam's environment in place of the launcher's (`MANGOHUD`, `RADV_*` and `LONGSHOT_*` set at launch are dropped). None of that has been measured, and the only way back is deleting the tile, which #130 re-adds. Limit routing to the Deck (SteamOS, or the Valve board in `/sys/class/dmi/id/board_vendor`).
@ -0,0 +191,4 @@
TryClear(armedAt);
return Decision.Direct("Steam refused the tile launch (the refusal said no outright), so the game started directly.");
}
return new Decision(Kind.RunGameId, uri, ViaTileNote);
Owner

xdg-open exiting 0 means the link was handed on, not that a game started. If Steam is on its sign-in screen, a different account is signed in, the tile's file is gone, or only gamescope is up, this returns ViaTileNote and no game starts. Once Steam acts on the link late, the stale arm starts a second copy next to a direct re-Play (within 300 s) or the default build (after). Wait off the UI thread for this arm's .played receipt. If it doesn't come, rename the arm to a claim product: if the rename succeeds nobody can claim it, so start direct; if it fails, the arm was claimed.

`xdg-open` exiting 0 means the link was handed on, not that a game started. If Steam is on its sign-in screen, a different account is signed in, the tile's file is gone, or only gamescope is up, this returns `ViaTileNote` and no game starts. Once Steam acts on the link late, the stale arm starts a second copy next to a direct re-Play (within 300 s) or the default build (after). Wait off the UI thread for this arm's `.played` receipt. If it doesn't come, rename the arm to a claim product: if the rename succeeds nobody can claim it, so start direct; if it fails, the arm was claimed.
@ -0,0 +129,4 @@
// that does not name that home's handoff cannot be matched, so: direct
if (token != null)
{
var arrival = ArrivalHome(tile, env);
Owner

This checks the tile's home but not that the tile starts this launcher. After a new AppImage under a new name, and until a Ready screen re-points the tile, the tile still runs the old file. An old launcher from before this PR ignores the arm and starts the default build, and a deleted file starts nothing. Route only when TileLauncherPath(tile) (links resolved) is the same file as LauncherPath.

This checks the tile's home but not that the tile starts *this* launcher. After a new AppImage under a new name, and until a Ready screen re-points the tile, the tile still runs the old file. An old launcher from before this PR ignores the arm and starts the default build, and a deleted file starts nothing. Route only when `TileLauncherPath(tile)` (links resolved) is the same file as `LauncherPath`.
@ -0,0 +718,4 @@
var started = boot.AddSeconds(start / hz);
if (started > best) best = started;
}
if (best == DateTime.MinValue) return true; // (Steam-like but no start time readable: optimistic)
Owner

With only gamescope running (SteamUp counts it), no steam process is found, so this answers "loaded". Decide then routes, xdg-open cold-starts Steam, and the UI thread waits up to 15 s. For routing, no Steam client process should mean Steam is not up.

With only gamescope running (`SteamUp` counts it), no `steam` process is found, so this answers "loaded". `Decide` then routes, `xdg-open` cold-starts Steam, and the UI thread waits up to 15 s. For routing, no Steam client process should mean Steam is not up.
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Compile and test (pull_request) Blocked by required conditions
This pull request has changes conflicting with the target branch.
  • App/ViewModels/BuildStepViewModel.cs
  • Core/Lang/de.json
  • Core/Lang/es.json
  • Core/Lang/fr.json
  • Core/Lang/it.json
  • Core/Lang/ja.json
  • Core/Lang/ko.json
  • Core/Lang/nl.json
  • Core/Lang/pl.json
  • Core/Lang/pt-BR.json
  • Core/Lang/ru.json
  • Core/Lang/zh-Hans.json
  • Core/Lang/zh-Hant.json
Some workflows are waiting to be reviewed.
View command line instructions

Manual merge helper

Use this merge commit message when completing the merge manually.

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'feat/play-through-steam-tile:omgitsgela-feat/play-through-steam-tile'
git switch 'omgitsgela-feat/play-through-steam-tile'
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/LongshotLauncher!151
No description provided.