Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 843a6201fb feat: Play > Start directly says a Steam game may hand itself to Steam - the notice, the tooltip and Settings (en/vi/ja); why a note rather than a fixed Steam rule (beta.27 PR-1)
The owner, 2026-10-20: Steam games hand themselves to Steam; a note in the UI, or a fixed setting
that Steam's games always go through the Steam client - the choice left open. The note:

- GamePlayer: PlayResult.SteamGame - the game the agent starts (Start directly, or an App running as
  administrator, or a Steam record with no link) is one Steam's own records name; the notice then
  reads Play_Started_Steam_Format / Play_Elevated_Steam_Format. Store records are read once a press.
- Strings: Play_ToolTip_Direct and Settings_PlayMode_Body say a Steam game may hand itself to Steam
  and the game Steam then starts is recorded; Settings adds that a few will not start outside Steam
  at all. en/vi/ja, ja marked review; Strings.Designer regenerated.
- Why not the fixed rule: three of the five Steam games started directly on 2026-10-20 ran and were
  measured from their first frame, and a Vulkan game is measured only when FrameLedger starts it
  (Everhex Demo) - recorded in 08_UI.
- Docs: 08_UI, guide/08-settings, LIMITATIONS, CHANGELOG.
- Tests: GamePlayerTests (Steam started directly and elevated say it; a loose or GOG game does not).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 10:20:59 +07:00
poli0981andClaude Opus 5.5 4e09047d5c fix: the owner's eight sessions of 2026-10-20 - a x2.52 state, the driver's DLSS word lost at exit, Start directly losing the game Steam starts, two summary windows, display sizes, a bare DLSS line; the two load-flaky tests (beta.27 PR-1)
The owner ran the installed 0.1.0-beta.26 (sessions 64-71) and asked for the results to be checked,
the two flaky tests fixed, bugs fixed, and a release if there were bugs. Read from a backup copy of
the ledger and the logs (docs/spike-notes/23-owner-runs-2026-10-20.md).

- FgWindow.IsNearWholeMultiplier: a window is a state's only within 10 % of a whole multiplier of two
  or more (FgSlices.Slice.IsActive); FgMixRecord.Parse reads stored rows by the same rule. Silent Hill
  2 under Dynamic MFG listed x2.52 for 12.8 s - windows where the multiplier stepped; it now reads
  x2.0, x3.0, none and 7.36 % not classified.
- NgxDriverState / CaptureSession: the driver is not asked after the game has gone, and CREATED |
  EVALUATE stand once a reading carried them. The last NGX reading, taken after the target exited,
  replaced every in-game one: none of the 14 answered sessions kept the two bits, so DLSS
  (driver-reported) and the NVIDIA App's mode (D63) never showed on an NGX-direct title.
- CaptureOrchestrator: a launch says it ended on its own (Recorded) with the pids it recorded
  (Targets), so a process turned away while it ran - the game Steam starts after Lies of P hands
  itself over - is recorded when it ends; the launch's own process never is.
- SessionSummaryOpener: one window per session; opening it again brings it forward.
- DisplayTally: the sizes are the mode's last sample that saw the window (a game leaving exclusive
  fullscreen closes it first; five sessions stored none).
- DlssText.Line: no line that says only "DLSS".
- Tests: the guard's scan set includes the test host above the harness, which under a full gate
  releases modules while it starts its other classes - ModuleScanFailed (reproduced 1 run in 12 of
  the assembly with coverage; 15 of 15 green after), ProcessUnreadable on 2026-10-19.
  ShmDrainIntegrationTests.InjectAsync asks again on those two reasons only (4 times at most, 250 ms
  apart); the pause case waits for READY; every injection suite waits for the harness's flushed
  "presenting" line instead of 800 ms (tests/Shared/HarnessReady.cs).
- Docs: 03_METRICS (the mix, the driver-reported rung, display sizes), 04_CAPTURE, 06_DATA_MODEL,
  08_UI, 14_TESTING, 18_GPU_VENDOR_APIS, 19_SAFETY (direct starts counted by the crash safety -
  measured, the policy unchanged), LIMITATIONS, guide (troubleshooting, results), spike-notes section
  23, HANDOFF items 20 and 21, CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 09:51:26 +07:00
45 changed files with 841 additions and 79 deletions

No files matched your search

+43
View File
@@ -35,6 +35,49 @@ numeric core and does not move; the heading is the full version — corrected 20
## [Unreleased]
### Changed
- **Play ▸ *Start directly* says what a Steam game may do.** Some Steam games hand themselves to Steam when
FrameLedger starts them — Lies of P closes within seconds and Steam starts it again. Starting a game Steam installed,
the notice now says it may hand itself to Steam first and that the game Steam then starts is recorded; the *Start
directly* tooltip and Settings ▸ Games ▸ *Play button* say so too, adding that a few will not start outside Steam at
all. Steam games keep *Start directly*: three of the five started directly on 2026-10-20 ran and were measured from
their first frame, and a Vulkan game is measured only when FrameLedger starts it. In en/vi/ja (ja marked for review).
### Fixed
- **A frame-generation "state" of ×2.52.** The owner's Silent Hill 2 session under the NVIDIA App's *Dynamic* multi
frame generation listed ×2.52 for 13 seconds beside ×2.0 and ×3.0: the five-second windows in which the multiplier
stepped from ×2 to ×3 read in between, and three of them formed a state nobody held. Every frame generation that
ships multiplies by a whole number, so a window now counts toward a state only within 10 % of one; the others are
*Not classified*. Sessions already recorded are read by the same rule: that session lists ×2.0, ×3.0, no frame
generation and 7.36 % not classified. The owner's runs of 2026-10-20 are recorded in
`docs/spike-notes/23-owner-runs-2026-10-20.md`.
- **The NVIDIA driver's DLSS report was lost from every stored session.** FrameLedger asked the driver one last time
after the game had closed, and that answer — which no longer says DLSS ran — replaced the ones read while the game
ran. So no session said *DLSS (driver-reported)* where no hook saw DLSS, and none named the NVIDIA App's quality mode
on such a game: Clair Obscur: Expedition 33 under the App's override read *Upscaler not identified*. The driver is no
longer asked once the game has closed, and once it reports that DLSS ran, the session keeps it. Sessions recorded
before keep what they stored.
- **Play ▸ *Start directly* recorded nothing of a game that hands itself to Steam.** Lies of P, started directly, closes
within seconds and Steam starts it again; the game Steam started was turned away while the first session ended and
never recorded. It is now recorded once that session ends, as a game started again already was. Each such start
still counts toward the two early exits that turn hooking off for a game, so Limitations ▸ Play advises starting such
a game through its store.
- **Opening a session's summary twice opened two windows.** The open window comes forward instead, restored if
minimised.
- **No window or monitor size for a game in exclusive full-screen.** A game leaving exclusive full-screen closes its
window a moment before its swap chain says so, and those last samples replaced the sizes: two Lies of P and three
Dark Souls III sessions show none. The sizes are now the last ones the mode saw.
- **A DLSS line that said only "DLSS"**, under a header that already did, is no longer shown: the NVIDIA App's override
loads its libraries under names FrameLedger does not list (The Witcher 3), and the *Loaded:* line prints them.
- **Two integration tests that failed under load** (developers only). The guard reads every process above the test
harness too, the test host among them, and under a full `build.ps1 check` the test host is still starting its other
test classes: a module it released while the guard read its list refused the injection (`ModuleScanFailed`, and
`ProcessUnreadable` on 2026-10-19). The drain suite asks the guard again on those two reasons, four times at most;
the pause case, which once read the writer still starting, waits for it to be ready; and every injection test waits
for the harness's own "presenting" line instead of 800 ms (`tests/Shared/HarnessReady.cs`).
## Releases
Newest first. Each file holds that release's section exactly as it stood here.
+2
View File
@@ -49,6 +49,8 @@
-->
<ItemGroup Condition="'$(IsTestProject)' == 'true'">
<Compile Include="$(MSBuildThisFileDirectory)tests\Shared\HarnessOverlayLogSweep.cs" Link="Shared\HarnessOverlayLogSweep.cs" />
<!-- When a started harness is really up (beta.27): the injection tests wait for its own "presenting" line. -->
<Compile Include="$(MSBuildThisFileDirectory)tests\Shared\HarnessReady.cs" Link="Shared\HarnessReady.cs" />
</ItemGroup>
<!--
+15 -3
View File
@@ -67,7 +67,9 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
([Metrics](docs/03_METRICS.md))
- **The mix of frame-generation states** in a session's summary (since 0.1.0-beta.24) is read over five-second
windows: frame generation that changes faster than that — the NVIDIA App's *Dynamic* mode can — reads partly as
*Not classified*, and a state shorter than 10 seconds is not listed. A stretch the game presents with almost no frame
*Not classified*: a window in which the multiplier stepped reads between two whole multipliers and, since
0.1.0-beta.27, is never a state of its own. A state shorter than 10 seconds is not listed. A stretch the game
presents with almost no frame
count of its own — shaders compiling at start, a loading screen, a menu drawn outside frame generation — reads as
*Not classified* too. The
multiplier chosen in a game's own menu is not read; the measured factor is its evidence. How the NVIDIA App's
@@ -99,7 +101,9 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
The mode chosen in a game's own menu is not readable for DLSS without Streamline, and is not inferred from the
render scale. How the driver numbers DLAA in
its report is NVIDIA's documented value, not yet seen on a real game. The render resolution is N/A where the
game's own calls do not carry it (DLSS without Streamline, for one). ([Metrics](docs/03_METRICS.md))
game's own calls do not carry it (DLSS without Streamline, for one). Sessions recorded before 0.1.0-beta.27 kept
the NVIDIA driver's answer from after the game had closed, which never says DLSS ran: on a game no hook names, they
show neither the driver's report nor the NVIDIA App's mode. ([Metrics](docs/03_METRICS.md))
- **Which DLSS ran** (since 0.1.0-beta.24) is named only from what the session showed: the model preset the NVIDIA
driver reports (L or M: DLSS 4.5; J or K: DLSS 4), a measured multi-frame factor (×5 or ×6: DLSS 4.5; ×3 or ×4:
DLSS 4), or a library whose major version names one (2.x, 3.x). A 310 library with no such evidence shows its
@@ -134,7 +138,9 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
"Fullscreen". FrameLedger reports what the game asked for.
- The mode is sampled ten times a second in a measured session and once a second in an unmeasured one; very
short switches can be missed. A session recovered after a crash, and every session recorded before
beta.10, read N/A. ([Display mode](docs/03_METRICS.md#display-mode--both-tiers-beta10))
beta.10, read N/A. Some sessions recorded before 0.1.0-beta.27 of a game in exclusive full-screen show no window or
monitor size: the game's last moments, after its window had closed, replaced them.
([Display mode](docs/03_METRICS.md#display-mode--both-tiers-beta10))
## Engine version
@@ -199,6 +205,12 @@ you accept the prompt. Turn it on only if you trust everything that runs under y
- **FrameLedger never starts a game as administrator.** *Start directly* does not start a game that asks for it — start
that one from its store or its own shortcut — nor a game whose recording is off: FrameLedger starts only what it
records. While FrameLedger itself runs as administrator, Play starts every game directly, with your standard rights.
- **Some games will not start directly** (seen on two Steam games, 2026-10-19 and 20). Lies of P, started by *Start
directly*, hands itself to Steam within seconds — since 0.1.0-beta.27 the game Steam then starts is recorded —, and
Clair Obscur: Expedition 33 closes within seconds, with or without FrameLedger's hook. Each such start ends a
measured session early, which the crash safety counts: two turn hooking off for the game. Start such a game through
its store (Settings ▸ Games ▸ *Play button*); the notice after Play says when a Steam game may hand itself to Steam.
([details](docs/spike-notes/23-owner-runs-2026-10-20.md))
## Game artwork
+29 -1
View File
@@ -501,6 +501,17 @@ F_app = Σ fgEvaluations (APPLICATION frames, counted at the
> not-classified time — so the session stored with the ×1336.0 row reads ×2.0, ×3.0, ×6.1, no frame generation and
> 30 s not classified, and its shares still add up.
>
> **Amended 2026-10-20 (beta.27): a state is near a whole multiplier.** Every frame generation that ships multiplies by
> a whole number — ×2 for FSR, XeSS and DLSS 3, up to ×4 for DLSS 4, up to ×6 for DLSS 4.5 — and its windows read near
> one: 1.98, 3.01, 6.06. The owner's Silent Hill 2 session of 2026-10-20 under the NVIDIA App's *Dynamic* mode listed
> a **×2.52** state for 12.8 s: windows in which the multiplier stepped between ×2 and ×3 read ×2.21–×2.70 — at 135 s,
> 251 application frames followed by one generated frame and 270 by two — and three of them pooled into a state nobody
> held (`spike-notes` §23). A window is now active only within **10 %** of a whole multiplier of two or more
> (`FgWindow.IsNearWholeMultiplier`: ×1.8–×2.2, ×2.7–×3.3, … ×5.4–×6.6); a window between two is *not classified*, and
> the steady state reads the same windows. A stored mix is read by the same rule (`FgMixRecord.Parse`): that session
> reads ×2.0 27.30 %, ×3.0 62.41 %, no frame generation 2.93 % and 7.36 % not classified. Of the 70 sessions in the
> owner's ledger copy it was the only stored row between two multipliers.
>
> **When there is a mix.** Only where the session's frame generation was named (`Named` / `ActiveUnidentified`) and the
> session-wide count either stood or was refused as `NonUniform` / `AmbiguousBand` — a change of state is exactly what a
> mix describes. Every other refusal (not counted, unattributed, interleaved streams, either saturation, no
@@ -627,6 +638,9 @@ carries the three shapes.
> *DLSS · NVIDIA App override*, *DLSS Quality*. The live card names what the report settles by itself
> (`upscalerQualityOverride`, `07_IPC`). Nothing infers a mode from the render scale (`HANDOFF` §7a). Silent Hill 2's
> own session reads no mode: its word lacks `CREATED | EVALUATE`, so no super resolution ran that the driver saw.
> *(Corrected 2026-10-20: it lacked them because the word stored had been read after the game closed — §The
> driver-reported rung. A session recorded from beta.27 keeps them; one recorded before, on a title no hook names, never
> reads the override's mode.)*
From the upscaler hooks we get, per frame:
@@ -739,6 +753,16 @@ Tier 2 has none of this: `upscaler = unknown`, ratio `N/A`.
> same word through `SessionProgress.upscalerDriverReported` (`07_IPC`). Segments carry no driver word: the driver's
> bookkeeping is per process, not per settings change. **Nothing native changed and no NGX hook was added**: the
> licence bar in `20_OPEN_QUESTIONS` stands.
>
> **Corrected 2026-10-20 (beta.27): every stored word had lost the rung.** The loop asked the driver once more after its
> last drain — on a session that ended because the game closed, after the game had gone — and that answer, the last,
> was the state (`NgxDriverState`: "the last ANSWERED reading is the state"). The driver still answers for the pid,
> with `CREATED | EVALUATE` cleared: Expedition 33 read `0x8067F` while it ran (2026-09-06) and its stored sessions
> `0x8007F`, the same word without the two bits. Of the 14 sessions in the owner's ledger copy in which the driver
> answered, none kept them — so no stored session reads *DLSS (driver-reported)*, and none on an NGX-direct title under
> an NVIDIA App override reads its mode (D63). Since beta.27 the driver is not asked once the game has gone, and the
> two bits stand once a reading carried them: a game releasing its features on its way out no longer unsays them, and
> every other bit is still the last reading's. Sessions recorded before keep what they stored (`spike-notes` §23).
**The render scale over time (beta.14, D49).** The session summary draws `100 × √(render pixels / output pixels)` — the
per-axis scale, `100 / upscale_ratio` — as steps over the session: from the `render_res` blob where the resolution
@@ -868,7 +892,11 @@ and how much of the time". Schema 0016 (`06_DATA_MODEL`), shared-memory region 4
excludes a pause to within one tick at each edge, as the frame series' gap does. A mode's **share** is its milliseconds
over the observed time (every mode but *No window*). `display_changes` counts samples whose mode differs from the one
before, no-window samples skipped. The sizes — `display_window_*` (client area), `display_buffer_*` (back buffer),
`display_monitor_*` and `display_monitor_hz` — are the ones seen in the mode that lasted longest; `display_source` is the
`display_monitor_*` and `display_monitor_hz` — are the ones seen in the mode that lasted longest *(corrected 2026-10-20,
beta.27: the last ones a sample of that mode SAW — a game leaving exclusive fullscreen closes its window while its swap
chain's last word is under 2 s old, and those last samples, exclusive with no window, had replaced every size: two Lies
of P and three Dark Souls III sessions stored none. A mode no sample of which saw its window keeps the back buffer
alone)*; `display_source` is the
strongest witness any sample had (`swapchain` > `opengl` > `window`). `sessions.swap_effect`, a column since 0001 with no
writer, is written from region 4.
+6 -1
View File
@@ -160,7 +160,12 @@ which makes the notification more important than it was, not less.
> now remembers the newest such process per executable and starts its session when the running one ends, if that one
> ended on its own (not cancelled with the host), the process is the same (pid and start time) and it is then the
> executable's ONLY process — a helper of a game still running has the game beside it and stays turned away, as before
> (`CaptureOrchestratorTests`: the restart recorded, the helper not, a process that left meanwhile not). **Behaviour change:** a game whose folder moved (not its drive letter) records nothing until
> (`CaptureOrchestratorTests`: the restart recorded, the helper not, a process that left meanwhile not). *(beta.27,
> 2026-10-20:)* a launch never said it had ended on its own, so after **Play** ▸ *Start directly* nothing turned away
> while it ran was ever recorded — Lies of P hands itself to Steam within seconds, and twice on 2026-10-19 the game
> Steam started went unrecorded (`spike-notes` §23). A launch now says so, with the processes it and its election
> recorded: the one it started appears to the watcher after the launch began and is turned away like any other, and a
> launch the user stopped does not start again on it. **Behaviour change:** a game whose folder moved (not its drive letter) records nothing until
> *Change executable* points its entry at the new file. `ProcessTree` reads ppid chains with the one rule that defeats pid
> reuse: a child that started before its parent is not its child. `DescendantElection` picks the newest-started
> descendant whose image is tracked — a launcher's consent does not extend to what it spawns, so the elected image
+1 -1
View File
@@ -337,7 +337,7 @@ CREATE TABLE sessions (
display_nowindow_ms INTEGER, -- no window could be read
display_changes INTEGER, -- mode changes between samples
display_source TEXT, -- swapchain | opengl | window: the strongest witness any sample had
display_window_w INTEGER, display_window_h INTEGER, -- client area, in the mode that lasted longest
display_window_w INTEGER, display_window_h INTEGER, -- client area, in the mode that lasted longest (the last seen, beta.27)
display_buffer_w INTEGER, display_buffer_h INTEGER, -- the swap chain's back buffer, same mode
display_monitor_w INTEGER, display_monitor_h INTEGER, display_monitor_hz INTEGER
);
+17
View File
@@ -557,6 +557,16 @@ All screens are `Page`s registered with the navigation page provider and navigat
> mode): recorded from the first frame, never as administrator, refused for a recording-off entry. A viewer's (D52) Play is
> off and its composition holds no `ShellStarter`. Tests: `StoreLaunchesTests`, `StoreRecordsTests`, `GamePlayerTests`,
> `ViewerModeTests`.
>
> **beta.27: a Steam game may hand itself to Steam.** Started by the agent — *Start directly*, or every press while the
> App runs as administrator — a game Steam's records name may leave within seconds and have Steam start it again (Lies
> of P, 2026-10-19; `spike-notes` §23), and since beta.27 the game Steam starts is recorded. The notice says so for such
> a game (`Play_Started_Steam_Format`, `Play_Elevated_Steam_Format`; `PlayResult.SteamGame` from the same store records
> the store mode reads), and the *Start directly* tooltip and Settings ▸ Games ▸ Play button say it for every Steam
> game, the latter adding that a few will not start outside Steam at all. The owner offered two ways (2026-10-20: a note
> in the UI, or a fixed rule that Steam's games always go through Steam) and left the choice open; the note was taken
> because the rule would cost too much: three of the five Steam games started directly on 2026-10-20 ran and were
> measured from their first frame, and a Vulkan game is measured only when FrameLedger starts it (Everhex Demo).
### Session summary (secondary `FluentWindow`, also the post-session toast target)
Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutter %, duration, **Display** — beta.10: the mode shown longest with its share and the window's size, both tiers; **VRAM (this game)** and **RAM (this game)** — beta.12: the median with the peak beneath, both tiers), **Statistics per series** (beta.12: every stored series' mean / median / minimum / peak), TriState chips, API/PresentMode/upscaler line, **the display line** (beta.10: every mode's share, the changes, the window on its monitor at its refresh rate, the back buffer and swap effect, and what the facts rested on — "the swap chain said whether it was exclusive" or "from the window alone: exclusive fullscreen cannot be told from borderless"; absent for a session recorded before), crash `InfoBar` (Severity=Error) when `crashed`, frametime chart, sensor strip, tags/notes editor, Export buttons.
@@ -568,6 +578,13 @@ Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutte
> *DLSS 5 runtime loaded* when it was. The game page's *Last session measured* repeats the label; the CSV export gains
> `# dlss:`. `DlssTextTests`.
> **beta.27: one window per session, and no DLSS line that says only *DLSS*.** Opening a session whose summary window is
> open — from a Sessions tab, a notification, the game page — brings that window forward, restored if minimised, rather
> than opening a second (`SessionSummaryOpener`; the owner had two windows of one Silent Hill 2 session, 2026-10-20). The
> DLSS line is not shown where it would say only *DLSS*: the header names the upscaler, and the NVIDIA App's override
> loads its libraries under names no census lists, which the *Loaded:* line prints (The Witcher 3, 2026-10-20).
> `PagesLoadTests.OpeningAnOpenSessionAgainBringsItsOneWindowForward`, `DlssTextTests`.
> **beta.24 (D63): the quality mode, on every surface alike.** The summary's header line, a Sessions-tab row, the game
> page's *Last session measured* and the live card name the upscaler through one entry point (`Formats.UpscalerOf`):
> the NVIDIA App's override where the driver reports it applied — *DLSS (driver-reported) Quality · NVIDIA App*, or
+15
View File
@@ -125,6 +125,21 @@ own work item on the STA thread and puts back — and with the keys a parameter,
`AnotherHookHarnessRunningBesideTheSuiteDoesNotMakeTheTargetAmbiguous` runs a second harness beside the capture (red
against the shared name: `TargetAmbiguous`). A suite that attaches by pid (`ShmDrainIntegrationTests`, the native
`fl_guard_test`) is not exposed and keeps the staged name.
- **Test readiness: an injection test waits for the harness to say it presents** (beta.27). The suites that start
hook-harness and then inject into it or look for it — `ShmDrainIntegrationTests`, `CaptureHostEndToEndTests`,
`AgentEndToEndTests`, `PartialRecoveryEndToEndTests` — slept 800 ms after starting it, a guess at when it presents.
They now wait, bounded at 30 s, for the line the harness prints and flushes right before its present loop
(`tests/Shared/HarnessReady.cs`, compiled in by `FrameLedger.DrainFixtures.targets`), and the pause case — which read
the writer's status as INIT once under a full gate on 2026-10-19 — waits for the writer's READY
(`WaitUntilInitFinishedAsync`) before it pauses.
- **The guard reads the test host too** (beta.27). The guard's scan set is the target and its ancestors up to a platform
launcher, so for an injection test it includes the test host that started the harness, `dotnet test` and the shell
above them. Under a full gate the test host is still starting its other test classes, and a module it releases
between the guard's list and the module's name refuses as `ModuleScanFailed` — measured 2026-10-20, once in the gate
and once in twelve runs of `FrameLedger.Infrastructure.Tests` with coverage, never in a run of the class alone;
`ProcessUnreadable` (2026-10-19, twice) is the same race met at the list. `ShmDrainIntegrationTests.InjectAsync` asks
again, four times at most, on those two reasons only. The end-to-end suites inject through the Agent or the capture
host, which records such a session as Tier 2; they have the same exposure and have not shown it.
- Guard integration: harness loads a **dummy DLL named like an anti-cheat module** → injection refused pre-launch; loaded late → safety unhook. (A renamed harmless DLL, not real anti-cheat software.)
## Hook overhead measurement (NFR-1, per release)
+1 -1
View File
@@ -237,7 +237,7 @@ Still resolve **entry points defensively at runtime**: `nvapi64.dll` may be abse
| Memory | `NvAPI_GPU_GetMemoryInfoEx` — **not `NvAPI_GPU_GetMemoryInfo`**, which this table named until 2026-08-05. The vendored headers mark it `__nvapi_deprecated_function` ("deprecated in release 520"), so under `/W4 /WX` a call to it fails the native build. **Neither is called (2026-09-10):** the vendored `nvapi.h` (`cd6918f6`) does not declare `GetMemoryInfoEx` at all — the deprecation message names a function the same header set does not ship — so the bridge's `vram` field is **reserved**, its bit is never set, and VRAM stays L1's PDH adapter counter. Taking a newer header set is the way to change that, not a call to the deprecated one |
| **Throttle reasons** | `NvAPI_GPU_GetPerfDecreaseInfo` — not available from L1 or L2. **Bridge (2026-09-10):** the raw reason mask, and 0 is a measurement (no reason), not a clear bit |
| Driver version | `NvAPI_SYS_GetDriverAndBranchVersion` — **bridge (2026-09-10):** `FlNvDriverVersion`, surfaced as `616.64 (r616_41)` |
| **NGX per-process state** | `NvAPI_NGX_GetNGXOverrideState` (R570+) — the driver's feedback word per DLSS feature for a PID, read OUT OF PROCESS by `fl-probe-nvapi --ngx-state` and, since 2026-09-06, by the capture host beside each module snapshot — **in-process through the bridge since 2026-09-10** (`NvapiNgxStateProbe`; the spawn is retired and the words, the merge and the printed block are unchanged). Measured: the SR word's `CREATED \| EVALUATE` is set without an NVIDIA-app override; the FG word follows DLSS-G once created (`CREATED \| EVALUATE` at ×4, corrected the same day — the first reading was blind because it was early), the multiplier bits stay clear; `scalingRatio` is 0 even under an override. Identity only, SR and FG (`03_METRICS` §Upscaling) — and, since beta.24 (D63), the mode an NVIDIA App override set where the word says it applied; its `performanceMode` is in NGX's own numbering (Silent Hill 2, 2026-10-13: the App's Ultra Performance, profile value 5, reported as 3) |
| **NGX per-process state** | `NvAPI_NGX_GetNGXOverrideState` (R570+) — the driver's feedback word per DLSS feature for a PID, read OUT OF PROCESS by `fl-probe-nvapi --ngx-state` and, since 2026-09-06, by the capture host beside each module snapshot — **in-process through the bridge since 2026-09-10** (`NvapiNgxStateProbe`; the spawn is retired and the words, the merge and the printed block are unchanged). Measured: the SR word's `CREATED \| EVALUATE` is set without an NVIDIA-app override; the FG word follows DLSS-G once created (`CREATED \| EVALUATE` at ×4, corrected the same day — the first reading was blind because it was early), the multiplier bits stay clear; `scalingRatio` is 0 even under an override. Identity only, SR and FG (`03_METRICS` §Upscaling) — and, since beta.24 (D63), the mode an NVIDIA App override set where the word says it applied; its `performanceMode` is in NGX's own numbering (Silent Hill 2, 2026-10-13: the App's Ultra Performance, profile value 5, reported as 3). *(Beta.27: never read after the game has gone — that reading, the last, had cleared `CREATED \| EVALUATE` on every stored session — and the two bits stand once a reading carried them: `03_METRICS` §The driver-reported rung.)* |
| **Reflex / PC latency** | `NvAPI_D3D_GetLatency` → per-frame sim/render/present/driver/GPU timestamps; hooking `NvAPI_D3D_SetSleepMode` / `SetLatencyMarker` in the Overlay tells us the game enabled Reflex (`17_HOOK_ENGINE`) |
Reflex latency is the single strongest reason L3 exists — it is genuinely unavailable anywhere else.
+7
View File
@@ -1145,6 +1145,13 @@ outlives a rules change, a game update and *Change executable*; §What a finding
## Crash & stability safety
- Two crashes of the same game within 60 s of injection ⇒ hooking auto-disabled for that game, UI explains, Tier-2 takes over. Recorded in `games.hook_autodisabled_reason`. *"Crash" here is any abnormal end: since beta.8 a session whose exit code is not an exception's (End task's 1) is `normal` on its row, and this policy still counts it inside the window — a hang our hook caused, ended by the user, is the case it exists for. The row's reason says "ended abnormally twice within 60 s of injection" (`04_CAPTURE` §Crash & exit classification).*
- **Measured 2026-10-19/20 (`spike-notes` §23): direct starts turned hooking off for exits no hook caused.** Lies of P
started by **Play** ▸ *Start directly* hands itself to Steam within seconds — its process leaves with nothing
presented and Steam starts the game again —, and Clair Obscur: Expedition 33 started directly closes within five
seconds and reads *crashed*, hooked or not (its third start, refused and unhooked, closed the same way). Each was a
hooked session's early abnormal end; the policy counted them, and two turned hooking off. It cannot tell either from
the hang it exists for, so it stands as written; whether a witness — the same executable started again within
seconds — may exempt a hand-off is the owner's decision, not taken. Users are told in `LIMITATIONS.md` §Play.
- **What reads as a crash changed in beta.14, in both directions** (`04_CAPTURE` §Crash & exit classification): a
Windows report that is not a crash (a memory-leak or hang report) no longer makes one, and an engine's crash reporter
started by a game that then left does — Unreal's crash ended with exit code 3 and read `normal`. Both feed this policy,
+14 -1
View File
@@ -216,7 +216,15 @@ item 21's first branch (`spike-notes` §22).
reads the App's own words, and the mix found ×2.0 / ×3.0 / ×6.1 — plus a ×1336.0 row that was a defect, fixed in
beta.26; (c) the override loads `160_E658700.bin` 310.9.16.0 and `1B0_E658703.dll` 2.14.16.0 from the NGX folder;
(e) **done** — every issue marked; the last six, triaged in `13_CI_CD` §SonarCloud (beta.26), the same day, and
`main`'s quality gate passes. The rest is not run yet.)*
`main`'s quality gate passes. The rest is not run yet.)* *(2026-10-20, the owner's runs of beta.26 — `spike-notes`
§23: (a) **done** — ×2, ×3 and ×4 chosen in Cyberpunk 2077's menu read ×1.9 (ten seconds), ×3.0 and ×4.0, each with
its own rates, under "Set in the game — no NVIDIA App frame-generation override"; **Fixed ×6** on Expedition 33 read
×6.0 under "Set in the NVIDIA App: Fixed ×6"; *Dynamic* on Silent Hill 2 read ×2.0 and ×3.0, plus a ×2.52 row that
was a defect, fixed in beta.27. The Witcher 3 under **Fixed ×6** presented ×2.0 throughout: the rows are the frames,
the line is the setting. (b) **could not pass before beta.27**: every stored driver word had lost
`CREATED | EVALUATE`, read after the game had closed, so an NGX-direct title under the override never read its mode
— run it on beta.27. (c) The Witcher 3 under the override loaded `160_E658700.bin` 310.9.16.0 and `1B0_E658700.dll` 2.14.16.0;
Silent Hill 2 and Expedition 33 loaded `1B0_E658703.dll`.)*
21. **beta.25 on real hardware — FSR's quality mode (D65), decision table written before the run.** Lies of P (FSR
through AMD's FidelityFX libraries) launched by FrameLedger, not attached, with the game's own *FSR* at *Quality*,
then a second session at *Performance* → the summary's header reads *FSR 3 Quality*, then *FSR 3 Performance* (or
@@ -229,6 +237,11 @@ item 21's first branch (`spike-notes` §22).
mode. *(2026-10-19, `spike-notes` §22: the Quality session read **no mode** with the query hooked — the first
branch; 1707×961 is the engine's own rounding of 66.67 %, not the size answer, so the title asked before the hook
was in or never asked. D65 stays built and silent for Lies of P. The Performance session is not run.)*
*(2026-10-20, §23: the Performance session, started through Steam, read "FSR 3 · 1280×720 → 2560×1440" and no mode —
the first branch on both. 1280×720 is exactly the vendor's Performance size, so a query the hook met would have
matched: the title did not ask while the hook was in. It cannot be launched by FrameLedger as this item asks — started
directly it hands itself to Steam within seconds, and before beta.27 the game Steam started was not recorded at
all.)*
**Answered 2026-08-05, do not re-ask:** remove `gameguard` and keep `guard` (approved
over a red `Rules` gate, with the reasoning recorded in the merge commit); vendor NVAPI
headers **and** `amd64/nvapi64.lib`; Windows 11 is the **measurement scope** only —
+1
View File
@@ -46,3 +46,4 @@ Each section below lives in its own file under `docs/spike-notes/`, moved verbat
| §20 | The launcher in front of four itch installs is malware (2026-10-13, beta.21, owner decision D57) | [`spike-notes/20-itch-malware.md`](spike-notes/20-itch-malware.md) |
| §21 | Opening pages and switching tabs in the App (2026-10-14, beta.23) | [`spike-notes/21-app-pages-and-tabs.md`](spike-notes/21-app-pages-and-tabs.md) |
| §22 | The owner's runs of beta.24 and beta.25 on real hardware (2026-10-19) | [`spike-notes/22-owner-runs-2026-10-19.md`](spike-notes/22-owner-runs-2026-10-19.md) |
| §23 | The owner's runs of beta.26 on real hardware (2026-10-20) | [`spike-notes/23-owner-runs-2026-10-20.md`](spike-notes/23-owner-runs-2026-10-20.md) |
@@ -0,0 +1,86 @@
## 23 · The owner's runs of beta.26 on real hardware *(2026-10-20)*
The owner ran the installed 0.1.0-beta.26 the morning after it shipped, 07:47–08:40 local time, and asked for the
latest eight sessions to be checked (sessions 64–71). The numbers below are read from a read-only SQLite backup copy of
the ledger, the Agent's, the App's and the Overlay's logs and Windows' Application log — never the data folder; the
summaries were rendered from the copy by the App's own window in a scratch test. Same PC as §22 (i7-14700KF, RTX 5080,
NVIDIA driver 617.42, 2560×1440 at 240 Hz).
| Session | Game, and how it was started | What it measured |
|---|---|---|
| 64 | Clair Obscur: Expedition 33, through Steam; the NVIDIA App's DLSS override (preset L, *Balanced*) and Frame Generation *Fixed ×6* | ×6.0 for 94.15 % (82 → 491 FPS), 5.85 % not classified; *Set in the NVIDIA App: Fixed ×6*; *DLSS 4.5 (a ×6.0 frame-generation state)*; the header *Upscaler not identified* (the driver's word, below) |
| 65 | Lies of P, through Steam | Tier 2: hooking was off for the game |
| 66 | Lies of P, through Steam; the game's FSR at *Performance*, its frame generation on | *FSR 3 · 1280×720 → 2560×1440*, no mode; ×2.0 for 95.36 % (59.42 → 118.98 FPS) |
| 67 | The Witcher 3, through Steam | Tier 2: its consent was not given yet |
| 68 | The Witcher 3 (Direct3D 12), started directly; the App's DLSS override (preset L) and *Fixed ×6* | *DLSS · 1707×960 → 2560×1440*; ×2.0 for 77.53 % (118.77 → 237.38 FPS), no frame generation 16.94 % (304 FPS), 5.54 % not classified |
| 69 | Cyberpunk 2077, started directly; ×2, ×3 and ×4 chosen in the game's menu, no App override | ×1.9 2.13 % (186 → 353 FPS, 10 s), ×3.0 13.85 % (64 → 190, 65 s), ×4.0 66.03 % (64 → 255, 310 s), no frame generation 9.59 % (375 FPS), 8.41 % not classified; *Set in the game — no NVIDIA App frame-generation override*; *DLSS 4 (a ×4.0 frame-generation state)* |
| 70 | Silent Hill 2, started directly, 67 s | refused `non_uniform` — the shader compilation at start (§22) is most of a 67-second session; no mix |
| 71 | Silent Hill 2, started outside FrameLedger; the App's *Dynamic*, up to ×6 | ×2.0 27.30 %, **×2.52 2.49 %**, ×3.0 62.41 %, no frame generation 2.93 %, 4.88 % not classified |
### Owner-only item 20(a): the three ways frame generation is set
- **Chosen in the game's menu** (Cyberpunk 2077 — the owner: "cyberpunk 2077 là switch in-game"): ×2, ×3 and ×4 each
formed a state with its own Native → Displayed, and the context line read *Set in the game*. The ×2 state was ten
seconds at 186 → 353 FPS, read ×1.9; how long the owner held ×2 is theirs to compare.
- **The App's *Fixed ×6*** (Expedition 33): ×6.0, in the App's own words.
- **The App's *Dynamic*** (Silent Hill 2): ×2.0 and ×3.0 — and a ×2.52 row, below.
- **The Witcher 3 under *Fixed ×6* presented ×2.0 throughout.** The profile and the driver's report both say the
frame-generation override applied (×6); the game presented one generated frame per application frame for the whole
session, VSync on at 240 Hz. The rows are what the game presented and the context line is the setting
(`03_METRICS` §The mix), so the summary shows both. Why the override did not reach this title — its frame generation
is DLSS 3 through Streamline 2.14.1, and the driver loaded `1B0_E658700.dll` 2.14.16.0 beside it — is not
established.
### A ×2.52 state — fixed in beta.27
Session 71's five-second windows, decoded from the copy with the App's own loader: ×2.00 for two minutes, ×3.00 for
three and a half, and where the *Dynamic* multiplier stepped, windows in between — at 135 s, 251 application frames
followed by one generated frame and 270 by two (×2.53), and ×2.62, ×2.70, ×2.31 later. Three of them pooled into a
×2.52 state for 12.8 s. Every shipping frame generation multiplies by a whole number, so a window is now a state's only
within 10 % of a whole multiplier (`FgWindow.IsNearWholeMultiplier`, `03_METRICS` §The mix); the stored row is read by
the same rule, and the session lists ×2.0, ×3.0, no frame generation and 7.36 % not classified. Of the 70 sessions in
the copy, it was the only stored row between two multipliers.
### The driver's word lost what it said while the game ran — fixed in beta.27
Expedition 33's header read *Upscaler not identified*, and no NVIDIA App mode, under an override the driver line
reports as applied (*preset L · Balanced*). Its stored super-resolution word is `0x8007F`; on 2026-09-06 the same game
under the same kind of override read `0x8067F` while it ran (§9) — the same word with `CREATED | EVALUATE`. The loop
asked the driver one last time after its last drain, after the game had closed, and that answer — the driver still
answers for the pid, with the two bits cleared — was the stored state. Of the 14 sessions in the copy in which the
driver answered, none kept the two bits; The Witcher 3's 2026-10-04 session (DLSS through Streamline, the game's own
library) stored `0x5` with its words marked *changed* between readings. So no stored session could read *DLSS
(driver-reported)*, and none on an NGX-direct title could name the override's mode (D63): owner-only item 20(b) could
not pass on any build before beta.27. Since beta.27 the driver is not asked once the game has gone, and the two bits
stand once a reading carried them (`NgxDriverState.Merge`).
### Start directly, and the crash safety
- **Lies of P hands itself to Steam** (2026-10-19, 21:43 and 21:46, *Start directly*): the process FrameLedger started
left within five seconds with nothing presented, and Steam started the game 1 s later. That process was turned away
while the first session was ending ("one at a time") and never recorded — a launch never said it had ended on its
own, so nothing turned away during one was started after it. Fixed in beta.27 (`04_CAPTURE` §Watch).
- **Expedition 33 closes when started directly** (2026-10-20, 07:49–07:50, three starts): each process left within
five seconds and read *crashed*, the third one refused and unhooked; no crash report and no Unreal crash folder for
any of them. Through Steam the game ran.
- **The crash safety counted those exits.** Each was a hooked session's early abnormal end, and two turned hooking off:
Lies of P at 21:46:36 on 2026-10-19 (the owner switched it on again within a minute; session 61 was measured),
Expedition 33 after its second direct start (07:49:46; the third start was refused) and again at 07:51:06 — after a
start outside FrameLedger that closed four seconds in with one frame presented, hooked: the only early exit of the
morning that no direct start explains. The policy cannot tell a hand-off from the hang it exists for (`19_SAFETY`
§Crash & stability safety); `LIMITATIONS.md` §Play tells users to start such a game through its store.
### The rest
- **Display sizes**: Lies of P's two sessions and three of Dark Souls III's stored no window or monitor size. A game
leaving exclusive full-screen closes its window while its swap chain's last word is still fresh, and the tally kept
the mode's last sample — exclusive, no window. Fixed in beta.27 (`03_METRICS` §Display mode).
- **The DLSS line read only *DLSS*** on The Witcher 3 under the override: the driver's copies loaded under names no
census lists (`160_E658700.bin` 310.9.16.0, `1B0_E658700.dll` 2.14.16.0 — note `…700.dll` where Silent Hill 2 and
Expedition 33 loaded `1B0_E658703.dll`). A line that would say only *DLSS* is not shown since beta.27; the *Loaded:*
line prints the files.
- **Two summary windows of one session** (the owner's screenshot): opening a session whose window is open now brings
that window forward.
- **Owner-only item 21** (FSR's mode on Lies of P): the *Performance* session read no mode either — the first branch on
both. Its render size, 1280×720, is exactly the vendor's Performance size, so a query the hook met would have
matched: the title did not ask while the hook was in. It cannot be launched by FrameLedger as the item asks.
+1 -1
View File
@@ -21,7 +21,7 @@ A value FrameLedger could not measure reads **N/A** — never 0, and never an es
- **The DLSS line** names the DLSS the game ran: *DLSS 4.5* or *DLSS 4* only when the session showed it (the model
preset the NVIDIA driver reports, or a frame-generation multiplier of ×3 and above), each DLSS library's version and
whether it came from the game or from the graphics driver (the NVIDIA App can swap in the driver's copy), and *DLSS 5
runtime loaded* when it was.
runtime loaded* when it was. With nothing to add to the header's *DLSS*, it is not shown.
- **Frame generation in this session** (sessions recorded with 0.1.0-beta.24 or later) lists every frame-generation
state the session held — `×2.0`, `×4.0`… — each with its own frame rates and its share of the time, then the time
without frame generation, and *Not classified* for time in no state that lasted at least 10 seconds: switching,
+1 -1
View File
@@ -50,7 +50,7 @@ The link under them, *Read what the hook does and does not do*, opens the safety
|---|---|---|
| **Show game artwork** | A game's page shows a picture of the game: the image you chose for it (**Edit…**), or else the cover and banner the Steam or GOG GALAXY app already keeps on your PC. Nothing is downloaded; a game from another store shows a picture only once you choose one. | On |
| **Colour the game page from its artwork** | The band at the top of a game's page takes the picture's main colour — never so strongly that a text on it gets hard to read. Off, the band keeps the plain card colour. | On |
| **Play button** | What **Play** does, on a game's page and on each game in the library. *Through the store*: Steam or the Epic Games Launcher starts the game, GOG GALAXY runs it, and the itch app asks which copy to launch — each store's app does what it does when you start a game from it. A game no store installed, and a GOG game without GOG GALAXY, is started by FrameLedger instead; so is every game while FrameLedger itself runs as administrator, so that the game does not. *Start directly*: FrameLedger's agent starts the game, recorded from its first frame, with your standard rights; it does not start a game whose recording is off, or one that asks to run as administrator. | Through the store |
| **Play button** | What **Play** does, on a game's page and on each game in the library. *Through the store*: Steam or the Epic Games Launcher starts the game, GOG GALAXY runs it, and the itch app asks which copy to launch — each store's app does what it does when you start a game from it. A game no store installed, and a GOG game without GOG GALAXY, is started by FrameLedger instead; so is every game while FrameLedger itself runs as administrator, so that the game does not. *Start directly*: FrameLedger's agent starts the game, recorded from its first frame, with your standard rights; it does not start a game whose recording is off, or one that asks to run as administrator. Some Steam games hand themselves to Steam when started directly — the game Steam then starts is recorded — and a few will not start outside Steam at all: start those through the store. | Through the store |
## Window
+1
View File
@@ -32,6 +32,7 @@ While the game runs, a notice may say *hooking refused*.
| **Disable all hooking** is on. | Switch it off in Settings ▸ Capture. |
| The game was already running when FrameLedger was updated. | Close the game and start it again. |
| Hooking was switched off after the game crashed twice soon after it started. | Switch it on again in the game's page if the cause may be gone — after a driver update, for example. |
| Hooking was switched off after **Play** started the game directly twice, and each time the game handed itself to Steam or closed at once. | Switch it on again, and set Settings ▸ Games ▸ **Play button** to *Through the store*: some Steam games will not start any other way. |
| The game's file is gone. | If only its drive letter changed, FrameLedger follows it within about 15 seconds; otherwise **Change executable…** on the game's page. |
| The component could not be loaded into the game. | [Report a problem](#report-a-problem). |
+7 -3
View File
@@ -46,7 +46,10 @@ public static class DlssText
/// <summary>
/// The summary's DLSS line: the label first when one is established, then each library with its version, where it was
/// loaded from and — for super resolution — the preset the driver reports, then DLSS 5's runtime when it was loaded.
/// Null for a session with no DLSS library, no DLSS upscaler and no DLSS Frame Generation.
/// Null for a session with no DLSS library, no DLSS upscaler and no DLSS Frame Generation — and, since beta.27, where it
/// would say only "DLSS": the header already names the upscaler. The NVIDIA App's override loads its libraries under
/// names no census lists (Witcher 3, 2026-10-20: <c>160_E658700.bin</c>, which the loaded-libraries line prints), and an
/// unreadable module list names none.
/// </summary>
public static string? Line(SessionRow row)
{
@@ -61,7 +64,8 @@ public static class DlssText
}
DlssEvidence evidence = Evidence(row);
var parts = new List<string> { DlssGeneration.Of(evidence) is { } generation ? LabelOf(generation, evidence) : "DLSS" };
string? label = DlssGeneration.Of(evidence) is { } generation ? LabelOf(generation, evidence) : null;
var parts = new List<string> { label ?? "DLSS" };
AddLibrary(parts, modules, sources, _superResolutionFile, Strings.Dlss_Feature_SuperResolution, PresetText(evidence.Preset));
AddLibrary(parts, modules, sources, _rayReconstructionFile, Strings.Dlss_Feature_RayReconstruction, detail: null);
AddLibrary(parts, modules, sources, _frameGenerationFile, Strings.Dlss_Feature_FrameGeneration, detail: null);
@@ -75,7 +79,7 @@ public static class DlssText
parts.Add(Strings.Dlss_NeuralRendering_Loaded);
}
return string.Join(" · ", parts);
return label is null && parts.Count == 1 ? null : string.Join(" · ", parts);
}
/// <summary>The CSV header's line, InvariantCulture: the generation and its basis, each DLSS library with its version and source, the preset.</summary>
+21 -6
View File
@@ -53,6 +53,7 @@ public sealed class GamePlayer
{
ArgumentNullException.ThrowIfNull(game);
PlayFallback fallback = PlayFallback.None;
StoreGame? record = null;
if (!await IsDirectAsync(ct).ConfigureAwait(false))
{
if (_elevated())
@@ -61,7 +62,7 @@ public sealed class GamePlayer
}
else
{
StoreGame? record = StoreRecords.Owning(game.Fingerprint.ExePath, game.StoreId, await _stores.ReadAsync("play", ct: ct).ConfigureAwait(false));
record = await OwningAsync(game, ct).ConfigureAwait(false);
if (record is null)
{
fallback = PlayFallback.NoStore;
@@ -79,7 +80,16 @@ public sealed class GamePlayer
}
}
return await StartDirectlyAsync(game, fallback, ct).ConfigureAwait(false);
// beta.27: a game Steam installed may hand itself to Steam when something else starts it (Lies of P, 2026-10-19:
// its process left within seconds and Steam started the game again), and the notice says so. No store's records
// name a game that fell back for want of one, so they are read only where they were not already.
if (fallback is PlayFallback.None or PlayFallback.Elevated)
{
record = await OwningAsync(game, ct).ConfigureAwait(false);
}
bool steamGame = string.Equals(record?.Platform, "steam", StringComparison.Ordinal);
return await StartDirectlyAsync(game, fallback, steamGame, ct).ConfigureAwait(false);
}
/// <summary>The notice a result is said with: its text, and whether it is a warning.</summary>
@@ -99,8 +109,9 @@ public sealed class GamePlayer
{
PlayFallback.NoStore => string.Format(CultureInfo.CurrentCulture, Strings.Play_NoStore_Format, gameName),
PlayFallback.NoGalaxy => string.Format(CultureInfo.CurrentCulture, Strings.Play_NoGalaxy_Format, gameName),
PlayFallback.Elevated => string.Format(CultureInfo.CurrentCulture, Strings.Play_Elevated_Format, gameName),
_ => string.Format(CultureInfo.CurrentCulture, Strings.Play_Started_Format, gameName),
PlayFallback.Elevated => string.Format(CultureInfo.CurrentCulture,
result.SteamGame ? Strings.Play_Elevated_Steam_Format : Strings.Play_Elevated_Format, gameName),
_ => string.Format(CultureInfo.CurrentCulture, result.SteamGame ? Strings.Play_Started_Steam_Format : Strings.Play_Started_Format, gameName),
}, false),
PlayOutcome.AgentUnavailable => (string.Format(CultureInfo.CurrentCulture, Strings.Play_AgentUnavailable_Format, gameName), true),
PlayOutcome.Unanswered => (Strings.Agent_Unanswered, true),
@@ -114,6 +125,10 @@ public sealed class GamePlayer
};
}
/// <summary>The record of the store that installed <paramref name="game"/>, if any store's own records name its folder.</summary>
private async Task<StoreGame?> OwningAsync(GameRow game, CancellationToken ct) =>
StoreRecords.Owning(game.Fingerprint.ExePath, game.StoreId, await _stores.ReadAsync("play", ct: ct).ConfigureAwait(false));
private PlayResult HandOff(GameRow game, StoreLaunch launch)
{
bool handed = launch.Kind == StoreLaunchKind.RunProgram
@@ -139,7 +154,7 @@ public sealed class GamePlayer
return PlayFallback.NoLink;
}
private async Task<PlayResult> StartDirectlyAsync(GameRow game, PlayFallback fallback, CancellationToken ct)
private async Task<PlayResult> StartDirectlyAsync(GameRow game, PlayFallback fallback, bool steamGame, CancellationToken ct)
{
if (!_agent.IsConnected)
{
@@ -180,7 +195,7 @@ public sealed class GamePlayer
Log.Information("play: {Game} (id {Id}) through the agent: {Outcome}", game.Name, game.Id, ack.Outcome);
return ack.Outcome switch
{
_ when ack.Accepted => new PlayResult(PlayOutcome.StartedByAgent, Fallback: fallback),
_ when ack.Accepted => new PlayResult(PlayOutcome.StartedByAgent, Fallback: fallback, SteamGame: steamGame),
"RecordingOff" => new PlayResult(PlayOutcome.RecordingOff, Fallback: fallback),
"SessionRunning" => new PlayResult(PlayOutcome.AlreadyRunning, Fallback: fallback),
"UnknownGame" => new PlayResult(PlayOutcome.NotInLibrary, Fallback: fallback),
+6 -2
View File
@@ -3,5 +3,9 @@
namespace FrameLedger.App.Services;
/// <summary>One press of Play: what happened, which store's app has it, why it fell back, and the agent's own word on a failure.</summary>
public sealed record PlayResult(PlayOutcome Outcome, string? Store = null, PlayFallback Fallback = PlayFallback.None, string? Detail = null);
/// <summary>
/// One press of Play: what happened, which store's app has it, why it fell back, the agent's own word on a failure — and,
/// since beta.27, whether the game the agent started is one Steam installed, which may hand itself to Steam first.
/// </summary>
public sealed record PlayResult(PlayOutcome Outcome, string? Store = null, PlayFallback Fallback = PlayFallback.None, string? Detail = null,
bool SteamGame = false);
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using FrameLedger.App.Charts;
using FrameLedger.App.ViewModels;
using FrameLedger.App.Windows;
@@ -14,7 +15,8 @@ namespace FrameLedger.App.Services;
/// Builds a summary window per open: the view model's override prompt is bound to THAT window's dialog host,
/// which is why the window is composed here rather than resolved whole from DI. The load runs after
/// <c>Show()</c> so the window appears at once and fills in. It keeps the windows it opened, so that Delete all sessions
/// can close the ones whose session is gone (<see cref="ISessionWindows"/>, beta.11).
/// can close the ones whose session is gone (<see cref="ISessionWindows"/>, beta.11), and so that a session has ONE summary
/// window: opening it again brings that window forward (beta.27 — the owner had two of the same session side by side).
/// </summary>
public sealed class SessionSummaryOpener : ISessionSummaryOpener, ISessionWindows
{
@@ -32,9 +34,21 @@ public sealed class SessionSummaryOpener : ISessionSummaryOpener, ISessionWindow
_selection = selection ?? throw new ArgumentNullException(nameof(selection));
}
/// <summary>The sessions whose summary is open, in the order they were opened (tests read it).</summary>
internal IReadOnlyList<long> OpenSessions => [.. _open.Select(static o => o.SessionId)];
public void Open(long sessionId)
{
_selection.Set(sessionId); // File ▸ Export follows the window the user opened last (P4 PR-3)
foreach ((long SessionId, SessionSummaryWindow Window) existing in _open)
{
if (existing.SessionId == sessionId)
{
BringForward(existing.Window);
return;
}
}
SessionSummaryWindow? window = null;
var viewModel = new SessionSummaryViewModel(
_services.GetRequiredService<ISessionRepository>(),
@@ -69,6 +83,17 @@ public sealed class SessionSummaryOpener : ISessionSummaryOpener, ISessionWindow
}
}
/// <summary>The open window, back in front of the user: out of the taskbar first if it was minimised.</summary>
private static void BringForward(Window window)
{
if (window.WindowState == WindowState.Minimized)
{
window.WindowState = WindowState.Normal;
}
window.Activate();
}
private static async Task LoadAsync(SessionSummaryViewModel viewModel, long sessionId)
{
try
+6
View File
@@ -767,6 +767,7 @@ public static class Strings
nameof(Play_AlreadyRunning_Format),
nameof(Play_Button),
nameof(Play_Elevated_Format),
nameof(Play_Elevated_Steam_Format),
nameof(Play_Epic_Format),
nameof(Play_Failed_Format),
nameof(Play_Gog_Format),
@@ -778,6 +779,7 @@ public static class Strings
nameof(Play_RecordingOff_Fallback_Format),
nameof(Play_RecordingOff_Format),
nameof(Play_Started_Format),
nameof(Play_Started_Steam_Format),
nameof(Play_Steam_Format),
nameof(Play_Title),
nameof(Play_ToolTip_Direct),
@@ -2645,6 +2647,8 @@ public static class Strings
public static string Play_Elevated_Format => ResourceManager.GetString(nameof(Play_Elevated_Format), Culture) ?? nameof(Play_Elevated_Format);
public static string Play_Elevated_Steam_Format => ResourceManager.GetString(nameof(Play_Elevated_Steam_Format), Culture) ?? nameof(Play_Elevated_Steam_Format);
public static string Play_Epic_Format => ResourceManager.GetString(nameof(Play_Epic_Format), Culture) ?? nameof(Play_Epic_Format);
public static string Play_Failed_Format => ResourceManager.GetString(nameof(Play_Failed_Format), Culture) ?? nameof(Play_Failed_Format);
@@ -2667,6 +2671,8 @@ public static class Strings
public static string Play_Started_Format => ResourceManager.GetString(nameof(Play_Started_Format), Culture) ?? nameof(Play_Started_Format);
public static string Play_Started_Steam_Format => ResourceManager.GetString(nameof(Play_Started_Steam_Format), Culture) ?? nameof(Play_Started_Steam_Format);
public static string Play_Steam_Format => ResourceManager.GetString(nameof(Play_Steam_Format), Culture) ?? nameof(Play_Steam_Format);
public static string Play_Title => ResourceManager.GetString(nameof(Play_Title), Culture) ?? nameof(Play_Title);
+10 -2
View File
@@ -4230,7 +4230,15 @@
<comment>review</comment>
</data>
<data name="Play_ToolTip_Direct" xml:space="preserve">
<value>プレイ: FrameLedger がゲームを自分で起動します。最初のフレームから記録し、通常の権限で実行します。</value>
<value>プレイ: FrameLedger がゲームを自分で起動します。最初のフレームから記録し、通常の権限で実行します。Steam のゲームは先に Steam へ起動を引き継ぐことがあります。その場合は Steam が起動したゲームを記録します。</value>
<comment>review</comment>
</data>
<data name="Play_Started_Steam_Format" xml:space="preserve">
<value>FrameLedger が {0} を起動しています。Steam のゲームは先に Steam へ起動を引き継ぐことがあります。その場合は Steam が起動したゲームを記録します。</value>
<comment>review</comment>
</data>
<data name="Play_Elevated_Steam_Format" xml:space="preserve">
<value>FrameLedger が管理者として実行されているため、ストアではなくキャプチャ エージェントが通常の権限で {0} を起動しています。Steam のゲームは先に Steam へ起動を引き継ぐことがあります。その場合は Steam が起動したゲームを記録します。</value>
<comment>review</comment>
</data>
<data name="Play_Title" xml:space="preserve">
@@ -4298,7 +4306,7 @@
<comment>review</comment>
</data>
<data name="Settings_PlayMode_Body" xml:space="preserve">
<value>ストア経由: Steam と Epic Games Launcher がゲームを起動し、GOG GALAXY が実行し、itch アプリは先に確認します。どのストアからもインストールされていないゲームは FrameLedger が起動します。直接: FrameLedger がゲームを自分で起動します。最初のフレームから記録し、通常の権限で実行します。</value>
<value>ストア経由: Steam と Epic Games Launcher がゲームを起動し、GOG GALAXY が実行し、itch アプリは先に確認します。どのストアからもインストールされていないゲームは FrameLedger が起動します。直接: FrameLedger がゲームを自分で起動します。最初のフレームから記録し、通常の権限で実行します。一部の Steam ゲームは直接起動すると Steam へ起動を引き継ぎます (その後 Steam が起動したゲームを記録します)。Steam 以外からは起動できないゲームもあるため、それらはストア経由で起動してください。</value>
<comment>review</comment>
</data>
<data name="Settings_PlayMode_Store" xml:space="preserve">
+8 -2
View File
@@ -3183,7 +3183,13 @@ The documents below are the full terms; this summary does not replace them.</val
<value>Play through the store that installed the game: Steam or the Epic Games Launcher starts it, GOG GALAXY runs it, the itch app asks first. A game no store installed is started by FrameLedger.</value>
</data>
<data name="Play_ToolTip_Direct" xml:space="preserve">
<value>Play: FrameLedger starts the game itself, recorded from its first frame, with your standard rights.</value>
<value>Play: FrameLedger starts the game itself, recorded from its first frame, with your standard rights. A Steam game may hand itself to Steam first; the game Steam then starts is recorded.</value>
</data>
<data name="Play_Started_Steam_Format" xml:space="preserve">
<value>FrameLedger is starting {0}. A Steam game may hand itself to Steam first; the game Steam then starts is recorded.</value>
</data>
<data name="Play_Elevated_Steam_Format" xml:space="preserve">
<value>FrameLedger is running as administrator, so the capture agent is starting {0} with your standard rights instead of its store. A Steam game may hand itself to Steam first; the game Steam then starts is recorded.</value>
</data>
<data name="Play_Title" xml:space="preserve">
<value>Play</value>
@@ -3234,7 +3240,7 @@ The documents below are the full terms; this summary does not replace them.</val
<value>Play button</value>
</data>
<data name="Settings_PlayMode_Body" xml:space="preserve">
<value>Through the store: Steam and the Epic Games Launcher start the game, GOG GALAXY runs it, the itch app asks first; a game no store installed is started by FrameLedger. Directly: FrameLedger starts the game itself — recorded from its first frame, with your standard rights.</value>
<value>Through the store: Steam and the Epic Games Launcher start the game, GOG GALAXY runs it, the itch app asks first; a game no store installed is started by FrameLedger. Directly: FrameLedger starts the game itself — recorded from its first frame, with your standard rights. Some Steam games hand themselves to Steam when started directly — the game Steam then starts is recorded — and a few will not start outside Steam at all: start those through the store.</value>
</data>
<data name="Settings_PlayMode_Store" xml:space="preserve">
<value>Through the store</value>
+8 -2
View File
@@ -3178,7 +3178,13 @@ Các văn bản bên dưới là điều khoản đầy đủ; bản tóm tắt
<value>Chơi qua store đã cài game: Steam hoặc Epic Games Launcher sẽ chạy game, GOG GALAXY chạy game, app itch hỏi trước. Game không do store nào cài thì FrameLedger tự chạy.</value>
</data>
<data name="Play_ToolTip_Direct" xml:space="preserve">
<value>Chơi: FrameLedger tự chạy game, ghi lại từ khung hình đầu tiên, với quyền thường của bạn.</value>
<value>Chơi: FrameLedger tự chạy game, ghi lại từ khung hình đầu tiên, với quyền thường của bạn. Game Steam có thể tự chuyển sang Steam trước; game do Steam chạy sau đó vẫn được ghi lại.</value>
</data>
<data name="Play_Started_Steam_Format" xml:space="preserve">
<value>FrameLedger đang chạy {0}. Game Steam có thể tự chuyển sang Steam trước; game do Steam chạy sau đó vẫn được ghi lại.</value>
</data>
<data name="Play_Elevated_Steam_Format" xml:space="preserve">
<value>FrameLedger đang chạy với quyền quản trị, nên capture agent sẽ chạy {0} với quyền thường của bạn thay vì qua store. Game Steam có thể tự chuyển sang Steam trước; game do Steam chạy sau đó vẫn được ghi lại.</value>
</data>
<data name="Play_Title" xml:space="preserve">
<value>Chơi</value>
@@ -3229,7 +3235,7 @@ Các văn bản bên dưới là điều khoản đầy đủ; bản tóm tắt
<value>Nút Chơi</value>
</data>
<data name="Settings_PlayMode_Body" xml:space="preserve">
<value>Qua store: Steam và Epic Games Launcher chạy game, GOG GALAXY chạy game, app itch hỏi trước; game không do store nào cài thì FrameLedger tự chạy. Chạy trực tiếp: FrameLedger tự chạy game — ghi lại từ khung hình đầu tiên, với quyền thường của bạn.</value>
<value>Qua store: Steam và Epic Games Launcher chạy game, GOG GALAXY chạy game, app itch hỏi trước; game không do store nào cài thì FrameLedger tự chạy. Chạy trực tiếp: FrameLedger tự chạy game — ghi lại từ khung hình đầu tiên, với quyền thường của bạn. Một số game Steam tự chuyển sang Steam khi được chạy trực tiếp — game do Steam chạy sau đó vẫn được ghi lại — và vài game không chạy được ngoài Steam: hãy chạy chúng qua store.</value>
</data>
<data name="Settings_PlayMode_Store" xml:space="preserve">
<value>Qua store</value>
@@ -557,8 +557,8 @@ public sealed class CaptureSession(
// ONE LAST SNAPSHOT before the last drain, so a module that loaded after the final scan is
// still named; on TargetExited it reads nothing, which the tally counts rather than hides. The last
// display sample stands until here (beta.10).
state.Loaded.Take(pid);
// display sample stands until here (beta.10). The driver is not asked once the game has gone (Take, beta.27).
state.Loaded.Take(pid, askDriver: !(alive.HasExited || end == SessionEndReason.TargetExited));
state.Display.Finish(state.Paused);
// ONE LAST DRAIN ON EVERY PATH, including the faulted one — that is the whole point of catching
@@ -647,7 +647,14 @@ public sealed class CaptureSession(
/// </summary>
public List<long> TouchQpc { get; } = [];
public void Take(int pid)
/// <summary>One touch: the module snapshot, and the driver's NGX word unless <paramref name="askDriver"/> is false.</summary>
/// <param name="pid">The target.</param>
/// <param name="askDriver">
/// False once the game has gone (beta.27): the driver still answers for its pid, with the bits that say a feature ran
/// cleared, and that answer — the last — replaced every reading taken while the game ran. No session the owner
/// stored from 2026-10-04 to 2026-10-20 kept CREATED | EVALUATE.
/// </param>
public void Take(int pid, bool askDriver = true)
{
TouchQpc.Add(System.Diagnostics.Stopwatch.GetTimestamp());
if (source is not null)
@@ -655,7 +662,7 @@ public sealed class CaptureSession(
Set = Set.Merge(source.Take(pid));
}
if (ngxSource is not null)
if (ngxSource is not null && askDriver)
{
Ngx = Ngx.Merge(ngxSource.Run(pid));
}
@@ -26,6 +26,13 @@ namespace FrameLedger.Application.Capture;
/// ones the driver answered, and <see cref="Changed"/> whether two answered readings disagreed on a mask — a
/// title switching DLSS on mid-session would show as a change, and the report prints it rather than averaging.
/// </para>
/// <para>
/// <b>Except the two bits that say a feature ran</b> (beta.27): <see cref="NgxOverrideFlags.Created"/> and
/// <see cref="NgxOverrideFlags.Evaluate"/>, once an answered reading carried them, stand for the session. The driver clears
/// them when the game releases the feature — on its way out, at a settings change —, and the reading taken after a game
/// had gone was the last one: Expedition 33 read <c>0x8067F</c> while it ran (2026-09-06) and every stored session of it
/// <c>0x8007F</c>, the same word without them.
/// </para>
/// </remarks>
public sealed record NgxDriverState(
NgxProbeOutcome Outcome,
@@ -142,6 +149,15 @@ public sealed record NgxDriverState(
}
bool changed = Changed || (Outcome == NgxProbeOutcome.Answered && (Sr != later.Sr || Rr != later.Rr || Fg != later.Fg));
return later with { Readings = readings, Answered = answered, Changed = changed };
ulong ran = Outcome == NgxProbeOutcome.Answered ? NgxOverrideFlags.CreatedAndEvaluated : 0;
return later with
{
Sr = later.Sr | (Sr & ran),
Rr = later.Rr | (Rr & ran),
Fg = later.Fg | (Fg & ran),
Readings = readings,
Answered = answered,
Changed = changed,
};
}
}
@@ -21,8 +21,9 @@ public sealed record FgMixRecord(IReadOnlyList<FgMixRecordRow> Rows)
/// <summary>The column's text back, or null for a null/empty/unparsable column (a writer that predates it, or a hand edit).</summary>
/// <remarks>
/// <b>Read by today's rule</b> (beta.26): a stored state no window of this build would form — a factor above
/// <see cref="FgWindow.GenerationCeiling"/>, or windows that averaged fewer than <see cref="FgWindow.MinPerBucket"/>
/// application frames — is time no state claims, and joins the not-classified row. beta.24 and beta.25 stored such a
/// <see cref="FgWindow.GenerationCeiling"/>, windows that averaged fewer than <see cref="FgWindow.MinPerBucket"/>
/// application frames, or since beta.27 a factor between two whole multipliers (Silent Hill 2, 2026-10-20: ×2.52) — is
/// time no state claims, and joins the not-classified row. beta.24 and beta.25 stored such a
/// row for a stretch presented through with one token per window (Silent Hill 2, 2026-10-19: ×1336.0,
/// 0.20 → 267.20 FPS), and the summary listed it and the DLSS line cited it. Every other row is as stored, and the
/// shares still add up to the whole.
@@ -75,6 +76,6 @@ public sealed record FgMixRecord(IReadOnlyList<FgMixRecordRow> Rows)
private static bool IsUnreadableState(FgMixRecordRow row) =>
FgMixRecordRow.KindOf(row.Kind) == FgMixKind.Generated
&& (row.Factor is not double factor || factor > FgWindow.GenerationCeiling
&& (row.Factor is not double factor || factor > FgWindow.GenerationCeiling || !FgWindow.IsNearWholeMultiplier(factor)
|| row.NativeFps is not double native || native * FgSteadyState.WindowSeconds < FgWindow.MinPerBucket);
}
@@ -290,7 +290,7 @@ public sealed class CaptureOrchestrator
}
var running = new Running(Guid.NewGuid(), game.Id);
running.Task = RunLaunchAsync(game, arguments, running.SessionGuid, running.Stop.Token, ct);
running.Task = RunLaunchAsync(game, arguments, running, ct);
_running[path] = running;
return new LaunchResult(LaunchOutcome.Accepted, running.SessionGuid);
}
@@ -433,8 +433,9 @@ public sealed class CaptureOrchestrator
private static string SessionId(RecordRequest request) => request.SessionGuid?.ToString("N") ?? "(unnamed)";
/// <summary>Launch mode on its own task: the environment, the session, the election, each reported.</summary>
private async Task RunLaunchAsync(GameRow game, string arguments, Guid sessionGuid, CancellationToken stop, CancellationToken ct)
private async Task RunLaunchAsync(GameRow game, string arguments, Running running, CancellationToken ct)
{
Guid sessionGuid = running.SessionGuid;
try
{
string path = game.Fingerprint.ExePath;
@@ -449,7 +450,7 @@ public sealed class CaptureOrchestrator
Arguments = arguments,
GameName = game.Name,
SessionGuid = sessionGuid,
StopToken = stop,
StopToken = running.Stop.Token,
};
RecordedSession r = await Task.Run(() => launch.Recorder.RecordAsync(request, ct), ct).ConfigureAwait(false);
Report(r, game.Name);
@@ -459,6 +460,13 @@ public sealed class CaptureOrchestrator
{
Report(elected, $"elected after {game.Name}");
}
// beta.27: what Reap needs to record a game started again when this launch ends — that it ended on its own, and
// the processes it recorded. Until now a launch never said so, and a process turned away while it ran was never
// recorded: Lies of P (2026-10-19), started directly, handed itself to Steam within seconds, and the game Steam
// started went unrecorded, twice.
running.Targets = elected is null ? [r.Outcome.TargetPid] : [r.Outcome.TargetPid, elected.Outcome.TargetPid];
running.Recorded = elected ?? r;
}
catch (OperationCanceledException)
{
@@ -553,13 +561,15 @@ public sealed class CaptureOrchestrator
/// only if the session ended on its own (a cancelled or faulted one — the host stopping — starts nothing), the process
/// is still the same one (pid and start time), and it is then the executable's ONLY process: a game started again has
/// replaced the old one, where a helper of a multi-process game (NW.js, Electron — one executable, many processes)
/// still has the game beside it, or several of its kind.
/// still has the game beside it, or several of its kind. Never a process the session itself recorded (beta.27): the one
/// a launch started appears to the watcher after the launch began, and is turned away like any other — a launch the user
/// stopped must not start again on the game it stopped recording.
/// </summary>
private sealed record Deferred(TrackedProcessAppeared Appeared, DateTimeOffset? StartedAt)
{
public bool StartsAfter(Running ended, IReadOnlyList<ProcessSnapshot> snapshot)
{
if (ended.Recorded is null)
if (ended.Recorded is null || ended.Targets.Contains(Appeared.Pid))
{
return false;
}
@@ -584,6 +594,9 @@ public sealed class CaptureOrchestrator
/// <summary>The session as recorded; null until it ended, and for one cancelled or faulted. Written before <see cref="Task"/> completes.</summary>
public RecordedSession? Recorded { get; set; }
/// <summary>The processes a launch and its election recorded (beta.27); written with <see cref="Recorded"/>, empty for a watched session.</summary>
public IReadOnlyCollection<int> Targets { get; set; } = [];
public void Dispose() => Stop.Dispose();
}
}
@@ -22,7 +22,15 @@ public sealed class DisplayTally
{
long ms = Math.Max(0, elapsedMs);
_ms[observation.Mode] = _ms.GetValueOrDefault(observation.Mode) + ms;
_last[observation.Mode] = observation;
// The sizes are those of the mode's last sample that SAW the window (beta.27). A game leaving exclusive fullscreen
// destroys its window while its swap chain's last word is still fresh, and those last samples — exclusive, no
// window — replaced every size: five Lies of P and Dark Souls III sessions (2026-10-18 to 20) stored none.
if (observation.Client is not null || !_last.TryGetValue(observation.Mode, out DisplayObservation kept) || kept.Client is null)
{
_last[observation.Mode] = observation;
}
if (DisplaySource.Strength(observation.Source) > DisplaySource.Strength(_source))
{
_source = observation.Source;
+6 -3
View File
@@ -27,10 +27,13 @@ internal static class FgSlices
public bool IsReadable => Samples >= FgWindow.MinPerBucket && Tokens >= FgWindow.MinPerBucket;
/// <summary>
/// Generating: readable, at least <see cref="FgWindow.ActiveThreshold"/>, and no more than
/// <see cref="FgWindow.GenerationCeiling"/> — above it the ratio is no frame generation's.
/// Generating: readable, at least <see cref="FgWindow.ActiveThreshold"/>, no more than
/// <see cref="FgWindow.GenerationCeiling"/> — above it the ratio is no frame generation's — and near a whole
/// multiplier (<see cref="FgWindow.IsNearWholeMultiplier"/>, beta.27): a window between two changed state inside
/// itself, and is no state's.
/// </summary>
public bool IsActive => IsReadable && Displayed >= Tokens * FgWindow.ActiveThreshold && Factor <= FgWindow.GenerationCeiling;
public bool IsActive => IsReadable && Displayed >= Tokens * FgWindow.ActiveThreshold && Factor <= FgWindow.GenerationCeiling
&& FgWindow.IsNearWholeMultiplier(Factor);
}
/// <summary>
@@ -184,6 +184,20 @@ public sealed record FgWindow
/// </summary>
public const double GenerationCeiling = 8.0;
/// <summary>
/// Whether <paramref name="factor"/> sits within <see cref="BucketTolerance"/> of a whole multiplier of two or more
/// (beta.27). Every frame generation that ships multiplies by a whole number — ×2 for FSR, XeSS and DLSS 3, ×2 to ×4
/// for DLSS 4, up to ×6 for DLSS 4.5 —, and its windows read 1.98, 3.01, 6.06. A five-second window that reads
/// between two changed state inside itself: Silent Hill 2 (2026-10-20) read ×2.53 where the NVIDIA App's Dynamic
/// multiplier stepped from ×2 to ×3 — half its application frames followed by one generated frame, half by two —,
/// and three such windows formed a ×2.52 "state" nobody held.
/// </summary>
public static bool IsNearWholeMultiplier(double factor)
{
double whole = Math.Max(2, Math.Round(factor, MidpointRounding.AwayFromZero));
return Math.Abs(factor - whole) <= (whole * BucketTolerance) + 1e-9; // the edge is in: 2.2 - 2 is 0.2000000000000002
}
/// <summary><c>none</c>, reached by counting: a published factor at or below <see cref="NoneCeiling"/>.</summary>
public bool IsNone => Factor is double f && f <= NoneCeiling;
@@ -127,12 +127,18 @@ public sealed class AgentEndToEndTests : IDisposable
}
}
private Process StartHarness(string arguments)
private async Task<Process> StartHarnessAsync(string arguments)
{
StageTarget();
File.Exists(Agent).Should().BeTrue("the Agent must be built and copied beside this test");
var p = Process.Start(new ProcessStartInfo(ConsentedExecutable, arguments) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true })!;
Thread.Sleep(800);
bool presenting = await HarnessReady.WaitUntilPresentingAsync(p, TestContext.Current.CancellationToken).ConfigureAwait(false);
if (!presenting && !p.HasExited)
{
p.Kill(entireProcessTree: true);
}
presenting.Should().BeTrue("the harness must reach its present loop before anything looks for it or is injected into it (HarnessReady)");
p.HasExited.Should().BeFalse("the harness must be running before the Agent looks for it");
return p;
}
@@ -181,7 +187,7 @@ public sealed class AgentEndToEndTests : IDisposable
// THE MILESTONE'S TECHNICAL HALF, from outside the process: the shipped Agent, our harness, one row.
(await GrantConsentAsync()).Should().Be(ConsentWriteOutcome.Written);
Process harness = StartHarness("--real --hold-presenting 40");
Process harness = await StartHarnessAsync("--real --hold-presenting 40");
try
{
using Process agent = StartAgent("capture", "--exe", ConsentedExecutable, "--seconds", "8");
@@ -225,7 +231,7 @@ public sealed class AgentEndToEndTests : IDisposable
(await GrantConsentAsync()).Should().Be(ConsentWriteOutcome.Written);
await SetKillSwitchAsync(engaged: true);
Process harness = StartHarness("--real --hold-presenting 20");
Process harness = await StartHarnessAsync("--real --hold-presenting 20");
try
{
using Process agent = StartAgent("capture", "--exe", ConsentedExecutable, "--seconds", "3");
@@ -255,7 +261,7 @@ public sealed class AgentEndToEndTests : IDisposable
{
(await GrantConsentAsync()).Should().Be(ConsentWriteOutcome.Written);
Process stranger = Process.Start(new ProcessStartInfo(Harness, "--real --hold-presenting 30") { UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true })!;
Process harness = StartHarness("--real --hold-presenting 30");
Process harness = await StartHarnessAsync("--real --hold-presenting 30");
try
{
using Process agent = StartAgent("capture", "--exe", ConsentedExecutable, "--seconds", "3");
@@ -129,11 +129,17 @@ public sealed class PartialRecoveryEndToEndTests : IDisposable
File.Copy(Harness, ConsentedExecutable);
}
private Process StartHarness(string arguments)
private async Task<Process> StartHarnessAsync(string arguments)
{
StageTarget();
var p = Process.Start(new ProcessStartInfo(ConsentedExecutable, arguments) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true })!;
Thread.Sleep(800);
bool presenting = await HarnessReady.WaitUntilPresentingAsync(p, TestContext.Current.CancellationToken).ConfigureAwait(false);
if (!presenting && !p.HasExited)
{
p.Kill(entireProcessTree: true);
}
presenting.Should().BeTrue("the harness must reach its present loop before anything looks for it or is injected into it (HarnessReady)");
p.HasExited.Should().BeFalse("the harness must be running before the Agent looks for it");
return p;
}
@@ -220,7 +226,7 @@ public sealed class PartialRecoveryEndToEndTests : IDisposable
await GrantConsentAsync().ConfigureAwait(true);
// Long enough to outlive the 30 s threshold, the flush after it and the kill.
Process harness = StartHarness("--real --hold-presenting 90");
Process harness = await StartHarnessAsync("--real --hold-presenting 90").ConfigureAwait(true);
try
{
// Disposed by the using even after Kill disposes it: Process.Dispose is idempotent, and the
+22 -1
View File
@@ -107,7 +107,7 @@ public sealed class DlssTextTests
DlssText.Line(Row("{\"nvngx_dlss.dll\":\"310.9.1.0\",\"nvngx_dlssnr.dll\":\"1.0.0.0\"}", upscaler: "dlss"))
.Should().Be("DLSS · Super Resolution 310.9.1 · DLSS 5 runtime loaded");
DlssText.Line(Row("{\"sl.interposer.dll\":\"2,8,0,0\"}", upscaler: "fsr3")).Should().BeNull("no DLSS at all");
DlssText.Line(Row("{broken", upscaler: "dlss")).Should().Be("DLSS", "an unreadable module list still says DLSS ran");
DlssText.Line(Row("{broken", upscaler: "dlss")).Should().BeNull("a line that would say only DLSS says nothing the header does not (beta.27)");
DlssText.ExportLine(Row()).Should().Be("N/A");
DlssText.Parse("310,9,1,0").Should().Be(new Version(310, 9, 1, 0));
DlssText.Parse("3.7").Should().Be(new Version(3, 7));
@@ -117,6 +117,27 @@ public sealed class DlssTextTests
return 0;
});
/// <summary>
/// beta.27: Witcher 3 under the NVIDIA App's override (2026-10-20) loaded the driver's libraries under names no census
/// lists, so its DLSS line said only "DLSS" beneath a header that already did; the loaded-libraries line prints them.
/// </summary>
[Fact]
public void ALineThatWouldSayOnlyDlssIsNotShown() => InEnglish(() =>
{
SessionRow witcher = Row(
"{\"160_E658700.bin\":\"310,9,16,0\",\"1B0_E658700.dll\":\"2,14,16,0\",\"_nvngx.dll\":\"32.0.16.1742\",\"sl.interposer.dll\":\"2,14,1,0\"}",
"{\"160_E658700.bin\":\"graphics_driver\",\"1B0_E658700.dll\":\"graphics_driver\",\"_nvngx.dll\":\"graphics_driver\",\"sl.interposer.dll\":\"game\"}",
upscaler: "dlss",
words: "{\"Outcome\":\"Answered\",\"Sr\":\"0x1F\",\"Rr\":\"0x3F\",\"Fg\":\"0xA03F\",\"Driver\":61742,\"Ratio\":0,\"Mode\":0,\"Preset\":6,\"FgCount\":5,\"FgPreset\":2,\"FgMode\":1,\"Readings\":17,\"Answered\":16,\"Changed\":true,\"Detail\":null}",
fgMode: "dlssg",
factor: 2.0);
DlssText.Line(witcher).Should().BeNull();
DlssText.Line(Row("{\"160_E658700.bin\":\"310,9,16,0\"}", upscaler: "dlss", fgMode: "dlssg", factor: 3.0))
.Should().Be("DLSS 4 (a ×3.0 frame-generation state)", "a label is something to say");
return 0;
});
[Fact]
public void TheLargestStateOfTheMixIsTheEvidence() => InEnglish(() =>
{
+34 -3
View File
@@ -164,8 +164,8 @@ public sealed class GamePlayerTests
var shell = new Shell();
var agent = new Agent();
(await Player(s, shell, agent, steam).PlayAsync(game, Ct)).Should().Be(new PlayResult(PlayOutcome.StartedByAgent));
shell.Opened.Should().BeEmpty("direct never asks the store, even for a store's game");
(await Player(s, shell, agent, steam).PlayAsync(game, Ct)).Should().Be(new PlayResult(PlayOutcome.StartedByAgent, SteamGame: true));
shell.Opened.Should().BeEmpty("direct never asks the store's app to start it, even for a store's game");
(await Player(s, new Shell(), new Agent(connected: false), steam).PlayAsync(game, Ct)).Outcome.Should().Be(PlayOutcome.AgentUnavailable);
(await Player(s, new Shell(), new Agent(outcome: "RecordingOff"), steam).PlayAsync(game, Ct)).Outcome.Should().Be(PlayOutcome.RecordingOff);
@@ -213,7 +213,7 @@ public sealed class GamePlayerTests
// A Steam record whose id is not a Steam id builds no link — and is not "GOG GALAXY is not installed".
var odd = new Stores(new StoreGame("steam", "not-an-app-id", "W", _steam, null, null));
PlayResult noLink = await Player(s, new Shell(), new Agent(), odd).PlayAsync(Game(_steam + @"\game.exe", null), Ct);
noLink.Should().Be(new PlayResult(PlayOutcome.StartedByAgent, Fallback: PlayFallback.NoLink));
noLink.Should().Be(new PlayResult(PlayOutcome.StartedByAgent, Fallback: PlayFallback.NoLink, SteamGame: true));
GamePlayer.Describe(noLink, "W").Text.Should().NotContain("GOG").And.NotContain("store");
// The store mode fell back and recording is off: switching Play to the store is no advice.
@@ -230,6 +230,37 @@ public sealed class GamePlayerTests
GamePlayer.Describe(new PlayResult(PlayOutcome.AgentUnavailable, Fallback: PlayFallback.NoStore), "W").Text.Should().NotContain("its store");
}
/// <summary>
/// beta.27: a game Steam installed may hand itself to Steam when the agent starts it (Lies of P, 2026-10-19: its process
/// left within seconds and Steam started the game again), and the notice says so — started directly, or by an App
/// running as administrator. Any other game's notice is unchanged.
/// </summary>
[Fact]
public async Task ASteamGameTheAgentStartsSaysItMayHandItselfToSteam()
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
var steam = new Stores(new StoreGame("steam", "1627720", "Lies of P", _steam, null, null));
GameRow game = Game(_steam + @"\game.exe", "1627720");
PlayResult elevated = await Player(s, new Shell(), new Agent(), steam, elevated: true).PlayAsync(game, Ct);
elevated.Should().Be(new PlayResult(PlayOutcome.StartedByAgent, Fallback: PlayFallback.Elevated, SteamGame: true));
GamePlayer.Describe(elevated, "Lies of P").Text.Should().Contain("administrator").And.Contain("hand itself to Steam");
await new RegisteredSettings(new SqliteSettingsStore(s.Db)).SetAsync(SettingsRegistry.UiPlayMode, PlayMode.Direct, Ct);
PlayResult direct = await Player(s, new Shell(), new Agent(), steam).PlayAsync(game, Ct);
direct.SteamGame.Should().BeTrue();
GamePlayer.Describe(direct, "Lies of P").Should().Be(
("FrameLedger is starting Lies of P. A Steam game may hand itself to Steam first; the game Steam then starts is recorded.", false));
PlayResult loose = await Player(s, new Shell(), new Agent(), steam).PlayAsync(Game(@"D:\Games\Loose\game.exe", null), Ct);
loose.SteamGame.Should().BeFalse("no store's records name its folder");
GamePlayer.Describe(loose, "W").Text.Should().Be("FrameLedger is starting W.");
var gog = new Stores(new StoreGame("gog", "1125815775", "A Space for the Unbound", @"D:\another\gog\A Space", null, null));
(await Player(s, new Shell(), new Agent(), gog).PlayAsync(Game(@"D:\another\gog\A Space\game.exe", "1125815775"), Ct))
.SteamGame.Should().BeFalse("only Steam's games hand themselves to their store");
}
[Fact]
public async Task AStoreAppWindowsWillNotOpenIsAFailureNamedAsSuch()
{
@@ -667,4 +667,50 @@ public sealed partial class PagesLoadTests
drawn.Should().BeGreaterThan(0).And.BeLessThanOrEqualTo(Decimator.DefaultBuckets * 2 + 2100, "FR-5.3: decimated per draw (the series, the markers, the sensors)");
series.Stutter!.Count(static f => f).Should().Be(7);
}
/// <summary>
/// beta.27: the owner opened one session twice from the dashboard and had two summary windows of it side by side
/// (2026-10-20). A session has one summary window — opening it again brings that one forward —, another session gets
/// its own, and a closed window lets the next open build a new one.
/// </summary>
[Fact]
public async Task OpeningAnOpenSessionAgainBringsItsOneWindowForward()
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow game = await s.GameAsync("Silent Hill 2");
long first = await s.SessionWithFramesAsync(game.Id, DateTimeOffset.UtcNow.AddMinutes(-10), frames: 120, spikeEvery: 60);
long second = await s.SessionWithFramesAsync(game.Id, DateTimeOffset.UtcNow, frames: 120, spikeEvery: 60);
await using ServiceProvider services = new ServiceCollection()
.AddSingleton<ISessionRepository>(s.Sessions)
.AddSingleton<IGameRepository>(s.Games)
.AddSingleton<ISessionAnnotationRepository>(s.Annotations)
.AddSingleton<IHardwareSnapshotRepository>(new SqliteHardwareSnapshotRepository(s.Db))
.AddSingleton(new SessionSeriesLoader(s.Sessions))
.AddSingleton<IFileSaver>(new NoSaver())
.AddSingleton<IMessageStrip>(new NoStrip())
.AddSingleton<IThemeApplier>(new NoTheme())
.AddSingleton(new AppearanceSettings(new MemorySettings()))
.BuildServiceProvider();
(IReadOnlyList<long> Twice, int Windows, IReadOnlyList<long> AfterClose) seen = await OnStaAsync(() =>
{
var shell = new ShellHost(new ServiceCollection().BuildServiceProvider(), null!, null!, new WindowClosePolicy());
var opener = new SessionSummaryOpener(services, shell, new SessionSelection());
opener.Open(first);
opener.Open(first);
opener.Open(second);
opener.Open(first);
IReadOnlyList<long> twice = opener.OpenSessions;
List<Windows.SessionSummaryWindow> shown = [.. System.Windows.Application.Current.Windows.OfType<Windows.SessionSummaryWindow>()];
shown.ForEach(static w => w.Close());
opener.Open(first);
IReadOnlyList<long> afterClose = opener.OpenSessions;
System.Windows.Application.Current.Windows.OfType<Windows.SessionSummaryWindow>().ToList().ForEach(static w => w.Close());
return (twice, shown.Count, afterClose);
});
seen.Twice.Should().Equal([first, second], "a session's second open brings its window forward instead of a copy");
seen.Windows.Should().Be(2);
seen.AfterClose.Should().Equal([first], "a closed window is forgotten, and the next open builds a new one");
}
}
@@ -672,6 +672,49 @@ public sealed class CaptureSessionTests : IAsyncDisposable
}
}
/// <summary>
/// beta.27: the driver still answers for a pid whose game has gone, with the bits that say a feature ran cleared. Read
/// before the last drain, that answer replaced every reading taken while the game ran, and no session the owner stored
/// from 2026-10-04 to 2026-10-20 kept CREATED | EVALUATE. The driver is not asked after the game left, and a reading
/// that clears the two bits — a game releasing its features on its way out — does not unsay them.
/// </summary>
[Fact]
public async Task TheDriverIsNotAskedAfterTheGameLeftAndAFeatureThatRanStaysRun()
{
var guard = new CountingGuard();
using var sink = new FakeSink();
using var liveness = new FakeLiveness { ExitAfterChecks = 30 };
int probes = 0;
var loop = new CaptureSession(
await StoreWithAsync(), new HookedCaptureGate(guard), guard, new FixedResolver(_pid, SessionEndReason.Running),
new DelegateLivenessSource(_ => liveness),
new DelegateRingAttacher(_ => (sink, ShmAttachRefusal.Ok)),
new CaptureOptions
{
DrainInterval = TimeSpan.FromMilliseconds(1),
ScanInterval = TimeSpan.FromMilliseconds(1),
AttachBudget = TimeSpan.FromMilliseconds(50),
MaxDuration = TimeSpan.FromSeconds(30),
HoldInterval = TimeSpan.FromMilliseconds(1),
LogFlushGrace = TimeSpan.FromMilliseconds(1),
},
modules: null,
ngx: new DelegateNgxProbe(_ =>
{
// Created and evaluated at the second reading only: before it, not yet; after it, released on the way out.
ulong sr = ++probes == 2 ? NgxOverrideFlags.Initialized | NgxOverrideFlags.DllExists | NgxOverrideFlags.CreatedAndEvaluated
: NgxOverrideFlags.Initialized | NgxOverrideFlags.DllExists;
return NgxDriverState.Parse($"NGXSTATE status=ANSWERED sr=0x{sr:X16} rr=0x1 fg=0x5 ratio=0.0000 mode=0 preset=0 fgcount=0 fgpreset=0 fgmode=0 driver=61742");
}));
CaptureOutcome r = await loop.RunAsync(_exe, Fingerprint, "payload.dll", TestContext.Current.CancellationToken);
r.Reason.Should().Be(SessionEndReason.TargetExited);
probes.Should().BeGreaterThan(2, "readings after the one that saw the feature ran, as on the owner's sessions");
probes.Should().Be(sink.Published.Count, "one per scan, and none once the game had left");
r.NgxDriver.SrCreatedAndEvaluated.Should().BeTrue("a feature that ran in the session stays run");
}
[Fact]
public async Task NoRecordRefusesConsentAndNothingIsEverInjected()
{
@@ -52,10 +52,11 @@ public sealed class FgMixRecordTests
}
[Theory]
[InlineData(2.524, 30.0)]
[InlineData(8.01, 30.0)]
[InlineData(4.0, 1.5)]
[InlineData(null, 30.0)]
public void AGeneratedRowAboveTheCeilingOrWithTooFewFramesIsFoldedEvenWithNoUnclassifiedRow(double? factor, double nativeFps)
public void AGeneratedRowNoWindowWouldFormIsFoldedEvenWithNoUnclassifiedRow(double? factor, double nativeFps)
{
string json = "{\"Rows\":[" +
"{\"Kind\":\"generated\",\"Factor\":2.0,\"NativeFps\":60,\"DisplayedFps\":120,\"Seconds\":40,\"Share\":0.8,\"Windows\":8}," +
@@ -525,6 +525,64 @@ public sealed class CaptureOrchestratorTests
recorder.Requests.Should().ContainSingle();
}
/// <summary>
/// beta.27: Lies of P, started directly (2026-10-19), handed itself to Steam within seconds, and Steam started the game
/// again while the launch's session was ending. The watcher turned that process away ("one at a time") and, a launch
/// never saying it had ended on its own, it went unrecorded — twice. It is recorded when the launch ends, as after a
/// watched session.
/// </summary>
[Fact]
public async Task AGameSteamStartsAgainAfterADirectStartIsRecordedWhenTheLaunchEnds()
{
var launchRecorder = new FakeRecorder();
using var launches = new FakeLaunches(launchRecorder);
(CaptureOrchestrator o, FakeRecorder attach, FakeSnapshots processes, List<string> log, _, long id) = await BuildWithLibraryAsync(launches).ConfigureAwait(true);
CancellationToken ct = TestContext.Current.CancellationToken;
(await o.LaunchAsync(id, "", ct).ConfigureAwait(true)).Outcome.Should().Be(LaunchOutcome.Accepted);
await WaitForRequestsAsync(launchRecorder, 1).ConfigureAwait(true);
// The process the launch started, then the one Steam starts once that one has left.
processes.Processes.Add(new ProcessSnapshot(100, 1, "game.exe", _game, DateTimeOffset.UnixEpoch));
await o.PollOnceAsync(ct).ConfigureAwait(true);
processes.Processes.Clear();
processes.Processes.Add(new ProcessSnapshot(200, 7, "game.exe", _game, DateTimeOffset.UnixEpoch.AddSeconds(6)));
await o.PollOnceAsync(ct).ConfigureAwait(true);
attach.Requests.Should().BeEmpty("one session per executable at a time");
launchRecorder.Pending[0].SetResult(GameExited(targetPid: 100));
await WaitUntilAsync(() => o.RunningSessions == 0).ConfigureAwait(true);
await o.PollOnceAsync(ct).ConfigureAwait(true);
await WaitForRequestsAsync(attach, 1).ConfigureAwait(true);
attach.Requests.Should().ContainSingle("the game Steam started is recorded once the launch has ended").Which.Mode.Should().Be(CaptureMode.Attach);
log.Should().Contain(l => l.Contains("pid 200", StringComparison.Ordinal) && l.Contains("recording it now", StringComparison.Ordinal));
}
/// <summary>
/// beta.27: the process a launch started appears to the watcher after the launch began and is turned away like any other;
/// a launch the user stopped does not start again on the game it stopped recording.
/// </summary>
[Fact]
public async Task ALaunchTheUserStoppedDoesNotStartAgainOnItsOwnProcess()
{
var launchRecorder = new FakeRecorder();
using var launches = new FakeLaunches(launchRecorder);
(CaptureOrchestrator o, FakeRecorder attach, FakeSnapshots processes, _, _, long id) = await BuildWithLibraryAsync(launches).ConfigureAwait(true);
CancellationToken ct = TestContext.Current.CancellationToken;
LaunchResult launched = await o.LaunchAsync(id, "", ct).ConfigureAwait(true);
await WaitForRequestsAsync(launchRecorder, 1).ConfigureAwait(true);
processes.Processes.Add(new ProcessSnapshot(100, 1, "game.exe", _game, DateTimeOffset.UnixEpoch));
await o.PollOnceAsync(ct).ConfigureAwait(true);
o.StopSession(launched.SessionGuid!.Value).Should().BeTrue();
launchRecorder.Pending[0].SetResult(GameExited(targetPid: 100) with { Outcome = new CaptureOutcome { Reason = SessionEndReason.StoppedByUser, TargetPid = 100 } });
await WaitUntilAsync(() => o.RunningSessions == 0).ConfigureAwait(true);
await o.PollOnceAsync(ct).ConfigureAwait(true);
await o.PollOnceAsync(ct).ConfigureAwait(true);
attach.Requests.Should().BeEmpty("the game still running is the one the stopped launch recorded");
}
private static RecordedSession LauncherExited(int launcherPid) => new()
{
SessionGuid = Guid.NewGuid(),
@@ -170,7 +170,7 @@ public sealed class CaptureHostEndToEndTests : IDisposable
File.Copy(Harness, ConsentedExecutable);
}
private Process StartHarness(string arguments)
private async Task<Process> StartHarnessAsync(string arguments)
{
StageTarget();
File.Exists(Host).Should().BeTrue("the host must be built and copied beside this test");
@@ -182,7 +182,13 @@ public sealed class CaptureHostEndToEndTests : IDisposable
RedirectStandardOutput = true,
})!;
Thread.Sleep(800);
bool presenting = await HarnessReady.WaitUntilPresentingAsync(p, TestContext.Current.CancellationToken).ConfigureAwait(false);
if (!presenting && !p.HasExited)
{
p.Kill(entireProcessTree: true);
}
presenting.Should().BeTrue("the harness must reach its present loop before anything looks for it or is injected into it (HarnessReady)");
p.HasExited.Should().BeFalse("the harness must be running before the host looks for it");
return p;
}
@@ -255,7 +261,7 @@ public sealed class CaptureHostEndToEndTests : IDisposable
"this case is about an ABSENT record; a leftover one from a sibling test would make the "
+ "host refuse for a different reason and the assertions below would say nothing");
Process harness = StartHarness("--real --hold-presenting 20");
Process harness = await StartHarnessAsync("--real --hold-presenting 20");
try
{
using Process host = StartHost("capture", "--exe", ConsentedExecutable);
@@ -290,7 +296,7 @@ public sealed class CaptureHostEndToEndTests : IDisposable
// self-constraint above pins WHICH executable it may stand in for.
(await GrantConsentAsync()).Should().Be(ConsentWriteOutcome.Written);
Process harness = StartHarness("--real --hold-presenting 40");
Process harness = await StartHarnessAsync("--real --hold-presenting 40");
Process? host = null;
try
{
@@ -404,7 +410,7 @@ public sealed class CaptureHostEndToEndTests : IDisposable
Directory.CreateDirectory(PartialDirectory);
HashSet<string> before = [.. Directory.EnumerateFiles(PartialDirectory, "*.partial")];
Process harness = StartHarness("--real --hold-presenting 40");
Process harness = await StartHarnessAsync("--real --hold-presenting 40");
Process? host = null;
string? file = null;
try
@@ -528,7 +534,7 @@ public sealed class CaptureHostEndToEndTests : IDisposable
// longer than the hold found the harness gone and ended TargetNotRunning — #286's first CI run, as on 2026-09-21
// and before. The host prints nothing until its session ends, so there is no "attached" to wait for; the hold is
// the margin, and the case's run time with it.
Process harness = StartHarness("--real --hold-presenting 15");
Process harness = await StartHarnessAsync("--real --hold-presenting 15");
Process? host = null;
try
{
@@ -87,4 +87,27 @@ public sealed class NgxDriverStateTests
same.Changed.Should().BeFalse();
same.Describe().Should().Contain("answered 2 of 2 probe(s); driver 616.64");
}
/// <summary>
/// beta.27: Expedition 33 read <c>0x8067F</c> while it ran (2026-09-06) and every stored session of it <c>0x8007F</c> — the
/// same word without CREATED | EVALUATE, read after the game had released its features. The two bits stand once read;
/// every other bit is still the last reading's.
/// </summary>
[Fact]
public void AFeatureThatRanStaysRunWhenALaterReadingClearsIt()
{
NgxDriverState released = NgxDriverState.Parse(
"NGXSTATE status=ANSWERED sr=0x000000000008007F rr=0x0000000000080005 fg=0x000000000000001F ratio=0.0000 mode=1 preset=12 fgcount=0 fgpreset=0 fgmode=0 driver=61742");
NgxDriverState merged = NgxDriverState.NotRun.Merge(NgxDriverState.Parse(_expedition33Override)).Merge(released);
merged.Sr.Should().Be(0x8067FUL);
merged.SrCreatedAndEvaluated.Should().BeTrue("the feature ran in this session");
merged.PerformanceMode.Should().Be(1u, "every other field is the last reading's");
merged.RenderPreset.Should().Be(12u);
merged.Changed.Should().BeTrue();
NgxDriverState never = NgxDriverState.NotRun.Merge(released).Merge(released);
never.SrCreatedAndEvaluated.Should().BeFalse("no reading said the feature ran");
}
}
@@ -107,6 +107,40 @@ public sealed class DisplayModeTests
s.ExclusivityKnown.Should().BeTrue();
}
/// <summary>
/// beta.27: a game leaving exclusive fullscreen destroys its window while its swap chain's last word is still fresh,
/// so its last samples are exclusive with no window; five Lies of P and Dark Souls III sessions stored no sizes.
/// </summary>
[Fact]
public void TheSizesAreTheLastOnesTheModeSaw()
{
var tally = new DisplayTally();
tally.Add(DisplayModeClassifier.Classify(Chain(exclusive: true), Window(_monitor)), 60_000);
tally.Add(DisplayModeClassifier.Classify(Chain(exclusive: true), null), 100); // the window is gone
tally.Add(DisplayModeClassifier.Classify(Chain(exclusive: true, fresh: false), null), 1_500);
DisplaySummary s = tally.Summary();
s.Dominant.Should().Be(DisplayMode.ExclusiveFullscreen);
s.WindowWidth.Should().Be(2560, "the exclusive samples saw the window before it was destroyed");
s.WindowHeight.Should().Be(1440);
s.MonitorWidth.Should().Be(2560);
s.MonitorHz.Should().Be(144);
s.BufferWidth.Should().Be(2560u);
}
[Fact]
public void AModeThatNeverSawItsWindowStoresTheChainsSizesAlone()
{
var tally = new DisplayTally();
tally.Add(DisplayModeClassifier.Classify(Chain(exclusive: true), null), 5_000);
DisplaySummary s = tally.Summary();
s.Dominant.Should().Be(DisplayMode.ExclusiveFullscreen);
s.WindowWidth.Should().BeNull("no sample of the mode saw a window");
s.MonitorHz.Should().BeNull();
s.BufferWidth.Should().Be(2560u, "the swap chain said its own size");
}
[Fact]
public void ASessionWhoseExclusivityWasUnknownForAMomentSaysSo()
{
@@ -158,6 +158,42 @@ public sealed class FgMixTests
AddsUpToTheWhole(mix);
}
/// <summary>
/// beta.27: Silent Hill 2 (2026-10-20) under the NVIDIA App's Dynamic multi frame generation held ×2 and ×3, and the
/// windows where the multiplier stepped read ×2.21–×2.70; three of them formed a ×2.52 "state" nobody held. A window
/// between two whole multipliers changed state inside itself, and is not classified.
/// </summary>
[Fact]
public void WindowsBetweenTwoMultipliersAreNotAState()
{
// Thirty seconds stepping between ×2 and ×3 every second: every five-second window reads 2.3–2.5.
List<FrameSample> stepping = Play(1, 2);
for (int s = 1; s < 30; s++)
{
stepping = SampleFixtures.Concat(stepping, Play(1, s % 2 == 0 ? 2 : 3));
}
FgMix mix = FgMix.From(Concat(Play(20, 2), stepping, Play(20, 3)), Frequency, noneAllowed: true)!;
mix.Rows.Select(static r => r.Kind).Should().Equal(FgMixKind.Generated, FgMixKind.Generated, FgMixKind.Unclassified);
mix.Rows.Where(static r => r.Kind == FgMixKind.Generated).Select(static r => Math.Round(r.Factor!.Value)).Should().Equal(2, 3);
mix.Rows[2].Seconds.Should().BeApproximately(30, 2);
mix.Rows.Should().OnlyContain(static r => r.Factor == null || FgWindow.IsNearWholeMultiplier(r.Factor.Value));
AddsUpToTheWhole(mix);
}
[Theory]
[InlineData(1.79, false)]
[InlineData(1.8, true)]
[InlineData(2.2, true)]
[InlineData(2.21, false)]
[InlineData(2.52, false)]
[InlineData(2.7, true)]
[InlineData(6.06, true)]
[InlineData(8.0, true)]
public void AWholeMultiplierIsWithinTenPercent(double factor, bool near) =>
FgWindow.IsNearWholeMultiplier(factor).Should().Be(near);
[Fact]
public void ARatioAtTheCeilingIsStillAState()
{
@@ -10,6 +10,7 @@ using FrameLedger.Infrastructure.AntiCheat;
using FrameLedger.Infrastructure.Ipc;
using FrameLedger.Infrastructure.Rules;
using FrameLedger.Shared;
using FrameLedger.Testing;
namespace FrameLedger.Infrastructure.Tests;
@@ -110,7 +111,7 @@ public sealed class ShmDrainIntegrationTests
outcome.Should().NotBe(RulesSeedOutcome.PackagedSeedUnusable);
}
private static Process StartHarness(string arguments)
private static async Task<Process> StartHarnessAsync(string arguments)
{
File.Exists(Harness).Should().BeTrue(
"hook-harness.exe must be staged beside the test binary (FrameLedger.DrainFixtures.targets). "
@@ -126,11 +127,42 @@ public sealed class ShmDrainIntegrationTests
RedirectStandardOutput = true,
})!;
Thread.Sleep(800); // let it create its device and start presenting
bool presenting = await HarnessReady.WaitUntilPresentingAsync(process, TestContext.Current.CancellationToken).ConfigureAwait(false);
if (!presenting && !process.HasExited)
{
process.Kill(entireProcessTree: true);
}
presenting.Should().BeTrue("the harness must reach its present loop before anything looks for it or is injected into it (HarnessReady)");
process.HasExited.Should().BeFalse("the harness must still be running when we inject");
return process;
}
/// <summary>
/// The real guard over the harness, which carries no anti-cheat (beta.27): a refusal names its reason, and one that says
/// the guard could not read the scan set whole is asked again — four more times at most, 250 ms apart.
/// </summary>
/// <remarks>
/// The scan set is the harness and its ancestors up to a platform launcher — here this test host, <c>dotnet test</c> and
/// the shell above them. Under a full gate the test host is still starting its other test classes, loading and releasing
/// modules while the guard reads its list, and a module released between the list and its name refuses as
/// <c>ModuleScanFailed</c>: measured 2026-10-20, once in the gate and once in twelve runs of this assembly with coverage,
/// never in a run of this class alone. <c>ProcessUnreadable</c> (twice on 2026-10-19) is the same race met at the list
/// itself. Both are the guard working, about this machine's tooling rather than the harness — D48's one re-read covers
/// a process still starting, not a list in motion. Every other refusal fails at once, and so does one that lasts.
/// </remarks>
private static async Task InjectAsync(NativeAntiCheatGuard guard, Process harness)
{
AntiCheatVerdict verdict = await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken).ConfigureAwait(false);
for (int again = 0; again < 4 && verdict.Reason is (AntiCheatRefusalReason.ModuleScanFailed or AntiCheatRefusalReason.ProcessUnreadable); again++)
{
await Task.Delay(250, TestContext.Current.CancellationToken).ConfigureAwait(false);
verdict = await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken).ConfigureAwait(false);
}
verdict.IsAllowed.Should().BeTrue($"the guard refused our own harness: {verdict.Reason} {verdict.Family} {verdict.Signal}");
}
private static void Kill(Process p)
{
try
@@ -316,16 +348,15 @@ public sealed class ShmDrainIntegrationTests
{
await SeedRulesAsync();
Process harness = StartHarness("--real --hold-presenting 12");
Process harness = await StartHarnessAsync("--real --hold-presenting 12");
try
{
var guard = new NativeAntiCheatGuard();
// The REAL guard with REAL sources — no test seam. The harness carries no anti-cheat, so a
// refusal here is a genuine finding about this machine, not a fixture problem.
AntiCheatVerdict verdict = await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken);
verdict.IsAllowed.Should().BeTrue(
$"the guard refused our own harness: {verdict.Reason} {verdict.Family} {verdict.Signal}");
// refusal here is a genuine finding about this machine, not a fixture problem — save the one
// InjectAsync asks again about: this test host's own module list, read while it changes.
await InjectAsync(guard, harness);
string ownBuildId = NativeAntiCheatGuard.BuildId();
using (ShmRingReader reader = await AttachAsync(harness.Id, ownBuildId))
@@ -524,12 +555,11 @@ public sealed class ShmDrainIntegrationTests
{
await SeedRulesAsync();
Process harness = StartHarness("--real --hold-presenting 25");
Process harness = await StartHarnessAsync("--real --hold-presenting 25");
try
{
var guard = new NativeAntiCheatGuard();
(await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken))
.IsAllowed.Should().BeTrue();
await InjectAsync(guard, harness);
using ShmRingReader reader = await AttachAsync(harness.Id, NativeAntiCheatGuard.BuildId());
@@ -537,6 +567,9 @@ public sealed class ShmDrainIntegrationTests
var tick = new Ref<uint>();
await EstablishRecordingAsync(reader, buffer, tick);
// The writer's init thread reaches its READY store after the present hook already records (WaitUntilInitFinishedAsync's
// remarks): under load the status below read INIT once (2026-10-19), which says nothing about pausing.
await WaitUntilInitFinishedAsync(reader);
reader.SetPaused(true);
ulong atPause = await SettleAsync(reader, buffer, tick);
await Task.Delay(1200, TestContext.Current.CancellationToken);
@@ -616,12 +649,11 @@ public sealed class ShmDrainIntegrationTests
{
await SeedRulesAsync();
Process harness = StartHarness("--real --hold-presenting 20 --present-interval-ms 0");
Process harness = await StartHarnessAsync("--real --hold-presenting 20 --present-interval-ms 0");
try
{
var guard = new NativeAntiCheatGuard();
(await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken))
.IsAllowed.Should().BeTrue();
await InjectAsync(guard, harness);
using ShmRingReader reader = await AttachAsync(harness.Id, NativeAntiCheatGuard.BuildId());
@@ -679,11 +711,11 @@ public sealed class ShmDrainIntegrationTests
// in the capture layer.
await SeedRulesAsync();
Process harness = StartHarness("--real --hold-presenting 15");
Process harness = await StartHarnessAsync("--real --hold-presenting 15");
try
{
var guard = new NativeAntiCheatGuard();
(await guard.GuardedInjectAsync(harness.Id, Payload, toleratedFamily: null, TestContext.Current.CancellationToken)).IsAllowed.Should().BeTrue();
await InjectAsync(guard, harness);
string ownBuildId = NativeAntiCheatGuard.BuildId();
using (ShmRingReader reader = await AttachAsync(harness.Id, ownBuildId))
+53
View File
@@ -0,0 +1,53 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Diagnostics;
namespace FrameLedger.Testing;
/// <summary>
/// When a hook-harness started for an injection test is really up: the line it prints, flushed, right before its present
/// loop — after its device and swap chain exist, so its module list is whole and it is presenting.
/// </summary>
/// <remarks>
/// The injection tests slept 800 ms after starting the harness and then looked for it or injected into it: a guess at
/// when it presents, made under a full <c>build.ps1 check</c> — every test assembly at once, each starting WARP devices —
/// where a guess can be short. Waiting for the harness's own signal replaces the guess with the event it stood for
/// (beta.27). Reading its standard output asynchronously also keeps that pipe drained for the rest of its life, so a
/// harness that prints more never blocks on a full pipe. The guard's refusals of 2026-10-19 and 20 were not this:
/// <c>ShmDrainIntegrationTests.InjectAsync</c> says what they were.
/// </remarks>
internal static class HarnessReady
{
/// <summary>What hook-harness prints, then flushes, right before it presents (<c>main.cpp</c>, <c>--hold-presenting</c>).</summary>
public const string PresentingMarker = "presenting for";
/// <summary>How long a harness may take to reach its present loop; bounded, so one that never does fails its test.</summary>
public static readonly TimeSpan Timeout = TimeSpan.FromSeconds(30);
/// <summary>Whether <paramref name="harness"/> printed <see cref="PresentingMarker"/> within <see cref="Timeout"/>.</summary>
/// <param name="harness">A hook-harness started with its standard output redirected, which nobody else reads.</param>
/// <param name="ct">The test's cancellation.</param>
public static async Task<bool> WaitUntilPresentingAsync(Process harness, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(harness);
var presenting = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
harness.OutputDataReceived += (_, e) =>
{
if (e.Data is { } line && line.Contains(PresentingMarker, StringComparison.Ordinal))
{
presenting.TrySetResult();
}
};
harness.BeginOutputReadLine();
try
{
await presenting.Task.WaitAsync(Timeout, ct).ConfigureAwait(false);
return true;
}
catch (TimeoutException)
{
return false;
}
}
}