Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 4d5f704c76 docs(handoff): two more traps of the beta.14 train - the 31-character build id ten commits after a tag, and the hosted runner that was never acquired (beta.14 PR-9)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:58:56 +07:00
poli0981andClaude Opus 5.5 9411aa0f6f release: 0.1.0-beta.14 - the CHANGELOG section with how to update from beta.13, the accuracy block's release line, README's release lines, LIMITATIONS' version, HANDOFF's train section with D47-D50 and owner-only item 11 (beta.14 PR-9)
VERSION stays 0.1.0: the tag's numeric core. The tag waits for the owner's confirmation, and PR-5 / PR-7 for the owner's
approval of the Privacy Policy 2.7 wording.

"Updating from 0.1.0-beta.13" says the three things a beta.13 user must do differently: choose Beta first (beta.13's
default stable channel finds no pre-release), update with no game running (beta.13 still auto-applies at start), and that
schema 0019 cannot be opened by an earlier version.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:58:56 +07:00
poli0981andClaude Opus 5.5 4130b7cbe4 feat(app): the new measurements as summary cards, a render scale chart, a clocks and fan chart, trend metrics and compare rows labelled (presented) (beta.14 PR-8, D49) (#271)
The App's half of D49 (PR-7 recorded the values). Every value is read from the stored row, never recomputed, and reads
N/A on a session recorded before beta.14.

Summary (SessionSummaryViewModel, the cards in AddFrameCards / AddPacingCards / AddMachineCards):
- Time below 60 FPS, with below 30 and "display under {refresh} Hz" beneath - the refresh share named for the display, as
  it is over the presents the display received - and Frame to frame; both carry (presented) where the lows do.
- VSync (share of frames, tearing allowed beneath), Ray tracing (share of frames, rays per pixel; only where measured),
  Game in focus (foreground over drain ticks), Capture quality (gaps, lost records, faults).
- The 1% Low card carries "displayed: N" where frames were generated - rule 6, beside the game's own, never instead.
- GPU clocks (core, memory; fan and memory temperature beneath), GPU held back (power, heat; NVIDIA only), Frames per watt.

Charts:
- RenderScaleChart over RenderScaleSeries: 100 x sqrt(render / output pixels) as steps, from the render_res blob where the
  resolution varied, a flat line at the row's extent where it did not, a sentence where never measured.
- SensorsChart: the memory temperature on the temperatures plot, in a new palette colour (Chart_SensorTertiary: no
  existing colour was 60 apart from all six beside it - ChartMathTests caught Chart_Histogram == Chart_Native), and a
  Clocks and fan plot - core and memory MHz, fan RPM on the right, the ticks a limit held the card back shaded
  (LimitRuns); collapsed when the session stored none of them.

Trend: nine metrics (time below 60 / refresh, frame to frame, render scale = 100 / upscale_ratio, VSync share, frames per
watt from hooked sessions; core clock, memory temperature, power-limit share from every session), with ms, MHz and FPS/W
axes. Compare: nine rows; the median, lows, stutter, time below 60 and frame to frame carry (presented) in the cell of a
present-only session, the best decided on the number, never the label. The Latency tab is shown only for a game with a
session that measured latency (nothing measures Reflex today). Formats.Share, Milliseconds, FramesPerJoule.

Tests: SessionSummaryViewModelTests (every new card with values, a pre-beta.14 row at N/A, the displayed low),
RenderScaleAndClocksTests (scale arithmetic, steps, flat line, limit runs, both charts drawn on the STA thread),
TrendSeriesBuilderTests, CompareViewModelTests (labels and bests), FormatsTests, GameDetailViewModelTests (Latency tab),
ChartMathTests (the clocks plot's colours too).

Docs: 08_UI (summary, trend, compare, latency), 03_METRICS (render scale over time), legal/ACCURACY.md (one bullet, mirrored
into README and DISCLAIMER by accuracy-check; Disclaimer version unchanged as in beta.13), guide/03-read-your-results,
LIMITATIONS, CHANGELOG. Strings en/vi, ja marked for review.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:58:54 +07:00
poli0981andClaude Opus 5.5 5db18c9da9 feat(metrics): time below 30/60/refresh, frame to frame, VSync/tearing, the card's clocks and limits, frames per watt - recorded, schema 0019 (beta.14 PR-7, D49) (#270)
Owner request 2026-10-05 ("propose metrics and charts"); D49: all four groups. This is the Agent's half; the App's
charts, cards, trend and compare come in PR-8. Every value is null where nothing measured it.

Pacing (Domain.Metrics.FramePacing): the share of the measured time below 30 FPS, below 60 FPS and below the monitor's
refresh rate, and the mean |ft[k] - ft[k-1]| over neighbouring intervals (FrameTimeSeries.FollowsBreak: a pair across a
gap or pause is not a pair). A frame counts as below X when it is itself 10 % longer than 1000/X, or when the median of
the nine around it (RollingMedian, the stutter rule's window and edges) is 2 % longer. Measured on a copy of the owner's
ledger: GIRLS' FRONTLINE 2 capped at 60 (296,380 frames, median 16.63 ms) read 50.0 % "below 60" by the plain rule and
9.6 % by this one (4.7 % of it below 30); a rolling mean does not help. Synthetic: steady 58 -> 93 %, 60.2 -> 0.7 %, a
100 ms hitch counts its own time and no neighbour's; a steady 59 reads 40 % (the stated cost). 30/60/frame-to-frame are
over the statistics' series (application frames when generated frames were counted - rule 6); the refresh share is over
the presents, at display_monitor_hz.

Sync (PresentArgsShares): the share of presents with a sync interval >= 1 and with DXGI_PRESENT_ALLOW_TEARING - both in
every Direct3D record since P1 and read by nothing; sync_interval_mode (0001) gets its first writer (on/off/mixed). OpenGL
and Vulkan carry no arguments: null.

The card (both tiers): core/memory clock, fan, memory temperature - in the samples before, stored nowhere - as series and
averages; power and thermal limit from NVAPI's perf-decrease reasons (GpuLimitReasons: 0x2, 0x1; 100 or 0 per tick, so
the mean is the share), NVIDIA only, null elsewhere.

Efficiency (EnergyEfficiency, SessionAggregator.ApplyEfficiency): application FPS / average GPU board power. Never the
displayed rate; the native rate when frame generation was counted over the session, the presented rate only under
no_fg_runtime; null for census_not_run, fg_runtime_loaded, none_withheld, a steady-state session, no power, Tier 2.

Schema 0019: thirteen REAL columns, ADD COLUMN only; SessionRow, SessionRowColumns (Parameters6/Read6). The sensor
statistics table shows the six new series in their own units (Formats.Frequency, Formats.Rpm; strings en/vi/ja review),
because it lists every catalogued series and printed anything unknown as memory.

Tests: FramePacingTests, PresentArgsSharesTests (+ efficiency), FrameTimeSeries FollowsBreak, PacingSyncAndEfficiency-
AggregationTests (series, sync, efficiency per qualifier, both tiers, the catalogue's names, the limit bits), the
migration (LedgerDatabaseTests.ScriptNineteen...), the column-for-column round trip, the table's units.

Docs: 03_METRICS (Pacing, Sync, the card, Efficiency, accuracy rows), 06_DATA_MODEL (schema, sensor_blobs, 0019),
LIMITATIONS, Privacy Policy 2.7 section 1 (the card's sensor series), legal-drift-history (what 2.7 changed), CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:44:00 +07:00
poli0981andClaude Opus 5.5 d565760830 feat(build): every managed binary names FrameLedger and carries the native copyright line; versioninfo-check reads both kinds (beta.14 PR-6, D50) (#269)
Owner request 2026-10-05 ("Thêm Assembly metadata"); D50: company and product "FrameLedger", the copyright the
native FL_COPYRIGHT word for word.

Measured before the change, from the built binaries: FrameLedger.Agent.exe/.dll read Company and Product
"FrameLedger.Agent" and FileDescription "FrameLedger.Agent" (what Task Manager lists); each library its own assembly
name; every managed LegalCopyright was one space; the apphost's OriginalFilename is its assembly's (FrameLedger.dll).
tools/versioninfo-check.ps1 read the five native binaries and nothing else.

- Directory.Build.props: Company, Product, Authors, Copyright, Description (the native blocks' sentence, the Comments
  field), RepositoryUrl (stamped as AssemblyMetadata by the SDK); the FrameLedgerSourceRef metadata moved here from the
  App csproj, and release.yml passes the same ref to the Agent's publish.
- App: AssemblyTitle "FrameLedger" and a Description. Agent: AssemblyTitle "FrameLedger Agent" and a Description.
- versioninfo-check.ps1: the rules in one function over a block, a managed half (-ManagedDir, -ExpectedProductVersion -
  required, -ManagedOnly), one LegalCopyright across every binary read, the apphost carrying its assembly's block,
  Company as well as Product = FrameLedger, and -SelfTest: ten cases, nine RED, each for the reason it names (four
  mutations of the rules each turn the self-test red). build.ps1 runs the self-test and both halves (the managed half
  alone under -SkipNative); release.yml reads out/app with the tag's version.
- AssemblyIdentityTests (App, Agent): company, product, copyright = FL_COPYRIGHT parsed from CMakeLists.txt,
  description, RepositoryUrl = IssueLink.Repository, and the Win32 block Explorer shows. Red on the source before.

Docs: 12_BUILD (Identity table, the gate, the publish lines), 13_CI_CD, 19_SAFETY, FORKING (what a fork changes),
CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:33:07 +07:00
poli0981andClaude Opus 5.5 1f7aebd0a4 fix(capture): a crash is a crash report of this game or the engine crash reporter it started (beta.14 PR-5) (#267)
Owner request 2026-10-05 (prevention; example SILENT HILL 2, UE 5.1), and a false crash found on the
owner's ledger: The Witcher 3, 2026-10-04, exit code 0, stored crashed by a WER 1001
RADAR_PRE_LEAK_64 (Windows' memory-leak detector) whose P1 named witcher3.exe.

E1 - CrashEventMatcher (pure): a 1000 from "Application Error" counts only when its AppName [0] equals
the executable's, its AppPath [10] (when given) is the executable's, and its ProcessId [8] (typed)
is the session's pid; a 1001 from "Windows Error Reporting" only when EventName [2] is a crash report
(APPCRASH, BEX, BEX64, CLR20r3, MoAppCrash, MoBEX) and P1 [5] equals the name. EventLogCrashSource
filters by provider in the XPath and asks the matcher; ICrashEventSource.FoundCrash(CrashQuery).
Checked once against the owner's real Application log: the Witcher 3 window no longer matches.

E2 - CrashReporterWitness, fed by the watcher's 1 s snapshots (CaptureOrchestrator.PollOnceAsync):
every on-crash reporter (CrashReporterCatalog: CrashReportClient, CrashReporter, CrashReport,
BsSndRpt/BsSndRpt64) with its parent by pid, image and start (a pid reused by a later process is not
the parent); always-on handlers (UnityCrashHandler64/32, crashpad_handler) never. SessionRecorder asks
at the end (two more polls when the game just left, at most 2.5 s); CrashReporterRule counts it when it
started >= 10 s after the game and the game left within 60 s: crashed, notes crash_reporter=<image>;
otherwise a note crash_reporter_seen=. Unreal's crash (exit code 3, no event) is crashed now. No
process is opened. Formats.ExitText names the reporter (string en/vi/ja).

E4 - ExecutableLocator: "bssndrpt" and "bugsplat" are helper fragments (KCD2 picked its game by rank).

Privacy Policy 2.7 (section 4): the Application log's crash reports about a tracked game, and the names
of programs a tracked game starts (the first was read since P2 and not stated).

Tests: CrashEventMatcherTests (the real RADAR record shape, a hang, a name inside another, pid and path
ties, typed and hex values), CrashReporterWitnessTests, CrashReporterRuleTests, SessionRecorderTests
(exit code 3 + reporter = crashed and named; a game that kept running = note only), ExitStatusMapper,
CaptureNotes, ReasonText (ExitText), ExecutableLocator, EventLogCrashSource.

Docs: 04_CAPTURE (crash classification corrected in place), 19_SAFETY (crash safety), 06_DATA_MODEL
(note slots), LIMITATIONS (When a game crashed), CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 03:54:05 +07:00
poli0981andClaude Opus 5.5 101b6cf4d3 test(infra): the build-id mismatch check uses another id of the same length, not one longer than the field (beta.14) (#273)
ShmHandshakeValidatorTests.TheGuardReportsThisInstallsBuildId appended "x" to this install's build id and expected a
mismatch. The handshake's buildId holds 31 characters plus NUL, and the helper cuts at 31: once `git describe` is 31
characters long - ten commits after a tag, v0.1.0-beta.13-10-g15ec7c1c5fd4 in a local gate on 2026-10-06 - the cut id
equals the real one and the check read Ok. It passed for the first nine commits after every tag and failed from the
tenth, locally and on CI alike.

The mismatch is now another id of the same length (the last character changed), which can never be cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 02:59:31 +07:00
poli0981andClaude Opus 5.5 e8bb477415 test(app): the chart-wheel test says which keys are held instead of reading the machine's keyboard (beta.14) (#268)
A local ./build.ps1 check (PR-6) went red on ChartWheelTests.APlainWheelOverAChartScrollsThePageAndNotTheChart:
offset 0. Nothing in that gate touched the App. ChartWheel read Keyboard.Modifiers, which is the machine's real
keyboard from any thread - measured: a fresh background STA thread's GetKeyState reported the machine's NumLock - so a
Ctrl held anywhere while the test ran sent the plain wheel down the zoom path (page not scrolled). CI, with no person at
the keyboard, never saw it.

ChartWheel.CurrentModifiers (default Keyboard.Modifiers; the App never sets it) is what both handlers read; the test sets
it inside its own work item on the one STA thread and puts it back. The keys are a parameter now, so the Ctrl+wheel half
is driven end to end too (page stays, the surface ScottPlot zooms from is reached). A mutation that stops Ctrl+wheel at
the plot turns that case red.

Docs: 14_TESTING (a test that sends input says which keys are held), CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 02:20:27 +07:00
poli0981andClaude Opus 5.5 5ac1555a8b fix(guard): a scan-set member still loading or already gone is read again once before the guard refuses, and a refused re-scan of a game that has exited ends as its exit (beta.14 PR-4, D48) (#266)
Owner decision D48 (2026-10-05), from the crash-reporter question: the 30 s re-scan reads every process
in the game's tree; a member still being created (an engine's crash reporter as its game dies, any
helper started a moment before - EnumProcessModulesEx ERROR_PARTIAL_COPY) or gone between the snapshot
and the open (OpenProcess ERROR_INVALID_PARAMETER) refused the session as unreadable, ending it as a
safety unhook - which also ends a user-mode exception's trial for good.

Native (FrameLedger.Guard): Collected::kRetry, produced by EnumerateModules only for those two errors;
ACCESS_DENIED (a protected process) stays kFailed and is never retried. CheckModules runs one pass,
notes a kRetry and goes on (a finding anywhere still refuses at once), then Pause(kScanRetryPauseMs =
250) and a second pass over a FRESH scan set, where kRetry refuses as kProcessUnreadable and a gone
target leaves no set (kProcessTreeUnavailable). Sources::Pause seam (Sleep in SystemSources).
FindPresentationRuntime treats kRetry as "not yet". fl_prescan's chain ended in an implicit pass for
any new Collected value - it refuses anything but kOk now. fl-baseline-probe names the new value.

Managed: ExitScanRelabel - when the re-scan refused for ProcessUnreadable / ModuleScanFailed /
ProcessTreeUnavailable (never a finding) and the game itself has exited at conclusion, the session is
TargetExited (exit code decides normal/crashed), CaptureOutcome.ExitScanReason, notes
`scan_at_exit=<reason>` (CaptureNotes.ScanAtExit). Findings, live games and other checks unchanged.

Tests: ctest fl_guard [D48] (re-read clean; still unreadable refuses; exited member drops out; gone
target refuses; ACCESS_DENIED never retried; a finding refuses at once; a finding the re-read sees
refuses; [live]: a suspended process and a pid with no process answer kRetry against the real source),
CaptureSessionTests (relabel for the three reasons; live game, finding, driver failure unchanged),
SessionRecorderTests (the note and the exit status), CaptureNotesTests.

Docs: 19_SAFETY (check 1 amended; During a session), 04_CAPTURE, 14_TESTING, CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 02:02:46 +07:00
poli0981andClaude Opus 5.5 544a6c6202 fix(update): the channel follows the running copy, no update is applied at start behind FR-12, and the apply waits for a game still holding the Overlay (beta.14 PR-3, D47) (#265)
Owner request 2026-10-05: audit the update logic (no failure reported). Read against Velopack 1.2.0
and the owner's own updater log.

- update.channel defaulted to stable while every release is a GitHub pre-release: a copy left on its
  defaults never found one (the log: "No releases found" since the ledger reset). Owner decision D47:
  default `auto` (choices auto/stable/beta) - UpdateChannelPolicy: a pre-release copy asks for
  pre-releases, a release for releases; a stored stable/beta wins. Settings lists "Automatic (Beta)".
- VelopackApp applied a downloaded package at the next start (SetAutoApplyOnStartup is ON by default)
  inside Run(), before FR-12 and the Agent's stop - the log shows the Agent killed. Off now; the
  package is adopted at start (UpdateService.AdoptPending over UpdateManager.UpdatePendingRestart, no
  feed request) and goes Ready/Deferred like any other.
- OnBeforeUpdateFastCallback asks the Agent to stop before Velopack replaces the version (installer
  over an installed copy); Velopack's diagnostics go to the App's log (VelopackSerilogLogger).
- The apply waits while a game still has FrameLedger.Overlay.dll (or the Vulkan layer) loaded from the
  install folder (PayloadInUse: a mapped image refuses an exclusive write; no process opened), and
  while an Agent waits on the administrator prompt (ElevationMarker, beside the instance lock).
- Stop budget = IpcProtocol.AgentShutdownGrace (15 s, the Agent's host reads it too) + 5 s; was 10 s.
- The offer states the delta's size (UpdateInfo.DeltasToTarget) with the full package as fallback.
- IOException is Offline only from the network (HttpIOException, a socket error); the uninstaller
  removes the "Start FrameLedger with Windows" Run value.

Tests: UpdateChannelPolicyTests, UpdateServiceTests (pre-release copy asks for pre-releases; a stable
choice wins; a pending package is Ready without a feed request and applies; deferred under a session;
a held Overlay keeps it Ready, leaves the Agent alone and says why; the elevation marker holds the
folder; the stop budget outlasts the grace), VelopackHooksTests (private fields of the pinned 1.2.0
builder: _autoApply false, the logger, the before-update hook), UpdatePromptsTests, PayloadInUseTests,
UpdateFailureMapperTests, UninstallHookTests, SettingsViewModelTests, SettingsRegistryTests.
Strings en/vi/ja (ja marked review).

Docs: 11_UPDATER (the update audit, beta.14), 06_DATA_MODEL, 08_UI, 12_BUILD, LIMITATIONS,
guide/01-install, CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 01:46:24 +07:00
poli0981andClaude Opus 5.5 c1984cab74 feat(app): Settings > Window > Hide scroll bars - no bar drawn anywhere, every scroller still scrolls (beta.14 PR-2) (#264)
Owner request 2026-10-05: an option to hide the scroll bars but still scroll.

ui.hide_scrollbars (bool, default 0, App only - AgentReads false). A bar's visibility is bound inside
its scroller's template, so no style reaches it: Services/ScrollBarHiding registers one class handler
on ScrollViewer's Loaded at start (beside DialogKeyboard) and, while on, sets an Auto or Visible axis to
Hidden - WPF's "no bar, still scrolls" for wheel, keyboard and touch - keeping the scroller's own value
on it; a Disabled axis is never touched (it lays its content out at the viewport's width). The Settings
toggle applies to the open windows at once (posted to the dispatcher from another thread), and off puts
every kept value back. Read at start beside ui.fps_decimals.

Strings en/vi/ja (ja marked review). Tests: ScrollBarHidingTests (a plain scroller, a disabled one, a
DataGrid's, a multi-line TextBox's and a FlowDocumentScrollViewer's: on hides every bar and the wheel
still scrolls; off restores each scroller's own setting; one that loads while on is hidden and one that
loads after off is left alone), SettingsViewModelTests.HidingScrollBars..., SettingsRegistryTests.
The class joins the strings-culture collection (process-wide state, runs alone).

Docs: 06_DATA_MODEL (settings row), 08_UI (Settings), 16_WPFUI_SYNTAX (gotcha), CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 01:31:02 +07:00
poli0981andClaude Opus 5.5 32e3c5aa8e fix(app): the import list readable in the dark theme with whole tick boxes, and the mouse wheel scrolls every page, dialog and chart (beta.14 PR-1) (#263)
Owner report 2026-10-05 (screenshot of File > Import library in the dark theme; "the wheel does not
scroll, I have to drag the scroll bar").

Import list: the row style added in beta.11 was based on {x:Type DataGridRow}, which WPF UI 4.3.0 does
not define - it keys its row style DefaultDataGridRowStyle - so the lookup fell through to Aero2's row and
SystemColors.WindowBrush (white in every theme) under the dark theme's white text. Based on
DefaultDataGridRowStyle now. WPF UI's CheckBox (MinWidth 120, padding 11) drew a sliver of the box in the
40 px column: MinWidth 0, no padding. The dialog's own scrolling is off (ImportReviewPrompt.Create), so the
list takes the height the window leaves and is the one thing that scrolls; the intro and the count stay.
Compare's DataGridCheckBoxColumn (an Aero2 box) is a template column with the theme's CheckBox.

Wheel: NavigationViewContentPresenter makes ScrollViewer.CanContentScroll default to true for Page and wraps
such a page in a DynamicScrollViewer; the five pages' own root ScrollViewer then had infinite height,
nothing to scroll, and took every wheel. Every Page sets CanContentScroll="False"; page roots and the
session summary show their bar on Auto. The Logs tail is bounded again, so autoscroll follows the end.
Scrollers nested in dialogs are ui:PassiveScrollViewer. Charts/ChartWheel (through ChartTheme.Attach, all
nine plots): a plain wheel is re-raised on the plot's parent so ScottPlot never zooms; Ctrl+wheel zooms
and stops there.

Tests (each run red against the unfixed XAML first): ImportReviewRenderTests (every text cell >= 4.5:1
against the composited colour painted under it, Dark and Light; ticked boxes drawn whole, counted in a
RenderTargetBitmap; a 60-row list scrolls inside the list with the footer in view), AccessibilityTests
(no BasedOn a type the App's dictionaries hold no style for; no DataGridCheckBoxColumn; every Page opts out
of the DynamicScrollViewer; no plain ScrollViewer in a dialog), PagesLoadTests (pages navigated in the real
presenter are not wrapped and the wheel scrolls them; the Logs tail is bounded and follows the end; every
page reads CanContentScroll false after WPF UI's override), ChartWheelTests. Visuals/Wcag test helpers;
ContrastTests uses Wcag.

Docs: 08_UI (UX rules, Contrast's third hole), 16_WPFUI_SYNTAX (two corrections in place, five gotchas),
14_TESTING (what the App draws), guide/03 (Ctrl+wheel), CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 01:03:04 +07:00
poli0981andClaude Opus 5.5 0ffecb5851 release: 0.1.0-beta.13 - Velopack deltas in release.yml, the CHANGELOG section, the accuracy block's release line, README's release lines, LIMITATIONS' version, HANDOFF's train section and owner-only item 10 (#261)
* ci(release): publish a Velopack delta - download the previous release before vpk pack, keep only what this pack built, filter the feed to this build (beta.13)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* release: 0.1.0-beta.13 - the CHANGELOG section, the accuracy block's release line, README's release lines, LIMITATIONS' version, HANDOFF's train section with the one START HERE and owner-only item 10

VERSION stays 0.1.0: the tag's numeric core.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(capture): the four sessions that must end on a scan, a throw, the kill switch or an exit get a 30 s safety net instead of a 120 ms ceiling they raced on a loaded runner (beta.13)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-04 09:39:53 +07:00
170 changed files with 6762 additions and 433 deletions

No files matched your search

+41 -2
View File
@@ -154,7 +154,9 @@ jobs:
$ref = if ('${{ steps.version.outputs.dry_run }}' -eq 'true') { '${{ github.sha }}' } else { "v$v" }
dotnet publish src/FrameLedger.App -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -p:Version=$v -p:FrameLedgerSourceRef=$ref -o out/app
if ($LASTEXITCODE -ne 0) { throw 'App publish failed' }
dotnet publish src/FrameLedger.Agent -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -p:Version=$v -o out/app
# beta.14 (D50): the same ref for the Agent - Directory.Build.props stamps it on every assembly, and both
# publishes build the same libraries into this one folder.
dotnet publish src/FrameLedger.Agent -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -p:Version=$v -p:FrameLedgerSourceRef=$ref -o out/app
if ($LASTEXITCODE -ne 0) { throw 'Agent publish failed' }
# A self-contained package redistributes the .NET runtime, and its licence and
@@ -195,7 +197,8 @@ jobs:
if ($missing.Count -gt 0) { throw "out/app is missing: $($missing -join ', ')" }
if (Test-Path out/app/FrameLedger.CaptureHost.exe) { throw 'out/app contains the unshipped capture host (12_BUILD: exactly two roots)' }
if (@(Get-ChildItem out/app/licenses/dotnet -File -ErrorAction SilentlyContinue).Count -lt 2) { throw 'out/app/licenses/dotnet holds fewer than two files -- the runtime licence step did not run' }
./tools/versioninfo-check.ps1 -BuildDir out/app
# beta.14 (D50): the managed half too - the eight managed binaries, carrying the tag's full version.
./tools/versioninfo-check.ps1 -BuildDir out/app -ManagedDir out/app -ExpectedProductVersion '${{ steps.version.outputs.version }}'
if ($LASTEXITCODE -ne 0) { throw 'versioninfo-check over the published tree' }
$size = (Get-ChildItem out/app -Recurse -File | Measure-Object Length -Sum).Sum / 1MB
Write-Host ("published tree: {0:N0} MB" -f $size)
@@ -210,17 +213,53 @@ jobs:
# ledger.db, logs, the layer manifest). The same id would put the install inside
# the ledger's folder and have the uninstaller remove every session without the
# question 12_BUILD promises. The title the user sees is still "FrameLedger".
# A DELTA (beta.13): vpk pack diffs against the newest full package already in --outputDir, and until beta.13 that
# directory was always empty - so no release carried a delta and every update downloaded the whole package
# (11_UPDATER §Built). The previous release is downloaded first; what THIS pack produced is assets.win.json, and only
# that is kept: the previous full package moves out (not uploaded, not checksummed) and the feed lists this build
# alone, as `vpk upload github` would write it. No previous release, or a download that fails, is a full-only
# release - said as a warning, not a stop, because it is exactly what every release before this one was.
- name: Pack (Velopack)
shell: pwsh
env:
GH_TOKEN: ${{ github.token }}
run: |
$ErrorActionPreference = 'Stop'
dotnet tool install -g vpk --version 1.2.0
if ($LASTEXITCODE -ne 0) { throw 'vpk install failed' }
$v = '${{ steps.version.outputs.version }}'
New-Item -ItemType Directory out/release -Force | Out-Null
vpk download github --repoUrl "https://github.com/${{ github.repository }}" --channel win --pre --token $env:GH_TOKEN --outputDir out/release
if ($LASTEXITCODE -ne 0) { Write-Host '::warning::the previous release could not be downloaded - this release carries a full package only' }
Write-Host 'previous release:'
Get-ChildItem out/release -File | ForEach-Object { Write-Host (" {0,-48} {1,12:N0}" -f $_.Name, $_.Length) }
vpk pack --packId FrameLedger.App --packVersion $v --packDir out/app --mainExe FrameLedger.exe --packTitle FrameLedger --packAuthors FrameLedger --releaseNotes out/notes.md --outputDir out/release
if ($LASTEXITCODE -ne 0) { throw 'vpk pack failed' }
$built = @((Get-Content out/release/assets.win.json -Raw | ConvertFrom-Json) | ForEach-Object { $_.RelativeFileName })
if ($built.Count -eq 0) { throw 'vpk pack wrote no assets.win.json entries' }
$keep = $built + @('releases.win.json', 'assets.win.json', 'RELEASES')
New-Item -ItemType Directory out/previous -Force | Out-Null
Get-ChildItem out/release -File | Where-Object { $keep -notcontains $_.Name } | Move-Item -Destination out/previous
$feed = Get-Content out/release/releases.win.json -Raw | ConvertFrom-Json
$feed.Assets = @($feed.Assets | Where-Object { $built -contains $_.FileName })
if ($feed.Assets.Count -eq 0) { throw 'the feed lists none of this build''s packages' }
[System.IO.File]::WriteAllText((Join-Path $PWD 'out/release/releases.win.json'), ($feed | ConvertTo-Json -Depth 8 -Compress), [System.Text.UTF8Encoding]::new($false))
if (Test-Path out/release/RELEASES) {
$legacy = @(Get-Content out/release/RELEASES | Where-Object { $built -contains ($_ -split ' ')[1] })
[System.IO.File]::WriteAllLines((Join-Path $PWD 'out/release/RELEASES'), [string[]]$legacy, [System.Text.UTF8Encoding]::new($false))
}
Write-Host 'this release:'
Get-ChildItem out/release | ForEach-Object { Write-Host (" {0,-48} {1,12:N0}" -f $_.Name, $_.Length) }
Write-Host ('feed: ' + (($feed.Assets | ForEach-Object { '{0} {1} {2}' -f $_.Type, $_.Version, $_.FileName }) -join '; '))
if (-not (Test-Path out/release/FrameLedger.App-win-Setup.exe)) { throw 'vpk did not produce FrameLedger.App-win-Setup.exe (README §Install names it)' }
$delta = "out/release/FrameLedger.App-$v-delta.nupkg"
if (Get-ChildItem out/previous -Filter '*-full.nupkg' -ErrorAction SilentlyContinue) {
if (-not (Test-Path $delta)) { throw "the previous full package was downloaded, but vpk produced no delta ($delta)" }
} else {
Write-Host '::warning::no previous full package - this release carries no delta'
}
- name: Checksums
shell: pwsh
+143
View File
@@ -28,6 +28,145 @@ numeric core and does not move; the heading is the full version — corrected 20
## [Unreleased]
## [0.1.0-beta.14] - 2026-10-06
**The fourteenth pre-release: a wheel that scrolls, updates that find this channel and wait for your games, crashes told
apart from memory reports, and new measurements.** The same unsigned installer: verify its hash against
`SHA256SUMS.txt`, then *More info → Run anyway*. What changed for a user:
- **The mouse wheel scrolls every page, dialog and chart**; over a chart the wheel scrolls the page and **Ctrl+wheel**
zooms the chart. **Settings ▸ Window ▸ Hide scroll bars** draws no bar and still scrolls. The import list is readable
in the dark theme.
- **Updates come from the channel of the copy you run** — a beta looks for betas — and are never applied on their own
when the App starts; restarting to update waits while a game FrameLedger measured is still running, and says so.
- **A game that crashed reads *crashed*, and only then**: a Windows memory report about a game no longer counts as a
crash, and an Unreal Engine game that opens its crash reporter and closes is recorded as crashed, the reporter named.
- **A game starting up or closing during FrameLedger's anti-cheat check** is read again once instead of refused, and a
check that could not read a game that had already closed ends the session as the game's own exit.
- **New in every session's summary**: time below 30 and 60 FPS and below the monitor's refresh rate, how even the frames
were, VSync and tearing, the graphics card's clocks, fan and memory temperature, how much of the time its power limit
or heat held it back (NVIDIA), frames per watt, and a render scale chart. Trend and Compare have them too.
- **FrameLedger's own programs say what they are** in Explorer and Task Manager (*FrameLedger Agent*).
**Updating from `0.1.0-beta.13`:**
1. **First choose *Beta* in Settings ▸ Updates.** beta.13 looks for stable releases by default, and every release so far
is a pre-release, so it finds nothing until you do. From beta.14 on the channel follows the copy you run.
2. **Update with no game running.** beta.13 still applies a downloaded update the next time the App starts, stopping the
Agent to do it; beta.14 no longer does.
3. **The database is migrated in place** (schema 0019, new columns only). An earlier version cannot open it afterwards.
4. Sessions already stored keep their status — a few may still read *crashed* because Windows logged a memory report
about the game. The Privacy Policy (version 2.7) is shown once for you to accept.
### Added
- **Settings ▸ Window ▸ Hide scroll bars.** No scroll bar is drawn anywhere in the app while it is on, and everything
still scrolls with the mouse wheel, the keyboard and touch. Off by default; it applies at once, to the open windows
too, and off brings every bar back.
- **New measurements in every session** (recorded from this version on; earlier sessions read N/A):
- **time below 30 FPS, below 60 FPS and below the monitor's refresh rate**, and how much one frame's time differs from
the next. A game held at its frame limit is not counted as dropping below it for the small wobble every frame limit
has — on the developer's machine a game capped at 60 read half its time "below 60" by the plain rule;
- **VSync and tearing**: how many of the game's frames asked to wait for the display, and how many allowed tearing
(Direct3D games);
- **the graphics card's clock speeds, fan speed and memory temperature**, and — on NVIDIA cards — how much of the time
its power limit or its temperature held it back;
- **frames per watt**: the game's own frames per second for each watt the graphics card drew, never counting generated
frames.
The session's sensor statistics table shows the new card readings in their own units. The database is migrated in
place (schema 0019), and an earlier version cannot open it afterwards.
- **Where the new measurements are shown:** the session summary has a card for each (the 1% low card also shows the
displayed frames' 1% low when frame generation was counted, beside the game's own), a **Render scale** chart — the
share of the screen's resolution the game rendered at, over the session — and a **Clocks and fan** chart under
Sensors, with the moments the card was held back shaded; the card's memory temperature joins the temperatures chart.
A game's **Trend** has nine more metrics and **Compare** nine more rows, where a figure taken over presents says
*(presented)* beside one taken over the game's own frames. The **Latency** tab is shown only for a game with a session
that measured latency — none does yet.
### Fixed
- **A session could read "crashed" when the game had not crashed, and an Unreal game's crash read "ended normally".**
Any Windows report that named the game counted as a crash — on the developer's machine a memory-leak report Windows
writes about large games marked an ordinary The Witcher 3 session *crashed*; hang reports and another program whose
name contains the game's would have done the same. Only a crash report of this game's own process counts now. And
Unreal Engine games handle their own crash: they open their crash reporter and exit with code 3, which said nothing;
FrameLedger now sees the crash reporter a game starts (Unreal's, CD PROJEKT RED's, Capcom's, BugSplat's) and records
the session as crashed when the game exits within a minute of it — the summary names the reporter. Unity's and
Chromium's crash handlers start with their game and are never taken for a crash. Sessions already stored keep their
status. BugSplat's sender (Kingdom Come: Deliverance II) can no longer be picked as a game's executable by the import.
The Privacy Policy (2.7) now says that FrameLedger reads Windows' crash reports and the names of programs a game starts.
- **A game that exited as FrameLedger's anti-cheat check ran could be recorded as "unhooked (safety)"** — and, under a
user-mode anti-cheat exception, end the exception's trial for good. The check reads every process in the game's
tree every 30 s; one that was just starting (an engine's crash reporter as its game dies, any helper the game launched
a moment before) or already gone could not be read, and the check refused. Such a process is now read once more a
quarter of a second later, and refused only if it is still unreadable (a protected process never gets the second
look). And when the check could not read and the game itself has exited, the session ends as that exit, normal or
crashed by its exit code. Anything the check *finds* is a refusal exactly as before (owner decision D48).
- **An installed copy never found an update unless you had changed its channel.** The update channel was *Stable* by
default and every FrameLedger release so far is a pre-release, so the check found nothing. The channel is now
*Automatic*: a pre-release looks for pre-releases and a release for releases; choosing *Stable* or *Beta* still decides.
- **A downloaded update was applied the next time FrameLedger started, before anything could check for a running game.**
The update library applies a waiting package at start unless told not to, and nothing told it: it stopped the capture
agent mid-session instead of letting it finish. The App now offers such a package as *Restart to update*, which waits
for the session to end and stops the agent properly, as it always did for a download in the same run.
- **The update dialog said ~102 MB when the download was the 1.6 MB delta.** It now says the delta's size and names the
full package as the fallback; the updater's own lines are in the App's log, so a full download shows there.
- **Restart to update could fail half way** when a game FrameLedger had measured was still running — its loaded overlay
cannot be replaced — or when an agent was still waiting on the administrator prompt, and it gave the agent 10 s to stop
where the agent takes up to 15. It waits for all three now and says why. A full disk no longer reads as "offline",
and uninstalling removes the *Start FrameLedger with Windows* entry.
- **The import list was unreadable in the dark theme.** File ▸ Import library (and Games ▸ Refresh) drew every row white
with white text, and each tick box as a sliver at the row's edge: a row style added in beta.11 to dim the games already
in the library fell through to Windows' own row, which is white in every theme, and WPF UI's check box is too wide for
its 40 px column. The rows take the theme's colours again and the boxes are whole, and the list is the one thing in the
dialog that scrolls — its intro and the count under it stay in view, where a list scrolling inside a scrolling dialog
used to carry the intro away. Compare's session picker draws the theme's check boxes too (it drew Windows' old ones).
- **The mouse wheel scrolled nothing on the Dashboard, Games, a game's page, Compare and Settings** — only dragging the
scroll bar did. WPF UI wraps a page in a scroller of its own unless the page says otherwise, and inside it each page's
own scroller had nothing to scroll and still took every wheel. Every page scrolls itself now. The Logs page had the same
cause: its tail grew to hold every line and never followed the newest one, as it was meant to. A scroller inside a
dialog (the consent, administrator, anti-cheat exception and bug report dialogs) hands the wheel on at its ends.
- **The chart-wheel test read the real keyboard** (developers): a Ctrl held anywhere on the machine while the test ran
turned its plain wheel into a zoom, and a local gate went red once. The keys held are now the test's own input, and the
Ctrl+wheel half is driven end to end as well.
### Changed
- **Over a chart, the wheel scrolls the page; Ctrl+wheel zooms the chart.** ScottPlot zoomed on every wheel, which with
the pages scrolling again would have zoomed the chart and scrolled the page at once. Dragging still pans and
double-click still resets.
- **FrameLedger's own programs say what they are.** In Explorer (*Properties ▸ Details*) `FrameLedger.exe` and
`FrameLedger.Agent.exe` now name the product, the author's copyright and what each one does, as the native DLLs always
have; Task Manager lists the background service as *FrameLedger Agent* rather than *FrameLedger.Agent*. Until this
release the Agent called its company and product "FrameLedger.Agent" and no managed file carried a copyright. The
release check now reads both kinds of file and fails when one of them does not name FrameLedger or carries a different
copyright line.
## [0.1.0-beta.13] - 2026-10-04
**The thirteenth pre-release: refusal notices that say where the anti-cheat is, GPU sensors that follow the game's graphics
card, and smaller updates.** The same unsigned installer: verify its hash against `SHA256SUMS.txt`, then *More info → Run
anyway*. What changed for a user:
- **An anti-cheat driver or service running on the PC is said as that.** While, for example, Easy Anti-Cheat's service
runs for another game, FrameLedger hooks no game at all; the notice used to say the anti-cheat "was detected in this
game", naming a game that may not even use it. It now says the anti-cheat is running on this PC, and the session's
summary says the same. A finding in the game itself still says "in this game".
- **The notice for a capture stopped mid-game** no longer promises that FrameLedger will hook the game again "when you
enable it again" — which was not true either way. It says where the anti-cheat was found and whether hooking was
turned off.
- **On a PC with more than one graphics card**, the GPU figures follow the card the game draws on once it has shown its
first frame, instead of the first card Windows lists (often a laptop's integrated GPU). Not yet tested on such a PC.
- **Updates download only what changed**: this release carries a delta package against `0.1.0-beta.12`, so updating
from it through the App downloads a fraction of the full ~107 MB.
**Updating from `0.1.0-beta.12`:**
- Help ▸ Check for updates downloads the delta; or quit the App (tray icon → Exit), end `FrameLedger.Agent.exe` and
run the installer as before.
- No database change, and no document to accept again.
### Fixed
- **A refusal because of a driver or service said the anti-cheat "was detected in this game".** The guard's checks for
@@ -44,6 +183,10 @@ numeric core and does not move; the heading is the full version — corrected 20
LibreHardwareMonitor reads that brand's GPU rather than the first one it lists (often a laptop's integrated GPU), and
NVAPI says nothing when the game runs on an AMD or Intel card — N/A rather than another card's temperature.
`LIMITATIONS.md` says what still describes the first card.
- **Updates download only what changed**, from this release on: each release now carries a Velopack delta package
against the previous one beside the full package, and an installed copy one release behind downloads the delta. No
earlier release had one — every update so far downloaded the whole ~107 MB package — so the first update that can use
a delta is from `0.1.0-beta.12` to this one; Velopack falls back to the full package whenever the delta does not apply.
- **Tests that change the App's language ran beside tests that read its text**, so the second kind could read the
wrong language once in many runs; the language-changing tests now run on their own.
+26
View File
@@ -69,6 +69,32 @@
<IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
</PropertyGroup>
<!-- beta.14 (D50): every managed binary names the product and who wrote it, as the native ones always have
(19_SAFETY: a binary says plainly what it is). Explorer's Properties > Details and Task Manager read these. Until
beta.14 the SDK's defaults stood: the Agent's Company and Product read "FrameLedger.Agent", each library's its own
assembly name, and no managed binary carried a copyright. The copyright is the native FL_COPYRIGHT
(src/native/CMakeLists.txt) word for word: tools/versioninfo-check.ps1 reads both from the built binaries and is
red when they differ. The file description is the AssemblyTitle - an entry point sets its own, a library keeps its
assembly name - and the Description is the Comments field, the native blocks' sentence for a library. The SDK
stamps RepositoryUrl into every assembly as AssemblyMetadata; it is the App's IssueLink.Repository, and the App's
AssemblyIdentityTests holds the two equal (a fork changes both - FORKING.md). -->
<PropertyGroup>
<Company>FrameLedger</Company>
<Product>FrameLedger</Product>
<Authors>poli0981</Authors>
<Copyright>Copyright (C) 2026 poli0981. GPL-3.0-only with additional terms: see NOTICE</Copyright>
<Description>Performance measurement tool. Identifies itself deliberately; see https://github.com/poli0981/frameledger</Description>
<RepositoryUrl>https://github.com/poli0981/frameledger</RepositoryUrl>
</PropertyGroup>
<!-- beta.12: the source a build was made from - release.yml passes the tag (a rehearsal, its commit); a local build has
none. The App's links into the repository open THIS version's documents with it (Services/RepositoryLinks.cs).
Every assembly since beta.14 (D50), not the App's alone: the two publishes build the same libraries into one
out/app, and release.yml passes the same ref to both. -->
<ItemGroup Condition="'$(FrameLedgerSourceRef)' != ''">
<AssemblyMetadata Include="FrameLedgerSourceRef" Value="$(FrameLedgerSourceRef)" />
</ItemGroup>
<!-- Test projects: documentation comments are noise, and xUnit's own
analyzers already cover what matters there. -->
<PropertyGroup Condition="$(MSBuildProjectName.EndsWith('.Tests'))">
+1 -1
View File
@@ -68,7 +68,7 @@ share — and migrate — one database, and fight over the same pipe and shared
| Logon task | `LogonTask` (the Agent's maintenance verbs) | one task per name |
| Issue and help links | `IssueLink.Repository` (`src/FrameLedger.App/Services/IssueLink.cs`) — `RepositoryLinks` builds every document link in the App from it and the source ref `release.yml` passes — plus the Releases link in `guide/01-install.md` and `.github/ISSUE_TEMPLATE/` | your users' reports belong in your tracker |
| Who the documents name | `legal/EULA.md`, `legal/DISCLAIMER.md`, `legal/PRIVACY_POLICY.md` name poli0981 as the Developer, with a contact | the person who distributes a build is the one its users deal with; review every claim they make, too — they describe FrameLedger's builds, not yours |
| Version information | `FL_COMPANY_NAME` / `FL_PRODUCT_NAME` in `src/native/CMakeLists.txt`, and the `ProductName` that `tools/versioninfo-check.ps1` requires | anti-cheat vendors and users identify the DLLs loaded into games by it (`docs/19_SAFETY_AND_ANTICHEAT.md`); it must name your project |
| Version information | `FL_COMPANY_NAME` / `FL_PRODUCT_NAME` / `FL_COPYRIGHT` in `src/native/CMakeLists.txt`; `Company` / `Product` / `Authors` / `Copyright` / `Description` / `RepositoryUrl` in `Directory.Build.props` and the `AssemblyTitle` / `Description` of the App's and the Agent's csproj (since beta.14); and the names `tools/versioninfo-check.ps1` and the two `AssemblyIdentityTests` require | anti-cheat vendors and users identify the DLLs loaded into games and the processes beside them by it (`docs/19_SAFETY_AND_ANTICHEAT.md`); it must name your project, and the copyright line must be one line on every binary — the check compares them |
| Checksums | your own `SHA256SUMS.txt` | users verify what *you* built |
The detection rules and the anti-cheat blocklist (`rules/detection-rules.json`) ship with each build; keeping them
+32 -1
View File
@@ -5,7 +5,7 @@ hooking on for — and reading the graphics calls the game makes. That is why it
resolution, the upscaler, frame generation and ray tracing apart. It is also where its limits come from. This
page lists them in plain words; each item links to the document that has the details.
*Beta software: this page describes version 0.1.0-beta.12.*
*Beta software: this page describes version 0.1.0-beta.14.*
## Games it will not measure
@@ -39,6 +39,18 @@ Windows, outside the game) and why nothing was measured.** Every
frame-rate, upscaler, frame-generation and ray-tracing value reads **N/A**, never 0. How the game's window was
shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
## When a game crashed
- A session reads **crashed** when the game ended with an exception's code, when Windows logged a crash report of it,
or — since 0.1.0-beta.14 — when it started its engine's crash reporter (Unreal's, CD PROJEKT RED's, Capcom's,
BugSplat's) and exited within a minute. A game that handles its own crash quietly, starts no reporter and leaves no
crash report reads **ended normally**, with its exit code.
- A crash reporter is seen from a once-a-second look at running programs: one that opens and closes faster can be
missed, and one started in the game's first 10 seconds is not counted (it could be a monitor that starts with the
game). Unity's crash handler and Chromium's `crashpad_handler` start with every game that has them, so their presence
says nothing. Sessions recorded before 0.1.0-beta.14 keep how they were stored — a few of them may read *crashed*
because Windows logged a memory report about the game. ([details](docs/04_CAPTURE.md))
## Frame rate and frame generation
- **One inflated number is never shown.** When frame generation is measured, the page shows the game's own
@@ -52,9 +64,18 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
- **A session whose frame generation changed** (menus, loading, a settings change) shows the factor of the
state it spent most of its time in, with the share of the session it covers — never an average of the two.
([Metrics](docs/03_METRICS.md))
- **Time below 30, 60 FPS and below the refresh rate** (since 0.1.0-beta.14) leaves out the small wobble of a game
held at its limit: a frame counts as below 60 when it took 10 % longer than 1/60 s, or when the frames around it ran
2 % slower. So a game running steadily just under the line — 59 FPS against 60 — reads partly as at it. Time below
the refresh rate needs the monitor's rate, which a session saved after a crash does not have.
- **VSync and tearing** (since 0.1.0-beta.14) are what the game *asked* for on each frame; the graphics driver or a
variable-refresh display can override it, and FrameLedger cannot see which won. OpenGL and Vulkan games do not say,
and read N/A. ([Metrics](docs/03_METRICS.md))
## Upscaling and ray tracing
- **The render scale chart** (since 0.1.0-beta.14) is drawn only where the render resolution was measured — the
same games as *Render → output resolution* in the accuracy statement; elsewhere it says it was not measured.
- The upscaler is read from the game's calls: DLSS and NIS through NVIDIA Streamline, and FSR through AMD's
FidelityFX libraries. **Intel XeSS is not read** (its licence forbids it), FSR 2 and upscalers built into the
game are not identified, and Vulkan and OpenGL games read N/A. Where no hook saw DLSS but the NVIDIA driver
@@ -111,6 +132,11 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
- **CPU temperature** needs *Run the agent as administrator* and the separately installed PawnIO driver, and
has not been verified on real hardware yet. CPU load is the time the processor was busy — not Task
Manager's "utility" figure, which can exceed 100%. ([Telemetry](docs/18_GPU_VENDOR_APIS.md))
- **Whether the graphics card was held back by its power limit or by heat** (since 0.1.0-beta.14) is known only on
NVIDIA cards, and only as it was at each once-a-second reading. On other cards it reads N/A.
- **Frames per watt** (since 0.1.0-beta.14) counts the game's own frames — never generated ones — against the graphics
card's power alone, not the processor's or the whole PC's. It reads N/A where the game's own frame rate is not known.
([Metrics](docs/03_METRICS.md))
## Running the agent as administrator
@@ -146,3 +172,8 @@ you accept the prompt. Turn it on only if you trust everything that runs under y
FrameLedger's programs are **not code-signed**: Windows SmartScreen may warn when you install it, and the
administrator prompt names an unknown publisher. Each release publishes SHA-256 checksums you can compare.
**An update waits while a game FrameLedger measured is still running.** The part of FrameLedger loaded into a game stays
loaded until the game exits, and Windows will not let the update replace it; *Restart to update* says which file is held
until you close that game ([details](docs/11_UPDATER.md)). Copies older than 0.1.0-beta.14 look only for stable
releases unless you choose *Beta* in Settings ▸ Updates, and apply a downloaded update the next time they start.
+12 -4
View File
@@ -9,8 +9,8 @@ anti-cheat, and look after your data, a page each. What FrameLedger cannot do is
[Limitations](LIMITATIONS.md). Both are in the app too (Help ▸ User guide, Help ▸ Limitations).
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.12`** (2026-10-04), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.14`** (2026-10-06), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
> game in the library runs (unless you switched its recording off), injects only into games you enabled
@@ -73,6 +73,14 @@ anti-cheat, and look after your data, a page each. What FrameLedger cannot do is
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
@@ -153,7 +161,7 @@ Elevation is **optional — for everything.** Hooked capture is the normal path
## Install
> **The latest pre-release is `v0.1.0-beta.12` (2026-10-04); before it `v0.1.0-beta.11` (2026-10-03), `v0.1.0-beta.10` (2026-09-28), `v0.1.0-beta.9` (2026-09-26), `v0.1.0-beta.8` (2026-09-25), `v0.1.0-beta.7` (2026-09-23), `v0.1.0-beta.6` (2026-09-23), `v0.1.0-beta.5` (2026-09-22), `v0.1.0-beta.4` (2026-09-21), `v0.1.0-beta.3` (2026-09-21), `v0.1.0-beta.2` (2026-09-17) and `v0.1.0-beta.1` (2026-09-16).** They are pre-releases: read `CHANGELOG.md`'s section for the one you install — what it measures, what it does not yet, and how to update — before installing. A source build is `docs/12_BUILD.md`.
> **The latest pre-release is `v0.1.0-beta.14` (2026-10-06); before it `v0.1.0-beta.13` (2026-10-04), `v0.1.0-beta.12` (2026-10-04), `v0.1.0-beta.11` (2026-10-03), `v0.1.0-beta.10` (2026-09-28), `v0.1.0-beta.9` (2026-09-26), `v0.1.0-beta.8` (2026-09-25), `v0.1.0-beta.7` (2026-09-23), `v0.1.0-beta.6` (2026-09-23), `v0.1.0-beta.5` (2026-09-22), `v0.1.0-beta.4` (2026-09-21), `v0.1.0-beta.3` (2026-09-21), `v0.1.0-beta.2` (2026-09-17) and `v0.1.0-beta.1` (2026-09-16).** They are pre-releases: read `CHANGELOG.md`'s section for the one you install — what it measures, what it does not yet, and how to update — before installing. A source build is `docs/12_BUILD.md`.
1. Download the latest `FrameLedger.App-win-Setup.exe` from [Releases](https://github.com/poli0981/frameledger/releases). It installs into `%LOCALAPPDATA%\FrameLedger.App`; your data stays in `%LOCALAPPDATA%\FrameLedger`, and uninstalling asks before touching it.
2. SmartScreen may warn — releases are not code-signed (free, open-source project). Verify the SHA-256 checksum published with each release, then **More info → Run anyway**.
@@ -200,4 +208,4 @@ GPU telemetry is layered so the project never depends on a proprietary vendor li
---
**Status:** pre-release (beta). Twelve tagged pre-releases so far; see `CHANGELOG.md` for what each one changed and the accuracy block at the top of this file for what is and is not measured. It is not feature-complete, it certainly still has bugs, and `legal/DISCLAIMER.md` §0 says what that means for you.
**Status:** pre-release (beta). Fourteen tagged pre-releases so far; see `CHANGELOG.md` for what each one changed and the accuracy block at the top of this file for what is and is not measured. It is not feature-complete, it certainly still has bugs, and `legal/DISCLAIMER.md` §0 says what that means for you.
+19 -5
View File
@@ -320,13 +320,27 @@ function Invoke-ProjectGates {
# Being plainly identifiable to anti-cheat is a requirement, not packaging
# polish (docs/19_SAFETY_AND_ANTICHEAT.md). Reads the built binary, because
# what ships is what an anti-cheat vendor sees.
#
# beta.14 (D50): BOTH HALVES. The rules prove themselves first (ten cases,
# nine RED, each for its own reason), then the live pass reads the native five
# and the managed eight from the App's and the Agent's build output, whose
# ProductVersion is the VERSION file's here (release.yml passes the tag's).
# Under -SkipNative the managed half still runs.
Write-Step 'versioninfo-check'
$versionTool = Join-Path $repo 'tools/versioninfo-check.ps1'
if ((Test-Path $versionTool) -and -not $SkipNative) {
Invoke-Checked 'versioninfo-check' { & $versionTool -BuildDir (Join-Path $repo "build/native/x64-$($Configuration.ToLower())") }
}
elseif ($SkipNative) {
Skip-Gate 'versioninfo-check' 'native build skipped, so there is no binary to inspect'
if (Test-Path $versionTool) {
Invoke-Checked 'versioninfo-check (self-test)' { & $versionTool -SelfTest }
$managedDirs = @('FrameLedger.App', 'FrameLedger.Agent' | ForEach-Object { Join-Path $repo "src/$_/bin/$Configuration" })
$productVersion = (Get-Content (Join-Path $repo 'VERSION') -Raw).Trim()
if ($SkipNative) {
Invoke-Checked 'versioninfo-check (managed)' { & $versionTool -ManagedOnly -ManagedDir $managedDirs -ExpectedProductVersion $productVersion }
Skip-Gate 'versioninfo-check (native)' 'native build skipped, so there is no binary to inspect'
}
else {
Invoke-Checked 'versioninfo-check' {
& $versionTool -BuildDir (Join-Path $repo "build/native/x64-$($Configuration.ToLower())") -ManagedDir $managedDirs -ExpectedProductVersion $productVersion
}
}
}
else {
Skip-Gate 'versioninfo-check' 'tools/versioninfo-check.ps1 not implemented yet'
+69
View File
@@ -38,6 +38,9 @@ Let `D` = session duration (first → last present), `F_app` = frames the *game*
| **Stutter time %** | `Σ ft_app[stutter] / Σ ft_app × 100` | 1 |
| **PC latency** | mean/p95 of `reflexLatencyUs` when Reflex reports it | **1 only** |
| **PSO stutter %** | share of stutter frames with `psoCreatedThisFrame > 0` | **1 only** |
| **Time below 30 / 60 FPS** (beta.14) | share of `Σ ft_app` in frames that count as below X — `ft > 1.10 × 1000/X`, or the nine-frame rolling median `> 1.02 × 1000/X` (§Pacing) | 1 |
| **Time below refresh** (beta.14) | the same over **presents**, X = `display_monitor_hz` — the display's rate, so over what the display received | 1 |
| **Frame to frame** (beta.14) | mean `\|ft_app[k] − ft_app[k−1]\|` over neighbouring intervals, ms | 1 |
**Percentile method:** sort ascending, linear interpolation between closest ranks (NumPy `linear` / Excel `PERCENTILE`). Document it, test it — tools differ and users will compare numbers.
@@ -90,6 +93,41 @@ toward the session's data-quality warnings.
**Sufficiency guards (FR-4.8):** 0.1% Low needs ≥ 10,000 application frames, 1% Low ≥ 1,000; otherwise `N/A`.
## Pacing (beta.14, D49)
**Time below 30 / 60 FPS and below the refresh rate** are shares of the measured time — `Σ ft (counted) / Σ ft` — so a long
hitch weighs what a player sits through, not one frame among many. **Frame to frame** is the mean change from one frame
time to the next over neighbouring intervals (`FrameTimeSeries.FollowsBreak`: a pair with an interval left out between —
a gap, a pause — is not a pair); it is low when pacing is even whatever the rate.
**Which frames count as below X — and why not "longer than 1000 / X".** The present-to-present interval of a game held
at X jitters around `1000 / X` by a few tenths of a millisecond, half of it on the long side. Measured on a copy of the
owner's ledger (2026-10-06): a GIRLS' FRONTLINE 2 session capped at 60 (median 16.63 ms, 296,380 frames) reads **50.0 %**
of its time "below 60" under the plain rule, and a rolling mean does not help — the local average of a game held at 60
sits on the threshold. So a frame counts when **it is itself more than 10 % longer** than `1000 / X` (a long frame, never
jitter) **or the median of the nine frames around it** (`RollingMedian`, the stutter rule's centered window and edges) **is
more than 2 % longer** (a rate that stays below X). The same session reads 9.6 % (its time below 30 alone is 4.7 %); with
a 0.4 ms jitter a steady 58 FPS reads 93 %, a steady 60.2 reads 0.7 %, and a 100 ms hitch counts its own 100 ms and no
neighbour's. **The cost, stated:** a rate less than 2 % under X (58.8–60 FPS for 60) reads partly as at X — a steady 59
reads 40 %. `Domain.Metrics.FramePacing`; `FramePacingTests` pins each of these.
**Which series.** 30, 60 and frame to frame are over `ft_app` — application frames where generated frames were counted
(rule 6: generated frames do not make a game run at 60), the presents otherwise, labelled `(presented)` as every
present-only statistic is. **The refresh share is over the presents**, generated ones included: it is the display's rate,
and what matters there is what the display received — a ×4 frame-generation session on a 240 Hz display reads near 0 %,
and over its application frames it would read 100 % whatever the pacing. It needs `display_monitor_hz` (the display
tally's, §Display mode): a session recovered from its crash file has none, and reads N/A. **Sufficiency:** the 1 % low's
1,000 frames; below it every value is N/A.
## Sync — what the presents asked for (beta.14, D49)
`vsync_present_pct` is the share of the dominant stream's presents with a sync interval of one or more (the game asked
to wait for the display), `tearing_allowed_pct` the share with `DXGI_PRESENT_ALLOW_TEARING`. Both arguments were in every
Direct3D record since P1 (`FL_MEASURED_PRESENT_ARGS`) and read by nothing; `sessions.sync_interval_mode` (0001) gets its
first writer with them — `on` (every present), `off` (none), `mixed`. **Asked, not obtained:** a driver setting or a
variable-refresh display can override the request, and nothing in the process says which won. OpenGL's
`wglSwapBuffers` and Vulkan's `vkQueuePresentKHR` carry neither argument: N/A, never 0 %. Tier 1 only.
## Frame Generation — ground truth (Tier 1)
This is the metric the rewrite exists for. Resolution ladder, highest confidence first; the winning rung is stored in `fg_source`:
@@ -602,6 +640,12 @@ Tier 2 has none of this: `upscaler = unknown`, ratio `N/A`.
> 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.
**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
varied (the finalizer stores it only then), a flat line at the row's extent where it did not, and a sentence where the
upscaler's parameters were never measured (`App.Charts.RenderScaleSeries`). The Trend and Compare read the row's
`upscale_ratio`, the dominant extent.
## RT / PT / RR — evidence-based tri-state
Tri-state `Yes | No | N/A` per session with `source` (`measured | manual | inherited`).
@@ -798,6 +842,27 @@ Per session over 1 Hz samples: `avg` (mean of non-null), `max` — and since bet
series. Sensor timeline aligned to the frame timeline via the shared QPC epoch captured at session start. Fields with no
data are `N/A`, never 0.
**The card's clocks and limits (beta.14, D49), both tiers.** The core and memory clock (MHz), the fan (RPM) and the
memory temperature were in the samples before (L2 reads them, L3 too) and stored nowhere; they are series now
(`gpu_core_clock`, `gpu_mem_clock`, `gpu_fan`, `gpu_mem_temp`) with `avg_gpu_core_clock_mhz`, `avg_gpu_mem_clock_mhz`,
`avg_gpu_fan_rpm` and `max_gpu_mem_temp`. **What held the card back** is NVAPI's perf-decrease reasons
(`GpuSample.ThrottleReasons`, L3 only): `gpu_power_limit` / `gpu_thermal_limit` read 100 on a tick whose reasons include
the power limit (`0x2`) / thermal slowdown (`0x1`) and 0 on one whose reasons do not, so their mean — `power_limit_pct`,
`thermal_limit_pct` — is the share of ticks held back. A card no layer reports reasons for (every card but NVIDIA's) has
no answer: N/A, never "not limited". `throttle_pct` (any reason) is unchanged.
## Efficiency (beta.14, D49)
`app_frames_per_joule` = the application frame rate ÷ the card's average board power — FPS per watt, frames per joule.
**Never the displayed rate** (rule 6): a generated frame costs the card a fraction of a rendered one, and counting it would
sell frame generation as efficiency. The application rate is known when frame generation was counted over the session
(Native FPS; a counted `none` makes it the presented rate), or when no frame-generation runtime was loaded
(`presented_qualifier = no_fg_runtime`). **Null** for `census_not_run`, `fg_runtime_loaded` and `none_withheld`, for a
session whose generation changed state (its steady state covers a share of the session, and the power is the whole
session's), without a power reading, and at Tier 2 (no frames). The power is the **graphics card's** — not the
processor's, not the whole PC's — averaged over the session's sensor ticks. `Domain.Metrics.EnergyEfficiency`,
`SessionAggregator.ApplyEfficiency`.
## Accuracy budget ~~(shown in Help → About metrics)~~
*(Corrected 2026-10-04: no such page exists. Users read these limits in `LIMITATIONS.md` (Help ▸ Limitations) and in
@@ -814,6 +879,10 @@ data are `N/A`, never 0.
| PC latency | as reported by Reflex | not available |
| Display mode (beta.10) | per 100 ms sample: exclusive fullscreen as the swap chain answers it (DXGI; OpenGL and Vulkan cannot say), borderless, windowed, minimised; the window's size from user32 | per 1 s sample, from the window alone: windowed, minimised, or *fullscreen or borderless* — never split |
| GPU temp / load / power | vendor API accuracy, ±1 s sampling | same |
| GPU clocks / fan / memory temperature (beta.14) | vendor API accuracy, ±1 s sampling | same |
| GPU power / thermal limit (beta.14) | NVAPI's perf-decrease reasons once a second — a limit that came and went between two ticks is not seen; NVIDIA only, N/A on every other card | same |
| Time below 30 / 60 / refresh (beta.14) | from the frame times above, with the margins of §Pacing — a rate less than 2 % under the threshold reads partly as at it | **not available** |
| Efficiency (beta.14) | the application rate's accuracy over the board-power sensor's; N/A wherever the application rate is not known | **not available** |
| CPU temperature | sensor-inherent ±1–2 °C, needs LHM + PawnIO + elevation. **Read since 2026-09-21** (`Telemetry.LhmCpuTemperatureReader`: the package sensor, else the hottest core) and **unmeasured on real hardware** — no elevated run with PawnIO has been taken (`20_OPEN_QUESTIONS` §CPU) | same |
| CPU load | **time busy over elapsed, every logical processor** (`GetSystemTimes`, 1 Hz, unprivileged; since 2026-09-21). Not Task Manager's "utility", which is frequency-scaled and exceeds 100 under turbo — the two are different numbers and this one is stated as what it is. Null on a session's first tick (no interval yet), never 0 | same |
| System memory in use | physical memory in use machine-wide, MiB (`GlobalMemoryStatusEx`, 1 Hz, unprivileged; since 2026-09-21). The machine's, not the game's | same |
+23 -2
View File
@@ -437,8 +437,29 @@ because a layer cannot leave a running game's loader chain.
## Crash & exit classification
- Normal: presenting PID exit code 0 — **and since beta.8 any exit code that is not an exception's** (End task and taskkill leave 1; a program's own error exit; Ctrl+C's `0xC000013A`), kept in `capture_notes` and said as what it is.
- `crashed`: ~~nonzero exit code~~ **an exception's exit code** (`ExitStatusMapper.IsExceptionCode`: NTSTATUS `0xC0000000–0xC0FFFFFF` but `0xC000013A`, `0xE06D7363` C++, `0xE0434352` .NET, `0x80000003` breakpoint), **or** an Application Error (1000) / WER (1001) event log record naming the exe within `[start, end + 30 s]`.
- `unhooked_safety`: the guard fired mid-session.
- `crashed`: ~~nonzero exit code~~ **an exception's exit code** (`ExitStatusMapper.IsExceptionCode`: NTSTATUS `0xC0000000–0xC0FFFFFF` but `0xC000013A`, `0xE06D7363` C++, `0xE0434352` .NET, `0x80000003` breakpoint), **or** an Application Error (1000) / WER (1001) event log record ~~naming the exe~~ **that is a crash report of this game** within `[start, end + 30 s]`, **or** (beta.14) an engine's crash reporter the game started before it left.
> **Corrected 2026-10-05 (beta.14, the crash-reporter question): the event-log witness was too broad, and one engine's
> crashes had no witness at all.** A record counted when any of its strings *contained* the executable's name: on the
> owner's machine a WER 1001 `RADAR_PRE_LEAK_64` — Windows' memory-leak detector — named `witcher3.exe` and a session
> that ended with exit code 0 was stored `crashed` (2026-10-04, read from a copy of the ledger and the event log); a hang
> report, another program whose name contains this one's, or a crash of a same-image child would have done the same.
> `CrashEventMatcher` now takes a 1000 from `Application Error` only when its application name equals the executable's,
> its path (when given) is the executable's and its process id is the session's, and a 1001 from `Windows Error
> Reporting` only when it is a crash report (`APPCRASH`, `BEX`, `BEX64`, `CLR20r3`, `MoAppCrash`, `MoBEX`) whose first
> parameter is the executable's name. And Unreal handles its own crash — it starts `CrashReportClient.exe` and exits
> with code 3, no exception code and no event — so it read `normal`. The watcher's once-a-second snapshots now record
> every **on-crash** reporter a process starts (`Watch.CrashReporterCatalog`: Unreal's `CrashReportClient.exe`,
> REDengine's `CrashReporter.exe`, RE Engine's `CrashReport.exe`, BugSplat's `BsSndRpt(64).exe`) with its parent by pid,
> image and start (`CrashReporterWitness` — a pid reused by a later process is not the parent); the recorder asks at the
> end, after two more polls when the game just left. It counts (`CrashReporterRule`) when it started at least 10 s after
> the game and the game left within 60 s of it: `crashed`, with `crash_reporter=<image>` in the notes. A reporter whose
> game kept running is a note (`crash_reporter_seen=`). **Always-on handlers never count** — Unity's
> `UnityCrashHandler64.exe` and `crashpad_handler.exe` start with their game. No process is opened for any of this.
> Sessions stored before beta.14 keep their status.
- `unhooked_safety`: the guard fired mid-session. *(Since beta.14, D48: a re-scan that refused only because it could not
read the game's tree, concluded after the game itself had exited, is the game's exit instead — `normal` or `crashed` by
its exit code — with `scan_at_exit=<reason>` in `capture_notes`; `19_SAFETY` §During a session.)*
- `degraded`: Overlay self-disabled after faults, or ring layout mismatch mid-session.
- `interrupted`: Agent died mid-session; recovered from `.partial` on next start.
- A **user stop** (FR-3.6; `StopSession` over the pipe, P3 PR-1b) is `normal`: the loop ends as `SessionEndReason.StoppedByUser` at its next tick, drains once more and finalizes; the target keeps running, unhooked from here. It is the session's own stop token, not the host's cancellation — the latter leaves a `.partial`.
+31 -4
View File
@@ -197,7 +197,9 @@ CREATE TABLE sessions (
started_at INTEGER NOT NULL, ended_at INTEGER NOT NULL, duration_s REAL NOT NULL,
capture_tier INTEGER NOT NULL, -- 1 = hooked, 2 = not hooked; CHECK (capture_tier IN (1,2))
capture_notes TEXT, -- why tier degraded, late_attach, etc.
capture_notes TEXT, -- why tier degraded, late_attach, etc.; beta.14 adds crash_reporter= /
-- crash_reporter_seen= (an engine's crash reporter the game started) and
-- scan_at_exit= (D48: a re-scan that could not read as the game exited)
late_attach INTEGER NOT NULL DEFAULT 0,
telemetry_source TEXT, -- composite descriptor, e.g. 'l1+lhm+nvapi' (18_GPU_VENDOR_APIS)
overlay_build_id TEXT, -- native DLL build that produced this data
@@ -221,7 +223,8 @@ CREATE TABLE sessions (
-- presentation
api TEXT, present_mode TEXT, swap_effect TEXT,
hdr_flag TEXT NOT NULL DEFAULT 'na', hdr_source TEXT, -- tri-state, like rt/rr beside it
sync_interval_mode TEXT, -- observed vsync behavior
sync_interval_mode TEXT, -- observed vsync behavior: on|off|mixed — first written in beta.14 (0019's
-- §Sync), NULL where no present carried its arguments (OpenGL, Vulkan, Tier 2)
-- upscaling / FG (measured at tier 1)
upscaler TEXT, -- none|dlss|fsr2|fsr3|fsr4|xess|nis|unknown, and fsr since 2026-09-04 (FL_UPSCALER_FSR_UNVERSIONED; added 2026-10-04)
@@ -295,6 +298,16 @@ CREATE TABLE sessions (
game_memory_source TEXT, -- counters,ex2,ex,held,opened — the reads that answered
sensor_stats_json TEXT, -- {"gpu_temp":{"N":…,"Mean":…,"Median":…,"Min":…,"Max":…}, …}
-- schema 0019 (2026-10-06, beta.14, D49): pacing (hooked), the present arguments (Direct3D), the card's clocks and limits
-- (both tiers) and efficiency (hooked) — 03_METRICS §Pacing, §Sync, §Sensor aggregates, §Efficiency
time_below_30_pct REAL, time_below_60_pct REAL,
time_below_refresh_pct REAL, -- over presents, at display_monitor_hz; NULL without a rate
frametime_delta_mean_ms REAL, -- mean |ft[k] - ft[k-1]| over neighbouring intervals
vsync_present_pct REAL, tearing_allowed_pct REAL, -- shares of the presents that carried their arguments
avg_gpu_core_clock_mhz REAL, avg_gpu_mem_clock_mhz REAL, avg_gpu_fan_rpm REAL, max_gpu_mem_temp REAL,
power_limit_pct REAL, thermal_limit_pct REAL, -- shares of the ticks that carried reasons: NVIDIA (L3) only
app_frames_per_joule REAL, -- application FPS / average GPU board power; never displayed frames (rule 6)
-- schema 0016 (2026-09-27, beta.10): the display mode, both tiers (03_METRICS §Display mode). Milliseconds per mode,
-- each sample standing for the time until the next (100 ms hooked, 1 s at Tier 2), a pause not counted; nowindow is
-- outside every share. NULL before, on a session recovered from its .partial file, and where the loop never sampled —
@@ -362,7 +375,10 @@ CREATE TABLE sensor_blobs (
series TEXT NOT NULL, -- cpu_temp|gpu_temp|gpu_hotspot|gpu_load|gpu_power|vram_proc|vram_adapter|cpu_load|ram_mb
-- (vram_proc was listed here from 0001 and never written); since schema 0018 (beta.12,
-- D43) also game_vram_dedicated|game_vram_shared|game_ram_private|game_ram_ws|game_commit,
-- MiB — the game process's own memory (Application.Recording.SensorSeriesCatalog)
-- MiB — the game process's own memory (Application.Recording.SensorSeriesCatalog); since
-- beta.14 (D49) also gpu_core_clock|gpu_mem_clock (MHz), gpu_fan (RPM), gpu_mem_temp (°C)
-- and gpu_power_limit|gpu_thermal_limit (100 or 0 per tick, NVIDIA only) — a series name
-- needs no migration
-- cpu_load / ram_mb / cpu_temp and sessions.avg_cpu_load, avg_cpu_temp, max_cpu_temp,
-- avg_ram_mb were in schema 0001 with NO producer until 2026-09-21 (Telemetry.SystemTelemetrySource
-- on the poller's tick). Rows before that date hold NULL, which is what they measured; no migration.
@@ -415,6 +431,7 @@ switch's rule); integers are invariant-culture within an inclusive range; choice
| `ui.minimize_to_tray` | bool | `0` | | UI (PR-8) |
| `ui.hide_anticheat_hooking` | bool | `1` | | UI (beta.8, 2026-09-25): the game page of an entry the guard found anti-cheat in shows the finding in place of its Hooking card (`08_UI` §Game detail) |
| `ui.fps_decimals` | bool | `0` | | UI (beta.8, 2026-09-25): every FPS figure with two decimals ("62.40") instead of a whole number |
| `ui.hide_scrollbars` | bool | `0` | | UI (beta.14, 2026-10-05): no scroll bar drawn anywhere; every scroller still scrolls with the wheel, the keyboard and touch (`App.Services.ScrollBarHiding`, `08_UI` §Settings) |
| `ui.library_view` | choice `grid`\|`list` | `grid` | | UI (beta.11, 2026-10-03): the Games library as a grid of cards that fills the width, or as a list; written by the page's own switch, no Settings row (`08_UI` §Games) |
| `capture.background` | bool | `1` | | ~~Agent~~ nobody *(corrected 2026-10-04: no Agent code ever read it, so the watcher recorded every tracked game whatever it said; beta.12 removed its switch from Settings and reserved the key — `SettingsRegistry.CaptureBackground`)* |
| `hooking.kill_switch` | bool | `0` | | Agent (FR-2.4, since P2 PR-F) |
@@ -423,7 +440,7 @@ switch's rule); integers are invariant-culture within an inclusive range; choice
| `capture.min_session_s` | int | `30` | 5–600 | Agent, per session (FR-3.6) |
| `telemetry.interval_ms` | int | `1000` | 500–2000 | Agent, per session (FR-3.5) |
| `retention.raw_sessions_per_game` | int | `20` | 0–10000; **0 = unlimited** | Agent, per session (§Retention) |
| `update.channel` | choice | `stable` | `stable` · `beta` | UI (P4 PR-5 reads it: `beta` = GitHub pre-releases too) |
| `update.channel` | choice | ~~`stable`~~ `auto` (beta.14, D47) | `auto` · `stable` · `beta` | UI (P4 PR-5 reads it: `beta` = GitHub pre-releases too; `auto` follows the running copy, a pre-release asking for pre-releases — `11_UPDATER` §The update audit) |
| `update.auto_check` | bool | `1` | | UI (P4 PR-5: the startup silent check, `11_UPDATER` §Flow "if enabled") |
| `privacy.online_metadata` | bool | `0` | | *reserved* — no consumer and, since 2026-09-16, no toggle on Settings either: the store request it would enable has no code (CLAUDE.md rule 8), and PRIVACY_POLICY 2.2 removed the row that described it |
| `log.debug` | bool | `0` | | UI |
@@ -633,6 +650,16 @@ Sequential embedded SQL (`Migrations/0001_init.sql`, `0002_*.sql`, …), applied
> `SqliteSessionRepositoryTests.ASessionRoundTripsColumnForColumn`,
> `PartialSessionFileTests.TheGameMemoryRoundTripsAndANarrowSensorsChunkFromBeta11StillReads`.
> **`0019_pacing_sync_gpu_limits.sql` (beta.14, 2026-10-06, owner decision D49) — pacing, sync, the card, efficiency.**
> Thirteen REAL columns, ADD COLUMN only: `time_below_{30,60,refresh}_pct`, `frametime_delta_mean_ms`,
> `vsync_present_pct`, `tearing_allowed_pct`, `avg_gpu_{core,mem}_clock_mhz`, `avg_gpu_fan_rpm`, `max_gpu_mem_temp`,
> `power_limit_pct`, `thermal_limit_pct`, `app_frames_per_joule`. Written by the recorder's aggregation
> (`SessionAggregator.ApplyPacing` / `ApplySync` / `ApplyEfficiency` for a hooked session, `WithSensorAggregates` for the
> card on both tiers); `sync_interval_mode` (0001) gets its first writer beside them. A session before it reads N/A — no
> value is computed after the fact. The `.partial` needs no change: the six new sensor series are fields every sample
> already carried. `LatestVersion` is 19; `LedgerDatabaseTests.ScriptNineteenAddsThePacingAndCardColumnsAndAnEarlierSessionHasNone`,
> `SqliteSessionRepositoryTests.ASessionRoundTripsColumnForColumn`. **A beta.13 cannot open a ledger beta.14 migrated.**
> **Every open used to migrate, and one that should not have did — 2026-09-16.** The Agent's `--console sessions`,
> a verb that prints, was run against the owner's ledger while the file on disk was at schema 2 and applied 0003 and
> 0004 to it. `LedgerDatabase.OpenReadOnlyAsync` exists since that day: an existing file, `PRAGMA query_only`, no
+67 -2
View File
@@ -399,7 +399,14 @@ All screens are `Page`s registered with the navigation page provider and navigat
> per-present `vram_proc` (a held 1 Hz sample) and~~ the adapter-wide `vram_adapter` sensor ~~as two
> differently-labelled series~~ (corrected 2026-10-03: the Overlay never produced `vram_proc`, so the game's line was
> never drawn on any session; beta.12's two memory plots are described above). **Latency**: the `latency_us` blob with the stored avg / p95 lines, shown only
> when Reflex reported (`reflex_active`); otherwise the tab says so.
> when Reflex reported (`reflex_active`); otherwise the tab says so. **Since beta.14 the tab itself is shown only when one
> of the game's sessions measured latency** (`GameDetailViewModel.AnyLatency`): nothing measures Reflex today, and a tab
> that could only say "no data" was noise.
>
> **Trend, beta.14 (D49):** nine more metrics — *Time below 60 FPS %*, *Display under refresh rate %*, *Frame to frame
> ms*, *Render scale %* (`100 / upscale_ratio`), *VSync share %* and *Frames per watt* from hooked sessions; *Avg GPU core
> clock MHz*, *Max GPU memory °C* and *Held back by power limit %* from every session's telemetry. Each has its own unit
> (ms, MHz and FPS/W are new axes); a session recorded before beta.14 has no point (`TrendSeriesBuilderTests`).
>
> **Trend, corrected 2026-09-25 (beta.8, owner item 6: "does Trend really work?").** It did not, on first open: the
> view model started loading before the page existed, and a load that finished first raised `TrendPresented` to nobody
@@ -431,6 +438,29 @@ All screens are `Page`s registered with the navigation page provider and navigat
### 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.
> **beta.14 (D49): the new measurements, as cards and charts.** The cards come in three methods (`AddFrameCards`,
> `AddPacingCards`, `AddMachineCards`), every value read from the row — never recomputed — and N/A on a row written before
> beta.14:
> - **Time below 60 FPS** with *below 30* and *display under {refresh} Hz* beneath it — the refresh share named for the
> display because it is over the presents the display received (`03_METRICS` §Pacing) — and **Frame to frame**; both
> carry *(presented)* where the session's statistics are over presents, as the lows do.
> - **VSync** (*{share} of frames*, with *tearing allowed* beneath), **Ray tracing** (*{share} of frames* and rays per
> pixel — the card appears only where ray tracing was measured), **Game in focus** (foreground ticks over drain ticks)
> and **Capture quality** (gaps · lost records · faults).
> - The **1% Low** card carries *displayed: {presents' 1% low}* beneath it where frames were generated (rule 6: beside the
> game's own, never instead of it).
> - **GPU clocks** (core · memory, with fan and memory temperature beneath), **GPU held back** (power · heat, NVIDIA only)
> and **Frames per watt** (*the game's own frames, GPU power only*).
>
> Charts: **Render scale** under Distribution (`Charts/RenderScaleChart` over `RenderScaleSeries`: `100 × √(render pixels /
> output pixels)` as steps — from the `render_res` blob where the resolution varied, a flat line at the row's extent where
> it did not, and a sentence where the upscaler's parameters were never measured), and on **Sensors** the card's memory
> temperature on the temperatures plot (its own palette colour, `Chart_SensorTertiary`: no existing one was 60 apart from
> all six beside it) and a fourth plot, **Clocks and fan** — core and memory clock in MHz, the fan in RPM on the right, and
> the ticks its power limit or heat held it back shaded behind them; collapsed when the session stored none of these.
> Tests: `SessionSummaryViewModelTests` (the new cards, a row before beta.14 at N/A, the displayed low),
> `RenderScaleAndClocksTests`, `ChartMathTests`.
>
> **Built 2026-09-14 (P3 PR-6).** `Windows/SessionSummaryWindow` (a secondary `FluentWindow` with its own
> `ContentDialogHost`), opened from a Sessions-tab row (double-click or Open) and from the Dashboard's recent
> list. Stat cards read the STORED aggregates — never recomputed — with the lows labelled *(presented)* when
@@ -535,6 +565,13 @@ Session picker (2–5, cross-game allowed) → overlaid percentile curves + stat
>
> **beta.10:** three rows after Duration — *Display mode* (every share), *Window* and *Monitor* (with its refresh
> rate) — facts, not scores: no mode is better than another, so none is ever marked best, and every tier has them.
>
> **beta.14 (D49):** *Time below 60 FPS* and *Frame to frame* (lower is better), *Display under refresh rate* (lower is
> better), *VSync share* and *Render scale* (settings: no best), *Avg GPU core clock* and *Held back by power limit*
> (facts: no best), *Max GPU memory °C* (lower) and *Frames per watt* (higher). **A statistic a present-only session has
> over its presents carries *(presented)* in its cell** — the median, the lows, stutter, time below 60, frame to frame —
> beside a session whose same statistic is over the game's own frames; the best is decided on the number, never the label
> (`CompareViewModel.Row`'s label, `CompareViewModelTests`).
### Logs
Tail view of `ui-*.log` / `agent-*.log` (toggle), level filter, search (`ui:AutoSuggestBox`), pause-scroll; buttons: Open logs folder, Export bug bundle (routes to 10_LOGGING flow).
@@ -552,6 +589,16 @@ Tail view of `ui-*.log` / `agent-*.log` (toggle), level filter, search (`ui:Auto
> `PagesLoadTests`.
### Settings
> **beta.14 (owner request 2026-10-05: "an option to hide the scroll bars but still scroll").** The Window section has
> **Hide scroll bars** (`ui.hide_scrollbars`, off by default). A bar's visibility is bound inside its scroller's template,
> which no style reaches, so `Services.ScrollBarHiding` sets the scrollers themselves: one class handler on
> `ScrollViewer`'s Loaded (registered at start beside `DialogKeyboard`) reaches every scroller the App shows, those inside a
> DataGrid, a TextBox, a rendered document and a dialog included. While on, an axis that is `Auto` or `Visible` becomes
> `Hidden` — WPF's "no bar, still scrolls": wheel, keyboard and touch — and its own value is kept on it; a `Disabled` axis is
> never touched (it lays its content out at the viewport's width). The toggle applies to the open windows at once, and off
> puts every kept value back. Tests: `ScrollBarHidingTests` (on hides every bar and the wheel still scrolls; off restores
> each; a scroller that loads later follows), `SettingsViewModelTests.HidingScrollBars…`.
> **beta.11 (owner request 2026-10-03: "remove the Settings rows that have no button or similar").** Every row has a control
> now: the *Games with hooking on* card shows only while a game has hooking on (its empty sentence is gone); the *Elevation*
> card is gone and its state is the third line of *Run the agent as administrator* (its explanation a tooltip on it); the
@@ -599,7 +646,7 @@ Agent section: elevation state with a plain explanation of what elevation *optio
> `Infrastructure.Startup.RunAtLogon` — this user's `HKCU\…\Run` value, quoted executable path, never HKLM —
> and the Run entry is the truth the toggle loads from; "Minimize to tray on close" is stored now and honoured
> when the tray exists. **Privacy:** ~~`privacy.online_metadata`, off by default, with the network sentence~~ — the card is not shown since 2026-09-16 (no code makes the request; the setting stays reserved).
> **Updates:** `update.channel` is read by PR-5's updater (beta = GitHub pre-releases), and `update.auto_check` — the startup check, on by default — sits beside it. **Logging:** `log.debug` moves this app's `LoggingLevelSwitch` at
> **Updates:** `update.channel` is read by PR-5's updater (beta = GitHub pre-releases; since beta.14 *Automatic (Beta)* or *(Stable)* first, the default, following the running copy — D47), and `update.auto_check` — the startup check, on by default — sits beside it. **Logging:** `log.debug` moves this app's `LoggingLevelSwitch` at
> once; the Agent has no reader for the key yet, and the row says so. **Legal:** reopen is a "not yet" line
> until PR-9's gate exists. ~~Register/Unregister the layer, Register/Repair/Remove the task~~ — PR-8b, with the
> Agent flags they need. Tests: `SettingsViewModelTests` (seven cases), `RunAtLogonTests` (Infrastructure, under
@@ -676,6 +723,12 @@ Agent section: elevation state with a plain explanation of what elevation *optio
- Keyboard: ~~NavigationView items Ctrl+1…5; grids fully navigable; Esc closes flyouts/dialogs~~ — §Accessibility below, since P4 PR-8 (2026-09-15); this bullet named three behaviours and none of them was built or checked.
- No blocking dialogs during capture; errors surface as InfoBars/tray toasts.
- Charts and stat numbers use culture-aware formatting per active UI culture (09); colors only from theme resources or the per-theme chart palette (16 §ScottPlot).
- **The mouse wheel scrolls whatever is under the pointer (beta.14).** Every page scrolls itself
(`ScrollViewer.CanContentScroll="False"` on the `Page` — `16_WPFUI_SYNTAX` §Gotchas: until beta.14 the wheel scrolled
nothing on five pages, and the Logs tail did not follow the newest line); a scroller nested in a dialog hands the wheel
on at its ends (`ui:PassiveScrollViewer`); over a chart a plain wheel scrolls the page and **Ctrl+wheel zooms the chart**
(`Charts/ChartWheel`, every plot through `ChartTheme.Attach`) — drag still pans and double-click still resets, as
ScottPlot does. The import checklist scrolls inside its list and nowhere else, so its intro and its count stay put.
## Accessibility
@@ -743,6 +796,18 @@ palette per theme, chosen with the theme).
> primary text, ≈ 12:1) but **clipping** — the pill sat in a star column with no trimming, so a sentence-length
> qualifier overflowed the row. The qualifier text trims with an ellipsis at 260 px (the readout's tooltip carries the
> full sentence), and the row's readout column is sized to content with the game's name trimming first.
>
> **A third hole, closed 2026-10-05 (beta.14; the owner's screenshot of File ▸ Import library in the dark theme: every
> row white, its text invisible, each tick box a sliver).** A style `BasedOn="{StaticResource {x:Type DataGridRow}}"`,
> added in beta.11 to dim the rows already in the library: WPF UI 4.3.0 keys its row style `DefaultDataGridRowStyle`
> and defines no implicit one, so the lookup fell through to Aero2's row and its `SystemColors.WindowBrush` — a white no
> theme reaches, under the dark theme's white text. No `#` in our XAML, no palette badge: neither check above could see
> it, and light-theme rows read fine. The tick boxes were WPF UI's `CheckBox` (`MinWidth` 120, padding 11) in a 40 px
> column. Held three ways: `AccessibilityTests.NoStyleIsBasedOnAnImplicitStyleTheThemeDoesNotDefine` (every `BasedOn`
> type has a style in the App's dictionaries), `ImportReviewRenderTests` (the rendered dialog, both themes: every cell's
> text against the composited colour painted under it ≥ 4.5:1, each ticked box drawn whole), and
> `AccessibilityTests.NoDataGridCheckBoxColumn` (Compare's checkbox column drew an Aero2 box). Each went red on the
> unfixed XAML before it went green.
### DPI
+51 -2
View File
@@ -1,6 +1,6 @@
# 11 — Updater
Velopack, feeding from GitHub Releases of `https://github.com/poli0981/frameledger`. ~~Stable channel only in v1.~~ *(Corrected 2026-10-04: two channels since P4 PR-5 — `update.channel`, stable by default or beta, which adds pre-releases. Every release so far is a pre-release; see §Built, Channels.)*
Velopack, feeding from GitHub Releases of `https://github.com/poli0981/frameledger`. ~~Stable channel only in v1.~~ *(Corrected 2026-10-04: two channels since P4 PR-5 — `update.channel`, ~~stable by default~~ or beta, which adds pre-releases. Every release so far is a pre-release; see §Built, Channels.)* *(Corrected 2026-10-05: the default is `auto` since beta.14, which follows the running copy — §The update audit, beta.14.)*
## Flow
@@ -29,7 +29,12 @@ All update HTTP goes through one `GitHubHttpClient` (also used by rules updates)
Binaries are not code-signed (project policy). Consequences and mitigations, documented in README and the update dialog footer:
- SmartScreen warning on first run of a new version — expected; SHA-256 checksums (`SHA256SUMS.txt`) published with every release; CI prints them into release notes.
- ~~Velopack delta packages reduce download size; full package fallback automatic.~~ *(Corrected 2026-10-04: no delta has been published — `release.yml` never puts the previous release in `out/release` before `vpk pack`, so every update downloads the full package; a delta needs a `vpk download github` step first.)*
- ~~Velopack delta packages reduce download size; full package fallback automatic.~~ *(Corrected 2026-10-04: no delta has been published — `release.yml` never puts the previous release in `out/release` before `vpk pack`, so every update downloads the full package; a delta needs a `vpk download github` step first.)* **Built in beta.13:**
`release.yml` downloads the previous release into `out/release` before `vpk pack`, so a release carries
`FrameLedger.App-<version>-delta.nupkg` beside the full package; the previous full package is moved out (neither uploaded
nor checksummed) and the feed lists this build alone, as `vpk upload github` would write it. Velopack applies the delta
when the installed copy is the previous release and falls back to the full package otherwise — `0.1.0-beta.13` is the
first release with one, so beta.12 → beta.13 is the first update that can use it (owner-only: HANDOFF item 10).
- Never bypass or suppress OS warnings programmatically.
## Versioning
@@ -106,6 +111,50 @@ flow, and the tests run the flow over a fake client because nothing here may tou
longer claims the updater provides one.
- ~~Release notes are rendered as plain text, not Markdown.~~ Corrected 2026-10-03: rendered since beta.12 (Markdig; HTML off, no image fetched).
## The update audit, beta.14 (owner request 2026-10-05: "check the update logic")
No failure had been reported; the audit read the flow above against Velopack 1.2.0 and the owner's own updater log
(`%LOCALAPPDATA%\velopack\velopack_FrameLedger.App.log`, read-only) and found two defects that made the flow above
partly fiction, and six smaller ones. Each is fixed in place:
- **A copy left on its defaults never found an update.** `update.channel` defaulted to `stable` while every release is a
GitHub pre-release; the owner's log reads "No releases found" from the day their ledger (and its settings row) was reset.
**Owner decision D47:** the default is `auto`, which follows the running copy — a pre-release asks for pre-releases, a
release for releases (`Update/UpdateChannelPolicy`, SemVer's `-` before any `+`) — and a stored `stable` or `beta` is the
user's choice and wins. Settings shows *Automatic (Beta)* or *(Stable)* first. Only an explicit selection ever wrote the
row (`SettingsViewModel.Persist` is guarded while loading), so existing copies with no row move to `auto`.
- **Velopack applied a downloaded update at the next start, behind FR-12.** `VelopackApp` applies a package waiting in
the install folder on startup unless told not to (`SetAutoApplyOnStartup`, ON by default), and the startup check
downloads in the background — so the next start of `FrameLedger.exe` (the Start menu, the logon Run value, a second
click, `--diag`) applied it inside `VelopackApp.Run()`, before the single-instance claim, before FR-12 could ask
whether a session runs, and before the Agent was asked to stop; its updater killed the Agent instead (the owner's log:
"Auto apply is true, so restarting to apply update…", then "Killing process: …FrameLedger.Agent.exe"). Off now
(`VelopackHooks`, pinned by `VelopackHooksTests` through the builder's private fields); a package an earlier run left
is adopted at start — `UpdateService.AdoptPending`, from `UpdateManager.UpdatePendingRestart`, no feed request — and is
Ready or Deferred like any other.
- **An update Velopack starts itself** (the installer run over an installed copy) asks the Agent to stop first, as the
uninstaller does (`OnBeforeUpdateFastCallback`, 15 s budget, a line in `logs\update.log`). The hook runs in the
version being replaced, so it first works for the update after beta.14.
- **The apply waits while a game still has the Overlay loaded** from the install folder (`Update/PayloadInUse`: a mapped
image refuses an exclusive write — a file-system question, no process opened). The Overlay is never unloaded from a
live game (`17_HOOK_ENGINE`), so after a mid-game stop the swap would fail half way after the App had quit. Asked before
the Agent is stopped; the strip names the file.
- **An Agent waiting on the administrator prompt** (the logon task's, the admin mode) holds only its elevation marker, not
the instance lock; the apply now waits for either (`UpdateService.AgentHolds`).
- **The stop budget is the Agent's own shutdown grace and five seconds** (`IpcProtocol.AgentShutdownGrace`, 15 s, which
the Agent's host now reads too): the App waited 10 s for an Agent that took up to 15 to finalize its sessions.
- **The offer says the download Velopack will make:** the deltas from the installed version when the feed has them
(`UpdateInfo.DeltasToTarget`; 1.6 MB for beta.12 → beta.13) and the full package as the fallback — it said ~102 MB.
Velopack's own lines are in the App's log since beta.14 (`velopack: …`, `VelopackSerilogLogger`), so whether a delta
or the full package came is in the bug report too.
- **Smaller:** an `IOException` is "offline" only from the network (`HttpIOException`, a socket error) — a full disk
read as offline; the uninstaller removes the "Start FrameLedger with Windows" Run value, which named an executable it
deletes.
**What none of this reaches:** a copy still on 0.1.0-beta.13 or older runs its own code for the update to beta.14 —
stable by default, apply-at-start on. Its user chooses *Beta* in Settings ▸ Updates and updates with no game running
(the beta.14 release notes say so); everything above holds from beta.14 on.
`UpdateServiceTests` (App.Tests/Update) cover the two skips, the channels, Deferred ↔ Ready, each error row, and
the apply's three endings; `UpdateFailureMapperTests` the table; `UninstallHookTests` the hook; ~~a real feed has
not been exercised — the first tag is the measurement~~ *(corrected 2026-10-04: the feed has existed since
+31 -5
View File
@@ -44,7 +44,7 @@ Compiler/linker flags (enforced in CMake, not per-target ad hoc): `/std:c++20 /M
**No AMD or Intel GPU *telemetry* SDK is vendored.** Those vendors' sensors are covered by LibreHardwareMonitor and the DXGI/PDH baseline (`18_GPU_VENDOR_APIS`). A build that pulls in Intel IGCL or AMD ADLX material is a licensing regression, not a feature — CI greps for it. **The AMD FidelityFX ffx-api headers (MIT by exception, tag v2.3.0) ARE vendored since 2026-09-04**, for the Overlay's upscaler hook and for types only — `fl_fidelityfx_headers` above, `18_GPU_VENDOR_APIS` §AMD for the licence reading, and `license-check.ps1` §2d for the per-file gate. Intel's XeSS SDK failed the checklist and nothing of it is here.
**VERSIONINFO is mandatory** on ~~`FrameLedger.Overlay.dll` and `FrameLedger.VkLayer.dll`~~ every shipped native — the five `tools/versioninfo-check.ps1` lists (corrected 2026-10-04): real `CompanyName`, `ProductName=FrameLedger`, `FileDescription`, version. Identifiability is a requirement (`19_SAFETY`), and a CI check fails the build if the resource block is missing.
**VERSIONINFO is mandatory** on ~~`FrameLedger.Overlay.dll` and `FrameLedger.VkLayer.dll`~~ every shipped native — the five `tools/versioninfo-check.ps1` lists (corrected 2026-10-04): real `CompanyName`, `ProductName=FrameLedger`, `FileDescription`, version. Identifiability is a requirement (`19_SAFETY`), and a CI check fails the build if the resource block is missing. **Since beta.14 (D50) the managed binaries are held to the same** — §Version, *Identity*.
## Managed build & native integration
@@ -170,6 +170,29 @@ two products claiming to be one.
- `release.yml` refuses a tag whose numeric core is not the file's. Bumping the version is one edit to
`VERSION`, in the same commit as the changelog section, before the tag.
**Identity (beta.14, D50).** Every binary names the product, says what it is and carries one copyright line. Until
beta.14 only the native blocks did: the managed ones carried the SDK's defaults — the Agent's company and product read
`FrameLedger.Agent`, each library's its own assembly name — and no copyright, and those blocks are what Explorer's
*Properties ▸ Details* and Task Manager show (Task Manager lists the Agent by its file description).
| Field | Native (`src/native/CMakeLists.txt`) | Managed (`Directory.Build.props`, the two entry points' csproj) |
|---|---|---|
| CompanyName, ProductName | `FL_COMPANY_NAME`, `FL_PRODUCT_NAME` = `FrameLedger` | `Company`, `Product` = `FrameLedger` |
| LegalCopyright | `FL_COPYRIGHT` | `Copyright` — the same line, word for word |
| FileDescription | each target's `fl_add_version_resource` description | `AssemblyTitle`: `FrameLedger` (App), `FrameLedger Agent` (Agent); a library keeps its assembly name |
| Comments | the identification sentence | `Description` — the same sentence for a library, a line of its own for each entry point |
| FileVersion / ProductVersion | the numeric core, `x.y.z.0` | `x.y.z.0` / the full version (`-p:Version`, a pre-release's tag included) |
| OriginalFilename | the file's own name | the assembly's (`FrameLedger.dll`) — the apphost `.exe` carries a copy of its assembly's block |
Also stamped on every assembly: `AssemblyMetadata("RepositoryUrl")` (the SDK, from `RepositoryUrl`; the App test holds
it equal to `IssueLink.Repository`) and, when `release.yml` passes it, `FrameLedgerSourceRef` — the App csproj's alone
until beta.14, now `Directory.Build.props`', and passed to both publishes. `tools/versioninfo-check.ps1` reads all of it
from the BUILT binaries — the native five and, with `-ManagedDir`, the managed eight (`FrameLedger.exe`/`.dll`,
`FrameLedger.Agent.exe`/`.dll`, Domain, Application, Infrastructure, Shared) — and is red when a copyright differs
anywhere, when a managed `ProductVersion` is not `-ExpectedProductVersion` (required: a comparison with nothing passes
everything), or when an apphost does not carry its assembly's block; its `-SelfTest` (ten cases, nine RED, each for the
reason it names) runs first. `AssemblyIdentityTests` (App and Agent) pins the source against `FL_COPYRIGHT`.
The Velopack package version is the tag's (`vpk pack --packVersion`), and `UpdateManager.CurrentVersion` reads
the installed package's manifest — not the assembly — which is why the two are made to agree here rather than
assumed to.
@@ -179,7 +202,8 @@ assumed to.
```
cmake --build --preset x64-release
dotnet publish src/FrameLedger.App -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -p:FrameLedgerSourceRef={tag} -o out/app
dotnet publish src/FrameLedger.Agent -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -o out/app
dotnet publish src/FrameLedger.Agent -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true -p:FrameLedgerSourceRef={tag} -o out/app
vpk download github --repoUrl https://github.com/poli0981/frameledger --channel win --pre --outputDir out/release # beta.13: the previous release, for a delta
vpk pack --packId FrameLedger.App --packVersion {ver} --packDir out/app --mainExe FrameLedger.exe --packTitle FrameLedger --packAuthors FrameLedger --releaseNotes out/notes.md --outputDir out/release
```
@@ -188,7 +212,9 @@ vpk pack --packId FrameLedger.App --packVersion {ver} --packDir out/app --mainEx
> take `-p:Version=<tag>` (§Version). No `--icon`: `assets/icon.ico` does not exist, and this line named it
> for six weeks. **Since beta.12 the App also takes `-p:FrameLedgerSourceRef`** — the tag, or for a rehearsal the
> commit — stamped as assembly metadata so its links into the repository open THIS version's documents
> (`Services/RepositoryLinks`); a build without it links to `main`.
> (`Services/RepositoryLinks`); a build without it links to `main`. **Since beta.14 the Agent takes it too**, because
> `Directory.Build.props` stamps it on every assembly and both publishes build the same libraries into `out/app` (§Version,
> *Identity*).
>
> **The package id is `FrameLedger.App`, and this line said `FrameLedger` until 2026-09-14 — which would have
> deleted every user's ledger on uninstall.** Velopack installs into `%LOCALAPPDATA%\<packId>` and removes that
@@ -223,7 +249,7 @@ vpk pack --packId FrameLedger.App --packVersion {ver} --packDir out/app --mainEx
- No trimming (WPF + reflection), no NativeAOT (WPF unsupported), **no obfuscation** (GPLv3 policy, and `19_SAFETY` forbids making our binaries harder to identify).
- `SatelliteResourceLanguages=en;vi;ja`. ~~Expected package ≈ 95–130 MB self-contained.~~ **Measured 2026-09-14 (P4 PR-5): the published tree is 250 MB in 362 files** (App + Agent, self-contained, ReadyToRun roughly doubles the IL). `vpk pack` 1.2.0 over that tree, run by hand the same day with the workflow's arguments: `FrameLedger.App-win-Setup.exe` **104 MB**, the full `.nupkg` and the portable zip 100 MB each, plus `releases.win.json` / `RELEASES` / `assets.win.json`; vpk's own pre-process step verified `VelopackApp.Run()` in `FrameLedger.App.Program::Main()`. **From the hosted runner on the first tag (2026-09-16, `v0.1.0-beta.1`):** the tree 252 MB, `Setup.exe` 110 MB, the nupkg and the zip 105 MB — the same shape, a few MB heavier for two more days of code.
- Velopack hooks (**built 2026-09-14, P4 PR-5**: `App/Update/VelopackHooks`, wired in the hand-written `Program.Main` before any window). **Install registers nothing** — the first-run flow is the offer (Agent setup), and the layer follows the ledger (§The Vulkan layer is not registered at install time); this line used to say "offer Agent setup + Vulkan layer registration", and the second half was the thing the section below forbids. Uninstall runs `UninstallHook`: `Shutdown` to a running Agent over the pipe (best effort, it holds the install directory), unregister the layer (HKCU), remove the logon task, then **ask** about the data folder — deleted on Yes only, never when it and the install overlap (`AreSeparate`), and a question unanswered inside Velopack's 30 s callback budget keeps it.
- Velopack hooks (**built 2026-09-14, P4 PR-5**: `App/Update/VelopackHooks`, wired in the hand-written `Program.Main` before any window; since beta.14 Velopack's apply-at-start is off and an update it starts itself stops the Agent first — `11_UPDATER` §The update audit). **Install registers nothing** — the first-run flow is the offer (Agent setup), and the layer follows the ledger (§The Vulkan layer is not registered at install time); this line used to say "offer Agent setup + Vulkan layer registration", and the second half was the thing the section below forbids. Uninstall runs `UninstallHook`: `Shutdown` to a running Agent over the pipe (best effort, it holds the install directory), unregister the layer (HKCU), remove the logon task, remove the *Start FrameLedger with Windows* Run value (beta.14 — it named the executable being deleted), then **ask** about the data folder — deleted on Yes only, never when it and the install overlap (`AreSeparate`), and a question unanswered inside Velopack's 30 s callback budget keeps it.
## Release-time token substitution
@@ -255,7 +281,7 @@ document the app displays for acceptance (FR-11) is a defect, not a template.
7. `tools/coverage-gate.ps1` — reads this run's cobertura reports; self-arming, and armed today for
`FrameLedger.Domain` and `FrameLedger.Application`
8. `tools/rules-validate.ps1` (schema + `anticheat` block sanity — a malformed or empty blocklist is a safety bug)
9. `tools/versioninfo-check.ps1` — reads the built binary, because what ships is what an anti-cheat vendor sees; since P4 PR-5 it also compares every `FileVersion` against the `VERSION` file (§Version)
9. `tools/versioninfo-check.ps1` — reads the built binary, because what ships is what an anti-cheat vendor sees; since P4 PR-5 it also compares every `FileVersion` against the `VERSION` file (§Version); **since beta.14 (D50) both halves run — the self-test, then the native five and the managed eight from the App's and the Agent's build output** (`-ManagedDir`, `-ExpectedProductVersion` = `VERSION`), one copyright across all of them (§Version, *Identity*). Under `-SkipNative` the managed half still runs
10. `tools/chokepoint-check.ps1` — injection and evasion primitives confined to one file, native **and** managed, plus the `FL_GUARD_TESTABLE` symbol check against the shipped artifacts
11. **`tools/hookinventory-check.ps1`** — three passes: A resolves every vendor symbol the Overlay names against `docs/vendor-exports.json`, B sweeps for stray literals, C reads the BUILT Overlay's import table and asserts it imports no vendor module. C skips loudly under `-SkipNative`. **Missing from this list until 2026-08-28**, which is §R10 happening again
12. **`tools/package-closure-check.ps1`** — both halves: the self-test (5 cases, 4 of which must go RED) **and** a live pass over this repository. It walks the transitive `ProjectReference` closure of the two publish roots below and fails on anything outside the allowlist, naming the reference edge. `FrameLedger.CaptureHost` is an injecting entry point kept out of the package by construction, and `20_OPEN_QUESTIONS` §S27 is closed on exactly that basis
+9 -1
View File
@@ -135,7 +135,15 @@ FrameLedger uses the **`poli0981/.github` ops repo** where its templates fit, an
- **The published tree asserted by name**: `FrameLedger.exe`, `FrameLedger.Agent.exe`, the ~~four~~ five shipped natives
`versioninfo-check` lists (`FrameLedger.ProcessStats.dll` since beta.12 — corrected 2026-10-04), `rules/detection-rules.json`; `FrameLedger.CaptureHost.exe` absent (`12_BUILD`:
exactly two roots — `package-closure-check` proves it statically, this reads the directory); `versioninfo-check`
run again over `out/app`, because a `.targets`-staged DLL that failed to copy is a warning to `dotnet publish`.
run again over `out/app`, because a `.targets`-staged DLL that failed to copy is a warning to `dotnet publish` —
**since beta.14 (D50) with its managed half** (`-ManagedDir out/app -ExpectedProductVersion <tag>`): the eight managed
binaries name FrameLedger, carry the tag's full version and the native binaries' copyright line (`12_BUILD` §Version,
*Identity*). Both publishes take `-p:FrameLedgerSourceRef` since beta.14.
- **since beta.13, `vpk download github --pre` first**, so `vpk pack` finds the previous release's full package in
`out/release` and writes a delta; after the pack, what `assets.win.json` names is kept and the rest (the previous full
package) moves to `out/previous`, the feed and `RELEASES` are filtered to this build, and a downloaded previous package
with no delta beside it fails the job. A failed download is a warning: the release is full-only, as every one before it
was (`11_UPDATER` §Built).
- `vpk pack --packId FrameLedger.App` (the `vpk` tool pinned to the library's 1.2.0) with the release notes;
`FrameLedger.App-win-Setup.exe` must come out, because README §Install names it. **Not `--packId FrameLedger`**:
Velopack installs into and uninstalls `%LOCALAPPDATA%\<packId>`, which with that id is the data folder
+27 -1
View File
@@ -16,6 +16,13 @@ The anti-cheat guard is the one component where a bug can cost someone an accoun
- **Absence-of-override test:** no code path may reach the injection primitive without a passing guard result. The mechanism previously described here — a `sealed` token type "only the guard can produce" — does not work and was disproved by compiling (`20_OPEN_QUESTIONS` §S8: C# accessibility flows inward, `CS0122`). The replacement is structural: the guard **owns the chokepoint** and calls the primitive itself, the primitive has internal linkage in the guard's own translation unit so no other TU has a symbol to call, and a build-time check asserts that nothing else references it. A token that escapes can be ignored; a symbol that does not exist cannot.
- Static pre-scan: a game directory containing `EasyAntiCheat/` renders `hook_enabled` un-settable; API-level attempt to set it is rejected — including via `SetWatchlist`, which no longer carries hooking state at all (`07_IPC` §The pipe is not a trust boundary). ~~**The toggle half needs persistence and is not built yet**~~ **built in P2/P3**: `SqliteGameConsentStore.RecordGuardBlockAsync` forces `hook_enabled = 0`, `AgentCommandHandler.SetHookEnabledAsync` re-runs the pre-scan and answers `Refused`, and `GameDetailViewModel` disables the toggle on a blocked row (corrected 2026-09-21; since 2026-09-22 a finding at a session's start or at the re-scan writes the same block — `CaptureSessionTests`); the scan itself is ctest `fl_prescan`, whose matrix is mostly fail-closed: a listing that FAILED, one that was TRUNCATED, a directory that could not be established, unusable rules, and a missing evidence source must each be *undetermined*, never clean. Two cases exist only to stop the rest passing vacuously — a genuinely clean directory must be **allowed**, and a name matching the wrong group (a directory named like a `files` entry) must **not** fire. One case removes a family from the rules and asserts the hit disappears, which is what proves there is a single matcher rather than a second one that happens to agree.
> **D48 (beta.14):** the module check's one re-read is held both ways in ctest `fl_guard` `[D48]` — a member still
> loading reads clean on the re-read (one pause, two snapshots); one still unreadable refuses; one that exited drops out of
> the fresh set; a target that exited refuses; `ACCESS_DENIED` is never retried; a finding refuses at once and a finding
> the re-read sees refuses — and against the real source (`[live]`: a process created suspended and a pid with no process
> answer `kRetry`). The managed half — a refused re-scan of a game that has exited ends as its exit, never for a finding —
> is `CaptureSessionTests` and `SessionRecorderTests`.
## Native unit tests (Catch2)
- **Ring buffer:** SPSC correctness under a hammering writer thread; seqlock torn-read detection; wrap and overwrite-oldest semantics; power-of-two capacity assumptions. Include the **one-full-lap case**: a reader stalled exactly `capacity` records must not validate a different frame as unchanged (this is what the never-reset `seq` counter defends, `07_IPC` §Protocol rules).
@@ -44,6 +51,24 @@ The anti-cheat guard is the one component where a bug can cost someone an accoun
- Blob codecs round-trip for every series in `frame_blobs` (NaN forbidden — assert), including the two-pair `render_res` encoding and the three-bit `rt_flags` byte. SQLite migrations apply cleanly from an empty file to the current schema, and re-applying is a no-op. (There is no v1→v2 upgrade to test — `06_DATA_MODEL` §Migrations.)
- IPC pipe: framing, split reads, oversize rejection, unknown fields/types ignored, protocol mismatch.
### What the App draws (beta.14)
A page or dialog that only *loads* has proved nothing about how it looks: `PagesLoadTests` counted the import list's
rows while every row was white text on white in the dark theme (`08_UI` §Contrast). The rendered checks run on the one
STA thread with the App's three dictionaries (`PagesLoadTests.OnStaAsync`) and look at the result: `Visuals` lays a
control out at a window's size, pumps the dispatcher (a `NavigationViewContentPresenter`'s navigation), swaps the theme
dictionary for one check and puts Dark back, and composites every Border and Panel background between a text and the
window into the colour actually painted under it; `Wcag` is the arithmetic. `ImportReviewRenderTests` measures each text
cell against that colour in both themes and counts the accent pixels of each ticked box in a `RenderTargetBitmap`; the
paging checks navigate a real page in WPF UI's presenter and send it the wheel. Each was run red against the unfixed XAML
first — a rendered check that cannot fail is the counted-rows check again.
**A test that sends input must also say which keys are held.** `Keyboard.Modifiers` is the machine's real keyboard, read
from any thread (a fresh background thread's `GetKeyState` reports the machine's NumLock — measured 2026-10-06), so a
wheel test that read it held whatever key a person pressed while the gate ran: `ChartWheelTests`' plain half went red once
on the developer's machine and never on CI. The handlers read `ChartWheel.CurrentModifiers`, which the test sets inside its
own work item on the STA thread and puts back — and with the keys a parameter, the Ctrl half is driven end to end too.
## Integration tests (CI-runnable, no game, no anti-cheat surface)
`hook-harness` is what makes this architecture testable without touching a real title:
@@ -131,7 +156,8 @@ that it was checked against anything.
| Mode | launch mode · attach mode · mid-session settings change |
| Safety | game with anti-cheat → toggle disabled · simulated late AC load → unhook · double-crash → auto-disable |
| Tier | forced Tier 2 (records duration, available sensors and the reason — and nothing else) · Tier 1 → Tier 2 degradation notice |
| Update | Velopack delta; update deferred while a game is hooked (FR-12) — *a delta needs a previous release, so this row is reachable from the second release, not the first* *(corrected 2026-10-04: no release has carried a delta — `release.yml` never fetches the previous release before `vpk pack`, `11_UPDATER` §Built — so the update leg is a full package)* |
| Update | Velopack delta; update deferred while a game is hooked (FR-12) — *a delta needs a previous release, so this row is reachable from the second release, not the first* *(corrected 2026-10-04: no release has carried a delta — `release.yml` never fetches the previous release before `vpk pack`, `11_UPDATER` §Built — so the update leg is a full package; **since beta.13** a release carries a delta against the previous one, and the first
update that can use it is beta.12 → beta.13 — HANDOFF owner-only item 10)* |
## Release smoke
+30 -2
View File
@@ -132,9 +132,9 @@ Code-behind wires services once: `navigationService.SetNavigationControl(RootNav
| Busy | `ui:ProgressRing` | |
| Contextual popup | `ui:Flyout` | Popup hand-rolling |
| Hyperlink-ish | `ui:HyperlinkButton`, `ui:Anchor` | |
| Grid of records | native `DataGrid` (WPF UI restyles it) | third-party grids |
| Grid of records | native `DataGrid` (WPF UI restyles it — through the grid's own `RowStyle`/`CellStyle`/`ColumnHeaderStyle` setters, so a local one is based on WPF UI's keyed style: §Gotchas, added 2026-10-05) | third-party grids |
Native `Menu`, `TabControl`, `ComboBox`, `Slider`, `ListView` are fine — the `ControlsDictionary` restyles standard WPF controls to Fluent automatically.
Native `Menu`, `TabControl`, `ComboBox`, `Slider`~~, `ListView`~~ are fine — the `ControlsDictionary` restyles standard WPF controls to Fluent automatically. *(Corrected 2026-10-05: 4.3.0 has no implicit style for the native `ListView`, `ListViewItem` or `GridViewColumnHeader` — only `ui:ListView` is restyled — nor for `DataGridRow`, `DataGridCell`, `DataGridColumnHeader` or `FlowDocumentScrollViewer`; read from the loaded `ControlsDictionary`.)*
## Icons
@@ -227,6 +227,34 @@ On startup and on `ApplicationThemeManager.Changed`: for every live plot set fig
bar with no exit, which is exactly how the safety notices shipped (2026-09-14). `Styles/FrameLedger.xaml` carries
the upstream template plus one presenter column; `PagesLoadTests.TheInfoBarTemplateRendersItsContent` renders both
templates and turns red when upstream gains a presenter, which is when the copy comes out.
- [ ] **WPF UI 4.3.0 keys its DataGrid parts' styles and defines no implicit one** (`DefaultDataGridRowStyle`,
`DefaultDataGridCellStyle`, `DefaultDataGridColumnHeaderStyle`, handed to the grid by its implicit `DataGrid` style's
`RowStyle`/`CellStyle`/`ColumnHeaderStyle` setters). A local `RowStyle` replaces WPF UI's; based on
`{StaticResource {x:Type DataGridRow}}` it falls through to Aero2's row, whose `SystemColors.WindowBrush` no theme
reaches: the import list was white text on white in the dark theme (owner's screenshot, beta.14). Base it on
`DefaultDataGridRowStyle`. `AccessibilityTests.NoStyleIsBasedOnAnImplicitStyleTheThemeDoesNotDefine` refuses any
`BasedOn` a type the App's dictionaries hold no style for, and `ImportReviewRenderTests` measures the rendered rows.
- [ ] **WPF UI's `CheckBox` is `MinWidth` 120 with an 11 px padding**: in a narrow grid column it draws a sliver of the box.
`MinWidth="0" Padding="0"` there. A `DataGridCheckBoxColumn` uses WPF's own element style, an Aero2 box — use a template
column (`AccessibilityTests.NoDataGridCheckBoxColumn`).
- [ ] **Every page sets `ScrollViewer.CanContentScroll="False"`.** `NavigationViewContentPresenter` changes that property's
default to true for `Page` and, on each navigation, wraps a page that keeps it in a `DynamicScrollViewer`. A page with
its own root `ScrollViewer` inside that wrapper has infinite height, nothing to scroll — and a stock `ScrollViewer`
marks every wheel handled even then, so the wheel scrolled nothing on five pages until beta.14 (owner: "I have to drag
the scroll bar"); the Logs tail grew to hold every line and never followed the end.
`AccessibilityTests.EveryPageOptsOutOfTheDynamicScrollViewer`, `PagesLoadTests.ANavigatedPageIsNot…`.
- [ ] **A stock `ScrollViewer` nested in a scroller takes the wheel at its ends too.** Inside a dialog use
`ui:PassiveScrollViewer`, which hands the wheel on when it cannot scroll (`AccessibilityTests.NoPlainScrollViewerInsideADialog`).
A `ContentDialog` whose content should not scroll as a whole sets `ScrollViewer.VerticalScrollBarVisibility="Disabled"`
on the dialog: its content row then has the window's height, and a `*` row inside it can hold a list that scrolls alone
(`ImportReviewPrompt`).
- [ ] **ScottPlot 5 zooms on every wheel and never marks it handled.** Without `Charts/ChartWheel` a wheel over a chart
zoomed it and scrolled the page at once; a plain wheel is the page's, Ctrl+wheel the chart's, for every plot that
`ChartTheme.Attach` registers.
- [ ] **A scroll bar's visibility is bound inside its scroller's template** (`ComputedVerticalScrollBarVisibility`), so a style
on `ScrollBar` or `ui:DynamicScrollBar` cannot hide it. Set the scroller's own `ScrollBarVisibility` to `Hidden` — no
bar, and the wheel, the keyboard and touch still scroll (`ui:PassiveScrollViewer` treats only `Disabled` as "cannot
scroll") — as `Services.ScrollBarHiding` does for `ui.hide_scrollbars` (beta.14).
- [ ] **No dialog in 4.3.0 closes on Esc.** Neither `ContentDialog.cs` nor `MessageBox.cs` at the 4.3.0 tag handles a
key (read 2026-09-15), and `ContentDialog.CloseButtonText` DEFAULTS to "Close" — an empty string is how a dialog
says it has no Close button. `MessageBox.Close()` is `[Obsolete("Use Close with MessageBoxResult instead")]` while no
+28 -1
View File
@@ -22,7 +22,7 @@ These are permanently out of scope. A PR implementing any of them is rejected re
- Reading or writing game memory outside the arguments of APIs we hooked
- Kernel drivers of our own
The DLL ships with its real filename, a populated VERSIONINFO block (`CompanyName`, `ProductName=FrameLedger`, version), and named kernel objects that clearly say `FrameLedger`. Being identifiable is a feature.
The DLL ships with its real filename, a populated VERSIONINFO block (`CompanyName`, `ProductName=FrameLedger`, version), and named kernel objects that clearly say `FrameLedger`. Being identifiable is a feature. Since beta.14 (D50) the Agent — the process that injects — and the App say the same about themselves: `FrameLedger` as company and product, *FrameLedger Agent* as the Agent's description, the native binaries' copyright line (`12_BUILD` §Version, *Identity*; `tools/versioninfo-check.ps1` reads both kinds).
## The anti-cheat guard (hard gate)
@@ -51,6 +51,19 @@ Implemented in `FrameLedger.Injector` and reached from managed code through a th
> handle rights above are confirmed sufficient for every target this call can
> legitimately reach.
>
> **Amended 2026-10-05 (owner decision D48, beta.14): one re-read, never a pass.** A member of the scan set that
> is still being created answers `ERROR_PARTIAL_COPY` (its loader has not built a module list), and one that exited
> between the snapshot and the open answers `ERROR_INVALID_PARAMETER`. Both refused the whole session — and at the
> 30 s re-scan an engine's crash reporter starting as its game died, or any helper started a moment before the scan,
> turned an ordinary exit into a "safety" unhook, which ends a user-mode exception's trial for good. Such a member
> (`Collected::kRetry`, `fl_guard.h`) is now read once more: the pass finishes (a finding in any member still refuses
> at once), waits `kScanRetryPauseMs` (250 ms), takes a **fresh** scan set and scans it whole. A member still unreadable
> then refuses `kProcessUnreadable`, as before; one that has gone is not in the new set; a target that has gone leaves
> no set, which refuses `kProcessTreeUnavailable`. **`ERROR_ACCESS_DENIED` — a protected process — is never retried**,
> and no other answer of any source is. The sentence above stands: every failure still means REFUSE; what changed is
> how many times "still loading" is asked before it counts as one. ctest `fl_guard` `[D48]` holds both directions,
> against fakes and against the real source (a process created suspended, a pid with no process).
>
> **Launch mode (2026-09-06, P1 item 2) does not weaken this.** `FlGuardedInjectWhenReady` polls
> the same enumeration to learn *when* the launched target has mapped a presentation runtime, and a
> failing enumeration there means "not yet" — the poll continues. That is not a pass: the poll
@@ -836,6 +849,15 @@ checked stays untrusted and refuses — that direction is deliberate.
Re-run **every pre-injection check** every 30 s, for **every Tier-1 session —
injected or layered**.
> **A refused re-scan of a game that has already exited is that exit (owner decision D48, beta.14).** When the re-scan
> refuses only because it could not read the game's tree (`ProcessUnreadable`, `ModuleScanFailed`,
> `ProcessTreeUnavailable` — never a finding) and the game itself has exited by the time the session concludes, the
> session ends as `TargetExited`, its exit code deciding normal or crashed, with `scan_at_exit=<reason>` in its notes
> (`Application.Capture.ExitScanRelabel`). The stop was still published to the Overlay — the game it would have stopped
> is gone. A finding, any refusal while the game still runs, and a refusal of another check (drivers, services, the
> pre-scan) are a safety unhook exactly as before. `CaptureSessionTests.AnUnreadableRescanOfAGameThatHasExited…` and
> its three refusing neighbours.
> **This said "both the module scan and the driver scan" until 2026-08-05, and
> the loop runs four checks, not two** (`20_OPEN_QUESTIONS` §S23-4).
> `FlGuardEvaluate` → `EvaluateImpl` runs `CheckDrivers`, `CheckServices`,
@@ -1078,6 +1100,11 @@ 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).*
- **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,
the D33 lapse and D38's trial as `crashed` always has: an Unreal game that crashes under a user-mode exception ends it
now, where before beta.14 the crash went unseen; a leak report no longer ends one.
- The Overlay DLL self-disables after 3 faults in hook bodies (`17_HOOK_ENGINE` §Fault policy) and reports it.
- Every hooked session writes a breadcrumb file before injection~~; if the game process dies before the first frame record arrives, the next run is recorded as suspect~~ *(corrected 2026-10-04: no "suspect" mark exists; the breadcrumb is the `.partial` file, and an early death counts toward the two-within-60-s auto-disable above)*.
+120 -3
View File
@@ -1804,7 +1804,7 @@ library and the import, PR-4 delete sessions, the charts across sessions and the
**Owner-only, added to the list below:** item 8.
## **START HERE** — 2026-10-04, the beta.12 train: the game's own memory, rendered documents, a user guide, the legal split
## ~~**START HERE**~~ — 2026-10-04, the beta.12 train: the game's own memory, rendered documents, a user guide, the legal split *(struck the same day: the head is §beta.13 below)*
*Status is `CHANGELOG.md` `[0.1.0-beta.12]`; this is what no other file carries. The approved plan was eight PRs: PR-0 the
recorder test that went red on a loaded runner, PR-1 `NOTICE` and the licence header (D45), PR-2 the game's memory
@@ -1836,7 +1836,8 @@ PR-7 the release.*
in the local gate (`LhmRealHardwareTests` beside `PrivilegeFootprintTests`); the Agent's own read was already behind a
catch. The two test classes share a collection now.
- **A test reading resource text outside the culture collection** races a class that flips `Strings.Culture`; a class
that adds many flips (`GameMemoryTextTests`) makes it likelier. `GamesViewModelTests` moved in; the rest are a chip.
that adds many flips (`GameMemoryTextTests`) makes it likelier. `GamesViewModelTests` moved in; the rest are a chip. *(Ended in beta.13: the
collection runs alone.)*
- **`ShmDrainIntegrationTests.AnUnhookRequestStops…` failed once on CI at the injection step** (≈1 s, `IsAllowed`
false) and passed on the re-run; it passed on the PR before. A flake to watch, not yet a fix.
- **Markdig follows the table spec strictly**: a line without cells between a table's rows ends the table, and GitHub
@@ -1863,10 +1864,109 @@ PR-7 the release.*
- **The audits (PR-6) found code gaps the docs had been describing as built**, each left for its own PR and named
here so it is not rediscovered: L1 telemetry is never pointed at the game's adapter (`SelectAdapter` has no caller,
`18_GPU_VENDOR_APIS`); a machine-wide service refusal still says "detected in this game" (§S23-3, 🔴); no release
has carried a Velopack delta (`release.yml` never fetches the previous release); there is no rules feed (§S20).
has carried a Velopack delta (`release.yml` never fetches the previous release); there is no rules feed (§S20). *(Three of the four closed in
beta.13 — §S23-3, the adapter, the delta; the rules feed stays.)*
**Owner-only, added to the list below:** item 9.
## ~~**START HERE**~~ — 2026-10-04, the beta.13 train: the four follow-ups the beta.12 audit left *(struck 2026-10-06: the head is §beta.14 below)*
*Status is `CHANGELOG.md` `[0.1.0-beta.13]`; this is what no other file carries. The owner asked (2026-10-04) for the
four chips the beta.12 documentation audit had left — §S23-3's wording, the App tests' culture races, L1's adapter, the
Velopack delta — then a release and the session closed. Two PRs: PR-1 the three code changes, PR-2 the release with the
delta in `release.yml`.*
**No new owner decision.** The choices below follow rules already written: a figure from the wrong graphics card is worse
than N/A (`FlShmHandshake.AdapterLuid`'s own comment), and a finding on the PC is not a finding in the game (§S23-3,
2026-09-06).
**Traps met on the way:**
- **Pointing L1 at the game's adapter changes nothing visible on its own**: `CompositeTelemetrySource` merges L3 > L2 >
L1 per field, and L2 (LibreHardwareMonitor's first GPU node) and L3 (NVAPI's first physical GPU) read their own card.
Every layer has to agree on the card — L1 by LUID (`IGpuAdapterSelector`), the others by the adapter's vendor
(`IGpuVendorFollower`), and L3 says nothing for an AMD or Intel adapter. Two GPUs of one vendor stay first-found.
- **A `CaptureRefused`'s `reason` is the session's end reason** (`RefusedByGuard`), not the guard's: the App could not
tell a service from a module until the events carried `guardReason`. A `RefusedAck`'s `Reason`, by contrast, IS the
guard's — two "reason" fields one pipe apart that mean different things.
- **A collection definition must be public** (xUnit1027), which CA1515 then flags in a test project that is an exe — the
suppression carries the reason. `TestContext.Current.TestCollection.TestCollectionClassName` proves the definition
bound, so a definition xUnit did not find fails a test instead of bringing the races back silently.
- **`vpk download github --pre` puts the previous release's full package in `out/release`**: `vpk pack` needs it there to
write a delta, and nothing else may ship it — `assets.win.json` names what this pack built, the rest moves to
`out/previous`, and the feed and `RELEASES` are filtered to this build, as `vpk upload github` writes them.
- **A 120 ms wall-clock ceiling races the second scan on a loaded runner**: the release rehearsal failed on
`CaptureSessionTests.AGuardThatThrowsMidSessionKeepsTheRecordsItAlreadyDrained`, which ended as `Running` before the
guard's second evaluation threw — the class beta.12's PR-0 fixed in the recorder tests. The four tests whose ending is a
scan, a throw, the kill switch or an exit take `EndsOnItsOwn` (a 30 s safety net); a test that EXPECTS `Running` keeps
the short ceiling, because that ceiling is its ending.
- **The beta.12 traps about the culture race and the four code gaps are closed here** (the rules feed stays open, §S20).
**Owner-only, added to the list below:** item 10.
## **START HERE** — 2026-10-06, the beta.14 train: contrast and the wheel, the update audit, crash reporters, assembly metadata, new measurements
*Status is `CHANGELOG.md` `[0.1.0-beta.14]`; this is what no other file carries. The owner's list (2026-10-05, with a
screenshot of the import list in the dark theme): the contrast, a review of the update logic, games recorded as crashed
by an engine's crash reporter (prevention; SILENT HILL 2 as the example), assembly metadata, new metrics and charts, and
a wheel that scrolls with an option to hide the scroll bars. Nine stacked PRs — PR-1 contrast and the wheel, PR-2 the
scroll-bar option, PR-3 the update audit, PR-4 the guard's retry, PR-5 crash classification, PR-6 assembly metadata,
PR-7 the metrics' Agent half (schema 0019), PR-8 their App half, PR-9 the release — plus one test fix (#268).*
**Decisions (owner, 2026-10-05, asked before the plan — do not re-ask):**
- **D47 — the update channel follows the running copy.** `update.channel` gained `auto`, the default: a pre-release
copy asks for pre-releases, a stable one for stable; an explicit *Stable* or *Beta* in Settings wins
(`Update/UpdateChannelPolicy`). Until beta.14 the default was `stable` and every release is a pre-release, so an
installed copy never found an update (the owner's own `velopack` log: "No releases found").
- **D48 — the guard's narrow fix, both halves.** A scan-set member still loading (`ERROR_PARTIAL_COPY`) or already gone
is read again once, ~250 ms later, before the guard refuses; still unreadable still refuses, and `ACCESS_DENIED` is
never retried. A refused re-scan for a could-not-read reason (`ProcessUnreadable`, `ModuleScanFailed`,
`ProcessTreeUnavailable` — never a finding) when the game itself had exited ends as the game's exit
(`ExitScanRelabel`, the note `scan_at_exit=`). CLAUDE.md rule 2 is unchanged: a failure still refuses.
- **D49 — all four metric groups.** The render scale over time; time below 30 / 60 / the refresh rate and frame to frame;
the facts the row stored and nothing showed (VSync and tearing, ray tracing's share, focus, capture quality, the
displayed 1 % low); the card's clocks, fan, memory temperature, limits, and frames per watt.
- **D50 — the managed binaries' identity.** Company and Product "FrameLedger", the copyright the native `FL_COPYRIGHT`
word for word; `versioninfo-check` reads both kinds and compares them.
**Traps met on the way:**
- **WPF UI 4.3.0 keys its DataGrid styles** (`DefaultDataGridRowStyle`) and defines no implicit row style: a `RowStyle`
`BasedOn="{StaticResource {x:Type DataGridRow}}"` falls through to Aero2's row and `SystemColors.WindowBrush` — white
under the dark theme's white text. Its `CheckBox` has `MinWidth` 120. Both in `16_WPFUI_SYNTAX` §Gotchas now.
- **`NavigationViewContentPresenter` makes a `Page`'s `CanContentScroll` true and wraps it in its own scroller**; a page's
own root `ScrollViewer` is then measured unbounded, has nothing to scroll, and still marks every wheel handled. ScottPlot
never marks the wheel handled.
- **`Keyboard.Modifiers` is the machine's real keyboard, from any thread** (a fresh background thread's `GetKeyState`
reported the machine's NumLock): a local gate went red on the chart-wheel test while a Ctrl was held. A test that sends
input sets the keys itself (`ChartWheel.CurrentModifiers`, #268).
- **Velopack 1.2.0 applies a downloaded update at the next start by default** (`SetAutoApplyOnStartup`), before FR-12's
check and with the Agent killed; `VelopackHooks` turns it off and a pending package is adopted instead.
- **The plain "time below X" rule fabricates drops**: a game capped at 60 read 50.0 % "below 60" from present-timing
jitter (measured on a copy of the owner's ledger); a rolling mean does not help. The margins of `FramePacing` and what
they cost are in `03_METRICS` §Pacing.
- **A WER 1001 is not a crash by its number**: `RADAR_PRE_LEAK_64` is Windows' memory-leak detector, and a substring match
on the executable's name stored an ordinary The Witcher 3 session as crashed. `CrashEventMatcher` reads the event name
and the typed process id.
- **No chart palette colour was 60 apart from all six on the temperatures plot** — `Chart_Histogram` equals
`Chart_Native` — so the seventh line got a key of its own (`Chart_SensorTertiary`); `ChartMathTests` caught it.
- **Meziantou's MA0051 (60 lines, 40 statements) split** `FrameTimeSeries`'s two builders into one `Kept` accumulator,
the summary's cards into three methods and Compare's rows into two; `dotnet format` wants one property per line in an
object initializer, even in a test.
- **The `fl_ring` anti-vacuity flake** (§Traps) fired on #264's CI and passed on the re-run, as written.
- **`git describe` is 31 characters ten commits after a tag** (`v0.1.0-beta.13-10-g15ec7c1c5fd4`) — the most
`FlShmHandshake.buildId` holds. `ShmHandshakeValidatorTests` appended `"x"` to the id for its mismatch case, the helper
cut it back to 31, and the check read `Ok`: red from the tenth commit after every tag, locally and on CI (#273 uses
another id of the same length).
- **"The job was not acquired by Runner of type hosted even after multiple attempts"**: with seven CI runs in flight a
queued Windows job was cancelled after ~15 minutes, twice, without a step having run. Nothing in the code; re-run the
job when fewer runs are queued.
- **The Privacy Policy 2.7 holds the merge of PR-5 and PR-7**: their wording (§4 the crash reports and the programs a
game starts, §1 the card's sensor series) is the owner's to approve before they land, as the plan said.
**Owner-only, added to the list below:** item 11.
## Owner-only — no PR can close these
1. **§S23-2 — branch protection.** `Rules / validate` is not a required status check on
@@ -1925,6 +2025,23 @@ PR-7 the release.*
*View on GitHub* opening the `v0.1.0-beta.12` tag. (d) The `ja` strings marked `review` (the memory labels, the
About window, the first-start summary). (e) `docs/LIST_GAME_TESTED.md` is as of beta.10: refresh it from a copy of
the ledger, with the games' memory figures, and approve it before it is committed (D35).
10. **beta.13 on real hardware.** (a) **The first delta:** update an installed `0.1.0-beta.12` through Help ▸ Check for
updates — the download is a fraction of the full ~107 MB, and the App comes back as beta.13; if it downloaded the
full package instead, say so (Velopack falls back silently). (b) **On this PC:** with an Easy Anti-Cheat service
running for any game, start a hook-enabled game — the notice says the anti-cheat is running on this PC, not in
the game. (c) **Two graphics cards**, if a machine with them is at hand: the Sensors chart's GPU figures are the
game's card. (d) The `ja` review of the new safety strings, with the others still marked for it.
11. **beta.14 on real hardware.** (a) **The update from beta.13:** choose *Beta* in Settings ▸ Updates, Help ▸ Check for
updates, then *Restart to update* with no game running; Settings then reads *Automatic (Beta)*. The `velopack:` lines
in `ui-*.log` say what was downloaded — a delta of about 2 MB; say so if it was the full package. (b) **Explorer ▸
Properties ▸ Details** of `FrameLedger.exe` and `FrameLedger.Agent.exe` name FrameLedger and the copyright; Task Manager
lists *FrameLedger Agent*. (c) **The wheel** on every page, the dialogs and the summary window; over a chart the wheel
scrolls the page and Ctrl+wheel zooms; the Logs page follows the newest line. (d) **Hide scroll bars** on and off,
without a restart. (e) **The import list in the dark theme**, and Compare's tick boxes. (f) **A crash**: an Unreal game
that crashes reads *crashed (… CrashReportClient.exe)*; The Witcher 3 closed normally no longer reads *crashed*. (g)
**The new measurements** on the RTX 5080: the VSync share against the game's own VSync setting, the render scale
against the DLSS mode, the clocks, fan and limits. (h) The `ja` strings marked `review`. (i) **The Privacy Policy 2.7
wording — before PR-5 and PR-7 merge.**
**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
+8
View File
@@ -63,6 +63,14 @@ are kept because they record what each version changed and why (owner decision D
>
> Version 2.5 (2026-09-27, 0.1.0-beta.10) adds how a tracked game's window is shown — read from Windows — and the engine build name read from an Unreal Engine game's executable. It is also the first version to say two things the software already did: it reads the **content** of a library game's executable (markers in its first 8 MB and its import table, since the detection of engines and features; and, when a session starts, the graphics-library markers in the whole file), and it reads the processor load and the memory in use (since 0.1.0-beta.3). Nothing here leaves your device, as before.
### What version 2.7 of the Privacy Policy changed (0.1.0-beta.14)
§4 says two things the software reads to tell a crash from an ordinary exit: the crash reports Windows keeps in its
Application log about a tracked game — read since P2 and never stated until 2.7 — and the names of the programs a tracked
game starts, so that an engine's own crash reporter is recognised (beta.14 PR-5). §1 lists the graphics card's clock
speeds, fan speed, memory temperature and power or thermal limit among the stored sensor series (beta.14 PR-7, D49): they
were read before and are stored since.
### What version 2.6 of the Privacy Policy changed
It names the game's own memory use (since beta.12, read from outside the game in every session) where version 2.5
+7 -3
View File
@@ -36,9 +36,13 @@ The first window walks you through four short steps:
## Updates
A few seconds after it starts, FrameLedger asks GitHub whether a newer version exists. A new version downloads in the
background and is installed only when you restart FrameLedger — never while a game is being measured. You can switch
the check off in **Settings ▸ Updates ▸ Check for updates at startup**, and check by hand with Help ▸ Check for
updates.
background and is installed only when you restart FrameLedger — never while a game is being measured, and not while a
game it measured earlier is still running. You can switch the check off in **Settings ▸ Updates ▸ Check for updates at
startup**, and check by hand with Help ▸ Check for updates.
**Settings ▸ Updates ▸ Channel** is *Automatic* unless you choose: a test version (a pre-release, like every version so
far) looks for test versions, a release looks for releases. Choose *Stable* or *Beta* to decide yourself. Before
0.1.0-beta.14 the channel was *Stable* by default and found no version at all — on an older copy, choose *Beta* to update.
## Uninstall
+15 -2
View File
@@ -18,6 +18,14 @@ A value FrameLedger could not measure reads **N/A** — never 0, and never an es
- **1% low** and **0.1% low** are the frame rate of the slowest 1% and 0.1% of frames: the further they fall below the
average, the less smooth the game felt. **Stutter** counts frames that took much longer than the frames around them,
and the share of time they took.
- **Time below 60 FPS** (with *below 30* and *display under* your monitor's refresh rate beneath it) is how much of the
session ran slower than that. A game held at its limit is not counted as dropping below it for the tiny wobble every
frame limit has. **Frame to frame** is how much one frame's time differs from the next: lower is smoother.
- **VSync** is how many frames asked to wait for the display, and *tearing allowed* how many did not mind tearing — what
the game asked; your graphics driver can still override it.
- **GPU clocks**, the fan and the video memory's temperature are the card's own readings. **GPU held back** says how much
of the time its power limit or its temperature slowed it down (NVIDIA cards only). **Frames per watt** is the game's
own frames per second for each watt the graphics card drew — generated frames never count.
## Memory
@@ -38,12 +46,17 @@ correct it by hand — your correction is labelled as yours.
- **Frametime** — how long each frame took. Spikes are stutters.
- **Distribution** — how often each frame rate occurred.
- **Sensors** — temperatures, load and power; video memory; memory. The game's own line and the whole card's or the
whole PC's are drawn separately.
- **Render scale** — the share of the screen's resolution the game rendered at before upscaling (100% means no
upscaling), and when it changed.
- **Sensors** — temperatures, load and power; video memory; memory; and the card's clocks and fan, with the moments it
was held back shaded. The game's own line and the whole card's or the whole PC's are drawn separately.
- **Trend** (on the game's page) — one point per session over time, for example before and after a driver update.
Changes to your hardware or driver are marked on it.
- **Compare** (in the navigation on the left) — pick sessions, even of different games, and see them side by side.
To look closer, hold **Ctrl** and turn the mouse wheel over a chart to zoom, drag to pan, and double-click to reset. The
wheel alone scrolls the page.
## Export
The summary's **Export CSV**, **Export JSON** and **Export PNG** buttons — or File ▸ Export — save a session to a file.
+10 -2
View File
@@ -11,8 +11,8 @@
that changes what FrameLedger.Overlay or the capture host does; date the change.
HTML comments are not part of the block.
-->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.12`** (2026-10-04), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.14`** (2026-10-06), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
> game in the library runs (unless you switched its recording off), injects only into games you enabled
@@ -75,6 +75,14 @@
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
+10 -2
View File
@@ -113,8 +113,8 @@ Software running inside another process can, in principle, destabilize it. Frame
Frame timing is derived from high-resolution timestamps taken at the moment the game presents each frame; upscaling, frame-generation and ray-tracing state are read from the parameters the game passes to those APIs. This is substantially more accurate than inferring settings from files on disk, but **no measurement is guaranteed to be exact**:
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.12`** (2026-10-04), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.14`** (2026-10-06), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
> game in the library runs (unless you switched its recording off), injects only into games you enabled
@@ -177,6 +177,14 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
+3 -3
View File
@@ -1,6 +1,6 @@
# FrameLedger — Privacy Policy
**Version:** 2.6 · **Effective:** {{RELEASE_DATE}}
**Version:** 2.7 · **Effective:** {{RELEASE_DATE}}
**Short version: everything stays on your PC. FrameLedger has no accounts, no telemetry, no analytics, and never uploads your data anywhere.**
@@ -9,7 +9,7 @@
Stored in `%LOCALAPPDATA%\FrameLedger` on your device:
- Your game library entries (names, executable paths, metadata you or the app filled in, and whether each one is recorded).
- Performance sessions: frame timing series, computed statistics, hardware sensor series (temperatures, load, memory usage), the game's own memory use (its dedicated and shared video memory, private working set, working set and commit, once a second), session duration, crash flags, the graphics driver's settings the game ran under (NVIDIA only), how the game's window was shown (full-screen, borderless or windowed, for how long, its size and the monitor's), tags and notes you write.
- Performance sessions: frame timing series, computed statistics, hardware sensor series (temperatures, load, power, memory usage, and the graphics card's clock speeds, fan speed, memory temperature and whether its power limit or heat held it back), the game's own memory use (its dedicated and shared video memory, private working set, working set and commit, once a second), session duration, crash flags, the graphics driver's settings the game ran under (NVIDIA only), how the game's window was shown (full-screen, borderless or windowed, for how long, its size and the monitor's), tags and notes you write.
- A hardware snapshot per session (CPU/GPU model, driver version, RAM size, OS build, display mode) used for the "what changed between sessions" feature.
- App settings, logs (rotated daily — the app keeps 7 days, the capture agent 14 — including the logs written by the component loaded into games), and, after a crash of the app itself, crash dump files.
- Which games you enabled code injection for, and when you consented.
@@ -39,7 +39,7 @@ An exported session (CSV or JSON) and a bug report can contain your games' names
## 4. What the app can technically observe
To do its job, FrameLedger observes: which of *your tracked* executables — the entries in your library whose recording is on — are running, and their process trees; the parameters your games pass to the graphics APIs it intercepts (presentation, upscaling, ray tracing, pipeline creation); the memory use of a tracked game's process — its dedicated and shared video memory, from Windows' GPU performance counters, and its working sets and commit, from Windows' process-memory information, for which a game it does not inject into is opened with the least access Windows offers and closed again (never its memory's content); loaded module names of a game being captured (for detection and for the anti-cheat safety check); the names of the files in each library game's install folder, the version information of its executable and of the upscaling libraries it ships, the content of its executable file (the markers of the engine and of the graphics libraries it carries, the libraries it imports, and the engine build name an Unreal Engine game carries), and the store files that name it (Steam's and GOG's, on your disk) — to detect its engine, its engine version and its features and to check it for anti-cheat before any injection is possible; the size, position and state of a tracked game's window and the monitor it is on, read from Windows and not from the game, and — for a game FrameLedger injects into — whether the game asked for exclusive full-screen; the NVIDIA driver's settings for your tracked executables (read only: the DLSS and frame-generation overrides the NVIDIA App set); hardware sensor values from your graphics driver's own libraries; and how busy the processor is and how much memory is in use, from Windows' own counters.
To do its job, FrameLedger observes: which of *your tracked* executables — the entries in your library whose recording is on — are running, and their process trees; the parameters your games pass to the graphics APIs it intercepts (presentation, upscaling, ray tracing, pipeline creation); the memory use of a tracked game's process — its dedicated and shared video memory, from Windows' GPU performance counters, and its working sets and commit, from Windows' process-memory information, for which a game it does not inject into is opened with the least access Windows offers and closed again (never its memory's content); loaded module names of a game being captured (for detection and for the anti-cheat safety check); the names of the files in each library game's install folder, the version information of its executable and of the upscaling libraries it ships, the content of its executable file (the markers of the engine and of the graphics libraries it carries, the libraries it imports, and the engine build name an Unreal Engine game carries), and the store files that name it (Steam's and GOG's, on your disk) — to detect its engine, its engine version and its features and to check it for anti-cheat before any injection is possible; the size, position and state of a tracked game's window and the monitor it is on, read from Windows and not from the game, and — for a game FrameLedger injects into — whether the game asked for exclusive full-screen; the NVIDIA driver's settings for your tracked executables (read only: the DLSS and frame-generation overrides the NVIDIA App set); hardware sensor values from your graphics driver's own libraries; how busy the processor is and how much memory is in use, from Windows' own counters; the crash reports Windows keeps in its Application log about a tracked game's executable while it ran (to tell a crash from an ordinary exit — the reports are read, never sent anywhere); and the names of the programs a tracked game starts, so that a game's own crash reporter is recognised.
It does **not** read game memory outside those API parameters, and does not read game saves, chat, input content, network traffic, or anything unrelated to performance measurement. It records only for programs you added to your library and did not switch recording off for — a program whose recording is off is not watched at all — and injects only into games you individually enabled.
@@ -43,6 +43,7 @@ internal sealed class AgentRecording
private readonly IOverlayToleranceChannel _tolerance;
private readonly WindowGeometryProbe _display = new();
private readonly UserModeExceptionLapsePolicy _exceptionLapse;
private readonly ICrashReporterSightings _reporters;
public AgentRecording(
IGameConsentStore store,
@@ -66,8 +67,10 @@ internal sealed class AgentRecording
IDriverProfileSource profiles,
IUserModeExceptionSwitch exceptions,
IOverlayToleranceChannel tolerance,
UserModeExceptionLapsePolicy exceptionLapse)
UserModeExceptionLapsePolicy exceptionLapse,
ICrashReporterSightings reporters)
{
_reporters = reporters;
_profiles = profiles;
_exceptions = exceptions;
_tolerance = tolerance;
@@ -123,7 +126,8 @@ internal sealed class AgentRecording
_observer,
_policy,
_profiles,
_exceptionLapse);
_exceptionLapse,
_reporters);
}
/// <summary>L1 + L2 + L3 under the composite, one poller per session; the poller owns and disposes the layers. The interval is the session's (<c>telemetry.interval_ms</c>, D16).</summary>
@@ -94,14 +94,7 @@ internal static class AgentServices
services.AddSingleton<IRuntimeModuleSnapshot>(static _ => new RuntimeModuleSnapshot(CensusNames.ModuleFileNames));
AddNvidia(services);
// The recorder's adapters (PR-D).
services.AddSingleton<IPartialSessionStore>(_ => new PartialSessionStore(paths.Tmp));
services.AddSingleton<ICrashEventSource, EventLogCrashSource>();
services.AddSingleton<IHardwareSnapshotSource>(static _ => new HardwareSnapshotSource(new DxgiAdapters()));
services.AddSingleton<ISeriesCodec, DeflateSeriesCodec>();
services.AddSingleton<SessionFinalizer>();
services.AddSingleton(static sp => new PartialRecovery(sp.GetRequiredService<IPartialSessionStore>(), sp.GetRequiredService<SessionFinalizer>()));
services.AddSingleton<AgentRecording>();
AddRecording(services, paths);
// The watcher (this PR): snapshots, identity, and the orchestrator over an unbounded recorder.
services.AddSingleton<IProcessSnapshotSource, ToolhelpProcessSnapshotSource>();
@@ -115,6 +108,20 @@ internal static class AgentServices
return services;
}
/// <summary>The recorder's adapters (PR-D), and since beta.14 the witness of engine crash reporters the watcher feeds and the recorder asks.</summary>
private static void AddRecording(IServiceCollection services, AgentPaths paths)
{
services.AddSingleton<IPartialSessionStore>(_ => new PartialSessionStore(paths.Tmp));
services.AddSingleton<ICrashEventSource, EventLogCrashSource>();
services.AddSingleton<CrashReporterWitness>();
services.AddSingleton<ICrashReporterSightings>(static sp => sp.GetRequiredService<CrashReporterWitness>());
services.AddSingleton<IHardwareSnapshotSource>(static _ => new HardwareSnapshotSource(new DxgiAdapters()));
services.AddSingleton<ISeriesCodec, DeflateSeriesCodec>();
services.AddSingleton<SessionFinalizer>();
services.AddSingleton(static sp => new PartialRecovery(sp.GetRequiredService<IPartialSessionStore>(), sp.GetRequiredService<SessionFinalizer>()));
services.AddSingleton<AgentRecording>();
}
/// <summary>
/// D33 (owner decision 2026-09-26): the user-mode exception's option (one row in <c>settings</c>), its channel to the
/// Overlay (<c>Local\FrameLedger.Tolerate.&lt;pid&gt;</c>, created before an injection under it), and the policy that ends
@@ -238,7 +245,8 @@ internal static class AgentServices
static line => Serilog.Log.Information("{Line}", line),
sp.GetRequiredService<ILaunchRecorderFactory>(),
sp.GetRequiredService<ExecutableRelocator>(),
sp.GetRequiredService<LatestProcessSnapshot>()));
sp.GetRequiredService<LatestProcessSnapshot>(),
sp.GetRequiredService<CrashReporterWitness>()));
services.AddSingleton<ILaunchRecorderFactory, AgentLaunches>();
}
@@ -12,6 +12,10 @@
<RuntimeIdentifier>win-x64</RuntimeIdentifier>
<AssemblyName>FrameLedger.Agent</AssemblyName>
<RootNamespace>FrameLedger.Agent</RootNamespace>
<!-- beta.14 (D50): Task Manager lists a process by its file description, and until beta.14 this one read
"FrameLedger.Agent" - the SDK's default, the assembly name - with the same as its company and product. -->
<AssemblyTitle>FrameLedger Agent</AssemblyTitle>
<Description>FrameLedger Agent: watches the games you added and records their sessions. Identifies itself deliberately; see https://github.com/poli0981/frameledger</Description>
</PropertyGroup>
<ItemGroup>
+1 -1
View File
@@ -353,7 +353,7 @@ internal static class Program
builder.Services.AddHostedService<PipeServerHostedService>();
// Finalize's grace on shutdown (04_CAPTURE §Threading model): a session that does not make it leaves
// its .partial for the next start's recovery.
builder.Services.Configure<HostOptions>(static o => o.ShutdownTimeout = TimeSpan.FromSeconds(15));
builder.Services.Configure<HostOptions>(static o => o.ShutdownTimeout = Shared.Ipc.IpcProtocol.AgentShutdownGrace);
using IHost host = builder.Build();
AgentConsole.Line($@"serve: ledger {paths.Database}; logs {paths.Logs}; pipe \.\pipe\{Shared.Ipc.IpcProtocol.PipeName}; Ctrl+C stops");
+3
View File
@@ -78,6 +78,8 @@ public partial class App : System.Windows.Application
HookCrashHandlers();
// 08_UI §Accessibility (P4 PR-8): Esc closes the open ContentDialog or MessageBox, before any window exists.
DialogKeyboard.Register();
// beta.14: ui.hide_scrollbars reaches every scroller as it loads, those in a control's template too.
ScrollBarHiding.Register();
_run = DiagReport.Requested(e.Args) ? DiagAsync() : RunAsync();
}
@@ -102,6 +104,7 @@ public partial class App : System.Windows.Application
var registered = new RegisteredSettings(store);
LoggingLevel.SetDebug(await registered.GetBooleanAsync(SettingsRegistry.LogDebug).ConfigureAwait(true));
FpsDecimals.Two = await registered.GetBooleanAsync(SettingsRegistry.UiFpsDecimals).ConfigureAwait(true);
ScrollBarHiding.Apply(await registered.GetBooleanAsync(SettingsRegistry.UiHideScrollBars).ConfigureAwait(true));
var closePolicy = new WindowClosePolicy { MinimizeToTray = await registered.GetBooleanAsync(SettingsRegistry.UiMinimizeToTray).ConfigureAwait(true) };
_host = BuildHost(_db, appearance, registered, closePolicy);
+5 -2
View File
@@ -25,13 +25,15 @@ public sealed record ChartPalette(
Color SensorSecondary,
Color Segment,
Color Histogram,
Color Percentile)
Color Percentile,
Color SensorTertiary)
{
/// <summary>The keys both dictionaries must carry, in the record's order.</summary>
public static readonly IReadOnlyList<string> Keys =
[
"Chart_Figure", "Chart_Data", "Chart_Axis", "Chart_Grid", "Chart_Native", "Chart_Displayed", "Chart_Stutter",
"Chart_StutterPso", "Chart_Sensor", "Chart_SensorSecondary", "Chart_Segment", "Chart_Histogram", "Chart_Percentile",
"Chart_SensorTertiary",
];
private static readonly Dictionary<ApplicationTheme, ChartPalette> _cache = [];
@@ -57,7 +59,7 @@ public sealed record ChartPalette(
{
ArgumentNullException.ThrowIfNull(dictionary);
Color[] c = [.. Keys.Select(k => Convert(dictionary, k))];
return new ChartPalette(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12]);
return new ChartPalette(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12], c[13]);
}
/// <summary>The colour a key names — how a chart that assigns palette entries to series by name reads them (<c>SensorsChart</c>).</summary>
@@ -76,6 +78,7 @@ public sealed record ChartPalette(
"Chart_Segment" => Segment,
"Chart_Histogram" => Histogram,
"Chart_Percentile" => Percentile,
"Chart_SensorTertiary" => SensorTertiary,
_ => throw new ArgumentOutOfRangeException(nameof(key), key, "not a chart palette key"),
};
+5 -1
View File
@@ -70,10 +70,14 @@ public static class ChartTheme
(byte)Math.Round((top.B * a) + (under.B * (1 - a))));
}
/// <summary>Registers a control so a theme change re-applies and refreshes it (weakly held; a closed window is forgotten).</summary>
/// <summary>
/// Registers a control so a theme change re-applies and refreshes it (weakly held; a closed window is forgotten), and
/// gives it the App's wheel: a plain wheel scrolls the page, Ctrl+wheel zooms (<see cref="ChartWheel"/>, beta.14).
/// </summary>
public static void Attach(WpfPlot control)
{
ArgumentNullException.ThrowIfNull(control);
ChartWheel.Attach(control);
lock (_lock)
{
_live.RemoveAll(static w => !w.TryGetTarget(out _));
+66
View File
@@ -0,0 +1,66 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using ScottPlot.WPF;
namespace FrameLedger.App.Charts;
/// <summary>
/// The mouse wheel over a chart (beta.14). ScottPlot 5's <see cref="WpfPlot"/> zooms on every wheel and never marks it
/// handled, so with the pages scrolling again (<c>16_WPFUI_SYNTAX</c> §Gotchas: they did not until beta.14) a wheel over a
/// chart would have zoomed it AND scrolled the page under the pointer. A plain wheel now belongs to the page — ScottPlot
/// never sees it — and Ctrl+wheel to the chart, which zooms and keeps the page where it is. Every plot reaches this through
/// <see cref="ChartTheme.Attach"/>.
/// </summary>
internal static class ChartWheel
{
/// <summary>Whether a wheel with these modifier keys zooms the chart rather than scrolling the page: Ctrl held.</summary>
public static bool Zooms(ModifierKeys modifiers) => (modifiers & ModifierKeys.Control) == ModifierKeys.Control;
/// <summary>
/// The modifier keys the two handlers read: <see cref="Keyboard.Modifiers"/>, which is the machine's real keyboard — a
/// thread that never had keyboard focus still reads it (measured 2026-10-06: a fresh background thread's
/// <c>GetKeyState</c> reported the machine's NumLock). So a test driving the wheel end to end held whatever key a person
/// pressed while it ran — the one input it did not control, and the plain half went red once in a gate on the developer's
/// machine and never on CI. The tests set this for the length of one dispatcher work item and put it back; the App never
/// sets it.
/// </summary>
internal static Func<ModifierKeys> CurrentModifiers { get; set; } = static () => Keyboard.Modifiers;
public static void Attach(WpfPlot plot)
{
ArgumentNullException.ThrowIfNull(plot);
plot.PreviewMouseWheel += OnPreviewMouseWheel;
plot.MouseWheel += OnMouseWheel;
}
/// <summary>
/// The tunnelling half, before ScottPlot's own handler on its inner element: a plain wheel is taken from the plot and
/// raised again on the plot's parent, from where it bubbles to the page's scroller as any other wheel would.
/// </summary>
private static void OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)
{
if (e.Handled || Zooms(CurrentModifiers()) || sender is not DependencyObject plot)
{
return;
}
e.Handled = true;
if (VisualTreeHelper.GetParent(plot) is UIElement parent)
{
parent.RaiseEvent(new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta) { RoutedEvent = UIElement.MouseWheelEvent, Source = sender });
}
}
/// <summary>The bubbling half, after ScottPlot has zoomed: Ctrl+wheel stops here, so the page does not scroll as well.</summary>
private static void OnMouseWheel(object sender, MouseWheelEventArgs e)
{
if (Zooms(CurrentModifiers()))
{
e.Handled = true;
}
}
}
@@ -7,7 +7,8 @@
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
xmlns:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF"
MinHeight="260">
<!-- 08_UI §Session summary / FR-5.1: the frametime timeline, min/max decimated (FR-5.3); zoom and pan are ScottPlot's.
<!-- 08_UI §Session summary / FR-5.1: the frametime timeline, min/max decimated (FR-5.3); zoom and pan are ScottPlot's —
zoom with Ctrl+wheel since beta.14, a plain wheel scrolls the page (ChartWheel).
The note above it says what the lines are not, when that is not obvious (beta.8). -->
<Grid>
<Grid.RowDefinitions>
@@ -0,0 +1,17 @@
<!-- SPDX-License-Identifier: GPL-3.0-only -->
<!-- Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE -->
<UserControl x:Class="FrameLedger.App.Charts.RenderScaleChart"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF">
<!-- 08_UI §Session summary (beta.14, D49): the render scale over the session, as steps; a line saying it was not measured
where the upscaler's parameters never were. -->
<Grid>
<sp:WpfPlot x:Name="Plot" />
<ui:TextBlock x:Name="NotMeasured" Appearance="Secondary" TextWrapping="Wrap" VerticalAlignment="Center" HorizontalAlignment="Center"
Text="{x:Static res:Strings.Chart_RenderScale_NotMeasured}" Visibility="Collapsed" />
</Grid>
</UserControl>
@@ -0,0 +1,52 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using System.Windows.Controls;
using FrameLedger.Application.Persistence;
using ScottPlot;
using ScottPlot.Plottables;
namespace FrameLedger.App.Charts;
/// <summary>
/// The render scale over a session (beta.14, D49; <see cref="RenderScaleSeries"/>): a step line — a scale holds until the next
/// change — and, where the upscaler's parameters were never measured, a sentence saying so instead of an empty plot.
/// </summary>
public partial class RenderScaleChart : UserControl
{
public RenderScaleChart()
{
InitializeComponent();
ChartTheme.Attach(Plot);
}
/// <summary>The points drawn by the last <see cref="Show"/>; 0 when the scale was not measured.</summary>
public int DrawnPoints { get; private set; }
public void Show(SessionSeries? series, SessionRow? row)
{
ScottPlot.Plot plot = Plot.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_TimeFromFirstFrame);
plot.YLabel(Strings.Chart_Axis_RenderScale);
(double[] xs, double[] ys) = row is null ? ([], []) : RenderScaleSeries.Of(series, row);
DrawnPoints = xs.Length;
if (xs.Length > 0)
{
Scatter line = plot.Add.Scatter(xs, ys, ChartTheme.Current.Native);
line.ConnectStyle = ConnectStyle.StepHorizontal;
line.MarkerSize = 0;
line.LineWidth = 2;
plot.Axes.AutoScale();
// A scale reads against 0 and 100 %: an axis fitted to one flat line would make 66.7 % look like a cliff.
plot.Axes.SetLimitsY(0, Math.Max(100, ys.Max() * 1.05));
}
NotMeasured.Visibility = xs.Length > 0 ? Visibility.Collapsed : Visibility.Visible;
Plot.Visibility = xs.Length > 0 ? Visibility.Visible : Visibility.Hidden;
Plot.Refresh();
}
}
@@ -0,0 +1,78 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using FrameLedger.Application.Persistence;
namespace FrameLedger.App.Charts;
/// <summary>
/// The render scale over a session (beta.14, D49): <c>100 × √(render pixels / output pixels)</c> — the per-axis scale
/// <c>03_METRICS</c> §Upscaling names, so DLSS Quality's 1707×960 of 2560×1440 reads 66.7 %. Per present from the
/// <c>render_res</c> blob where the resolution varied, a flat line at the row's extent where it did not (the finalizer stores
/// the blob only then), and nothing where the upscaler's parameters were never measured.
/// </summary>
internal static class RenderScaleSeries
{
/// <summary>The scale in percent, or null when either size is unknown (0 is the writer's "unknown").</summary>
public static double? Scale(int renderW, int renderH, int outputW, int outputH) =>
renderW > 0 && renderH > 0 && outputW > 0 && outputH > 0
? 100.0 * Math.Sqrt((double)renderW * renderH / ((double)outputW * outputH))
: null;
/// <summary>
/// Seconds from the first present and the scale there — only the points where the scale changes, and the last one, since
/// a scale holds until the next change and a 300,000-present session has a handful (drawn as steps). Empty when nothing
/// was measured.
/// </summary>
public static (double[] Xs, double[] Ys) Of(SessionSeries? series, SessionRow row)
{
ArgumentNullException.ThrowIfNull(row);
if (series is null || series.Presents == 0)
{
return ([], []);
}
if (series.RenderRes is { } quads && quads.Length >= 4 * series.Presents)
{
return Changes(series, quads);
}
return Scale(row.RenderW ?? 0, row.RenderH ?? 0, row.OutputW ?? 0, row.OutputH ?? 0) is double flat
? ([0, series.DurationS], [flat, flat])
: ([], []);
}
private static (double[] Xs, double[] Ys) Changes(SessionSeries series, ushort[] quads)
{
var xs = new List<double>();
var ys = new List<double>();
double? last = null;
int lastIndex = -1;
for (int i = 0; i < series.Presents; i++)
{
if (Scale(quads[4 * i], quads[4 * i + 1], quads[4 * i + 2], quads[4 * i + 3]) is not double s)
{
continue;
}
lastIndex = i;
if (last is double previous && Math.Abs(previous - s) < 1e-9)
{
continue;
}
xs.Add(series.TimesS[i]);
ys.Add(s);
last = s;
}
// The last measured present closes the final step, so a scale held to the end is drawn to the end.
if (last is double end && xs.Count > 0 && series.TimesS[lastIndex] > xs[^1])
{
xs.Add(series.TimesS[lastIndex]);
ys.Add(end);
}
return ([.. xs], [.. ys]);
}
}
@@ -16,5 +16,11 @@
<sp:WpfPlot x:Name="Vram" Height="220" Margin="0,6,0,0" />
<ui:TextBlock Margin="0,12,0,0" FontTypography="BodyStrong" Text="{x:Static res:Strings.Sensors_Ram_Header}" />
<sp:WpfPlot x:Name="Ram" Height="220" Margin="0,6,0,0" />
<!-- beta.14 (D49): the card's clocks (MHz) and fan (RPM, right axis), with the ticks its power limit or heat held it
back shaded. Collapsed when the session stored none of them. -->
<StackPanel x:Name="ClocksSection">
<ui:TextBlock Margin="0,12,0,0" FontTypography="BodyStrong" Text="{x:Static res:Strings.Sensors_Clocks_Header}" />
<sp:WpfPlot x:Name="Clocks" Height="220" Margin="0,6,0,0" />
</StackPanel>
</StackPanel>
</UserControl>
@@ -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 System.Windows.Controls;
using FrameLedger.App.Services;
using FrameLedger.Application.Recording;
@@ -28,6 +29,7 @@ public partial class SensorsChart : UserControl
[
("gpu_temp", "Chart_Sensor", false),
("gpu_hotspot", "Chart_Stutter", false),
(SensorSeriesCatalog.GpuMemTemp, "Chart_SensorTertiary", false),
("gpu_load", "Chart_Native", false),
("gpu_power", "Chart_SensorSecondary", true),
("cpu_temp", "Chart_Percentile", false),
@@ -52,6 +54,21 @@ public partial class SensorsChart : UserControl
(SensorSeriesCatalog.RamSystem, "Chart_Percentile"),
];
/// <summary>The clocks plot's lines (beta.14): core and memory clock on the MHz axis, the fan on the right-hand RPM axis.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey, bool Rpm)> ClocksPlot =
[
(SensorSeriesCatalog.GpuCoreClock, "Chart_Native", false),
(SensorSeriesCatalog.GpuMemClock, "Chart_Displayed", false),
(SensorSeriesCatalog.GpuFan, "Chart_SensorSecondary", true),
];
/// <summary>The limits shaded on the clocks plot (beta.14): the ticks each one held the card back, NVIDIA only.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey)> LimitSpans =
[
(SensorSeriesCatalog.GpuPowerLimit, "Chart_Stutter"),
(SensorSeriesCatalog.GpuThermalLimit, "Chart_StutterPso"),
];
private const double _mibPerGb = 1024.0;
public SensorsChart()
@@ -60,8 +77,12 @@ public partial class SensorsChart : UserControl
ChartTheme.Attach(Temps);
ChartTheme.Attach(Vram);
ChartTheme.Attach(Ram);
ChartTheme.Attach(Clocks);
}
/// <summary>The shaded spans the last <see cref="Show"/> drew on the clocks plot.</summary>
public int LimitSpansDrawn { get; private set; }
public int DrawnSeries { get; private set; }
/// <summary>The temperatures plot, for a test's look at its axes.</summary>
@@ -73,6 +94,104 @@ public partial class SensorsChart : UserControl
DrawTemps(series);
DrawMemory(Vram, series, VideoMemoryPlot);
DrawMemory(Ram, series, SystemMemoryPlot);
DrawClocks(series);
}
/// <summary>
/// The card's clocks and fan (beta.14), and every run of ticks a limit held it back as a shaded span behind them — a span
/// from the first such tick to the next tick that was not, so one tick reads as a second. The section collapses for a
/// session that stored none of these series (recorded before beta.14, or a card no layer reads them on).
/// </summary>
private void DrawClocks(SessionSeries? series)
{
ScottPlot.Plot plot = Clocks.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(TimeAxisLabel(series));
plot.YLabel(Strings.Sensors_Axis_Mhz);
LimitSpansDrawn = 0;
bool any = false;
if (series is not null)
{
ChartPalette p = ChartTheme.Current;
foreach ((string name, string key) in LimitSpans)
{
string label = string.Equals(name, SensorSeriesCatalog.GpuPowerLimit, StringComparison.Ordinal) ? Strings.Sensors_Limit_Power : Strings.Sensors_Limit_Thermal;
LimitSpansDrawn += Spans(plot, series, name, label, p.ByKey(key));
}
foreach ((string name, string key, bool rpm) in ClocksPlot)
{
bool drawn = Line(plot, series, name, Label(name), p.ByKey(key), rpm ? plot.Axes.Right : null);
any |= drawn;
if (drawn && rpm)
{
plot.Axes.Right.Label.Text = Strings.Sensors_Axis_Rpm;
}
}
any |= LimitSpansDrawn > 0;
plot.Axes.AutoScale();
plot.ShowLegend(Alignment.UpperRight);
}
ClocksSection.Visibility = any ? Visibility.Visible : Visibility.Collapsed;
Clocks.Refresh();
}
/// <summary>Shades every run of ticks whose value is 100 (held back) in <paramref name="name"/>; how many spans it drew.</summary>
private static int Spans(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color)
{
SensorSeries? limit = series.Sensors.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.Ordinal));
if (limit is null)
{
return 0;
}
int drawn = 0;
foreach ((double from, double to) in LimitRuns(limit))
{
VerticalSpan span = plot.Add.VerticalSpan(from, to, color.WithAlpha(0.18));
span.LineWidth = 0;
if (drawn++ == 0)
{
span.LegendText = label;
}
}
return drawn;
}
/// <summary>
/// The runs of ticks held back, as (start, end) seconds: from a tick at 100 to the next tick, and through every tick at
/// 100 after it — the reading holds for the second until the next. Pure, for the tests.
/// </summary>
internal static IReadOnlyList<(double From, double To)> LimitRuns(SensorSeries limit)
{
ArgumentNullException.ThrowIfNull(limit);
var runs = new List<(double, double)>();
double? start = null;
for (int i = 0; i < limit.Values.Length; i++)
{
bool held = limit.Values[i] >= 50;
if (held && start is null)
{
start = limit.TimesS[i];
}
else if (!held && start is double s)
{
runs.Add((s, limit.TimesS[i]));
start = null;
}
}
if (start is double open)
{
double last = limit.TimesS[^1];
runs.Add((open, last > open ? last + (last - limit.TimesS[Math.Max(0, limit.TimesS.Length - 2)]) : open + 1));
}
return runs;
}
/// <summary>The time axis says where its zero is: the first frame when the sensors sit on the frames' axis, the session's start otherwise.</summary>
+25
View File
@@ -68,4 +68,29 @@ public enum TrendMetric
DisplayBorderlessShare,
DisplayWindowedShare,
/// <summary>
/// The nine below are beta.14's (D49): pacing and efficiency from the hooks, the card's clock, memory temperature and power
/// limit from the telemetry every session records. A session before beta.14 has no point on any of them.
/// </summary>
TimeBelow60,
/// <summary>The share of the presented time below the monitor's refresh rate — what the display received.</summary>
TimeBelowRefresh,
FrameToFrame,
/// <summary>The render scale, <c>100 / upscale_ratio</c> — the per-axis scale of the session's dominant extent.</summary>
RenderScale,
VsyncShare,
GpuCoreClock,
MaxGpuMemTemp,
PowerLimitShare,
/// <summary>Application frames per watt of the card's power — never displayed frames (rule 6).</summary>
Efficiency,
}
@@ -52,7 +52,10 @@ public static class TrendSeriesBuilder
public static string UnitOf(TrendMetric metric) => metric switch
{
TrendMetric.PresentedFps or TrendMetric.NativeFps or TrendMetric.Displayed or TrendMetric.P1Low or TrendMetric.P01Low => Strings.Trend_Unit_Fps,
TrendMetric.MaxGpuTemp or TrendMetric.MaxCpuTemp => Strings.Trend_Unit_Celsius,
TrendMetric.MaxGpuTemp or TrendMetric.MaxCpuTemp or TrendMetric.MaxGpuMemTemp => Strings.Trend_Unit_Celsius,
TrendMetric.FrameToFrame => Strings.Trend_Unit_Ms,
TrendMetric.GpuCoreClock => Strings.Trend_Unit_Mhz,
TrendMetric.Efficiency => Strings.Trend_Unit_FpsPerWatt,
TrendMetric.AvgGpuPower => Strings.Trend_Unit_Watts,
TrendMetric.AvgRam or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak => Strings.Trend_Unit_Gigabytes,
TrendMetric.FgFactor => Strings.Trend_Unit_Factor,
@@ -106,7 +109,8 @@ public static class TrendSeriesBuilder
/// </summary>
public static bool IsMachineMetric(TrendMetric metric) => metric is TrendMetric.MaxGpuTemp or TrendMetric.AvgGpuLoad or TrendMetric.AvgGpuPower
or TrendMetric.AvgCpuLoad or TrendMetric.MaxCpuTemp or TrendMetric.AvgRam
or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak;
or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak
or TrendMetric.GpuCoreClock or TrendMetric.MaxGpuMemTemp or TrendMetric.PowerLimitShare;
public static int ExcludedCount(IReadOnlyList<SessionRow> rows, TrendMetric metric)
{
@@ -170,10 +174,25 @@ public static class TrendSeriesBuilder
TrendMetric.DisplayExclusiveShare => DisplayShare(row, DisplayMode.ExclusiveFullscreen),
TrendMetric.DisplayBorderlessShare => DisplayShare(row, DisplayMode.Borderless),
TrendMetric.DisplayWindowedShare => DisplayShare(row, DisplayMode.Windowed),
_ => null,
_ => Beta14ValueOf(row, metric),
};
}
/// <summary>beta.14 (D49): the values of schema 0019 — null on a row written before it, as on one where nothing measured them.</summary>
private static double? Beta14ValueOf(SessionRow row, TrendMetric metric) => metric switch
{
TrendMetric.TimeBelow60 => row.TimeBelow60Pct,
TrendMetric.TimeBelowRefresh => row.TimeBelowRefreshPct,
TrendMetric.FrameToFrame => row.FrametimeDeltaMeanMs,
TrendMetric.RenderScale => row.UpscaleRatio is > 0 ? 100.0 / row.UpscaleRatio.Value : null,
TrendMetric.VsyncShare => row.VsyncPresentPct,
TrendMetric.GpuCoreClock => row.AvgGpuCoreClockMhz,
TrendMetric.MaxGpuMemTemp => row.MaxGpuMemTemp,
TrendMetric.PowerLimitShare => row.PowerLimitPct,
TrendMetric.Efficiency => row.AppFramesPerJoule,
_ => null,
};
/// <summary>MiB as stored, in GB as Task Manager counts them (1 GB = 1024 MiB).</summary>
private static double? Gb(double? mib) => mib / 1024.0;
@@ -16,7 +16,7 @@
Safety_AdminMode_* only, versioned by AgentAdminDisclosure.Version. It states what the option adds, what it does not
change, how Windows asks, and the risk; every colour is a theme brush.
-->
<ScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<ui:PassiveScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<StackPanel>
<ui:TextBlock Text="{x:Static vm:AgentAdminDialogViewModel.Intro}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,14,0,0" Text="{x:Static vm:AgentAdminDialogViewModel.Adds}" TextWrapping="Wrap" />
@@ -34,5 +34,5 @@
IsChecked="{Binding Accepted, Mode=TwoWay}" />
<ui:TextBlock Margin="0,12,0,0" HorizontalAlignment="Right" Appearance="Tertiary" Text="{x:Static vm:AgentAdminDialogViewModel.Version}" />
</StackPanel>
</ScrollViewer>
</ui:PassiveScrollViewer>
</UserControl>
@@ -16,7 +16,7 @@
versioned by AntiCheatExceptionDisclosure.Version. It states why the exception is offered, the risk, what is still
refused, how it ends, and that it turns nothing on; it recommends neither choice. Every colour is a theme brush.
-->
<ScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<ui:PassiveScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<StackPanel>
<ui:TextBlock Text="{Binding Intro}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,14,0,0" Text="{Binding Why}" TextWrapping="Wrap" />
@@ -37,5 +37,5 @@
Content="{x:Static vm:AntiCheatExceptionDialogViewModel.AcceptText}"
IsChecked="{Binding Accepted, Mode=TwoWay}" />
</StackPanel>
</ScrollViewer>
</ui:PassiveScrollViewer>
</UserControl>
@@ -19,7 +19,7 @@
<ui:TextBlock TextWrapping="Wrap" Text="{Binding Intro}" />
<Border Margin="0,10,0,10" Padding="10,6" CornerRadius="6"
Background="{DynamicResource ControlFillColorDefaultBrush}" BorderBrush="{DynamicResource ControlStrokeColorDefaultBrush}" BorderThickness="1">
<ScrollViewer MaxHeight="220" VerticalScrollBarVisibility="Auto">
<ui:PassiveScrollViewer MaxHeight="220" VerticalScrollBarVisibility="Auto">
<ItemsControl ItemsSource="{Binding Entries}">
<ItemsControl.ItemTemplate>
<DataTemplate>
@@ -27,7 +27,7 @@
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</ScrollViewer>
</ui:PassiveScrollViewer>
</Border>
<ui:HyperlinkButton Padding="0" Content="{x:Static vm:BugReportPreviewViewModel.ShowZipText}" Command="{Binding ShowZipCommand}" />
<ui:TextBlock Margin="0,10,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:BugReportPreviewViewModel.DragInstruction}" />
@@ -16,7 +16,7 @@
tiers are two paragraphs of the same shape, in the order enable / do-not-enable, with nothing between
them that reads as a recommendation. Every colour is a theme brush (16_WPFUI §Theming).
-->
<ScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<ui:PassiveScrollViewer MaxHeight="520" VerticalScrollBarVisibility="Auto">
<StackPanel>
<ui:TextBlock Text="{x:Static vm:ConsentDialogViewModel.Intro}" TextWrapping="Wrap" />
@@ -38,5 +38,5 @@
Text="{Binding Typed, UpdateSourceTrigger=PropertyChanged}"
PlaceholderText="{x:Static vm:ConsentDialogViewModel.Phrase}" />
</StackPanel>
</ScrollViewer>
</ui:PassiveScrollViewer>
</UserControl>
@@ -16,15 +16,30 @@
or has no executable cannot be ticked (its box is disabled since beta.11 - before, a tick was taken and ignored).
Rows already in the library are hidden unless "Show the N games already in the library" is ticked, and then
dimmed. Import never enables hooking (the intro says so).
beta.14 (owner's screenshot, dark theme): every row was white with white text and every tick box a sliver. The row
style was based on {x:Type DataGridRow}, which WPF UI 4.3.0 does not define - it keys its row style
DefaultDataGridRowStyle and hands it to the grid through the DataGrid style's RowStyle - so the lookup fell through
to Aero2's row template and its SystemColors.WindowBrush, which no theme reaches. The sliver is WPF UI's CheckBox
style, MinWidth 120 and padding 11, in a 40 px column: MinWidth 0 and no padding draw the whole box. And the list
no longer scrolls inside a dialog that scrolls too: ImportReviewPrompt turns the dialog's own
scrolling off, so the grid takes the height the window leaves and is the one thing that scrolls - the intro and the
count stay where they are (ImportReviewRenderTests).
-->
<StackPanel>
<ui:TextBlock TextWrapping="Wrap" Text="{x:Static vm:ImportReviewViewModel.Intro}" />
<CheckBox Margin="0,8,0,0" Content="{Binding ShowExistingText}" IsChecked="{Binding ShowExisting, Mode=TwoWay}"
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="*" MinHeight="120" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<ui:TextBlock Grid.Row="0" TextWrapping="Wrap" Text="{x:Static vm:ImportReviewViewModel.Intro}" />
<CheckBox Grid.Row="1" Margin="0,8,0,0" Content="{Binding ShowExistingText}" IsChecked="{Binding ShowExisting, Mode=TwoWay}"
Visibility="{Binding HasExisting, Converter={StaticResource BoolToVis}}" />
<DataGrid Margin="0,10,0,8" MaxHeight="360" AutoGenerateColumns="False" CanUserAddRows="False" HeadersVisibility="Column"
<DataGrid x:Name="Candidates" Grid.Row="2" Margin="0,10,0,8" AutoGenerateColumns="False" CanUserAddRows="False" HeadersVisibility="Column"
ItemsSource="{Binding Shown}" SelectionMode="Single" IsReadOnly="False">
<DataGrid.RowStyle>
<Style TargetType="DataGridRow" BasedOn="{StaticResource {x:Type DataGridRow}}">
<Style TargetType="DataGridRow" BasedOn="{StaticResource DefaultDataGridRowStyle}">
<Style.Triggers>
<DataTrigger Binding="{Binding IsExisting}" Value="True">
<Setter Property="Opacity" Value="0.55" />
@@ -36,7 +51,7 @@
<DataGridTemplateColumn Width="40">
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<CheckBox HorizontalAlignment="Center" IsEnabled="{Binding CanImport}"
<CheckBox MinWidth="0" Padding="0" HorizontalAlignment="Center" IsEnabled="{Binding CanImport}"
AutomationProperties.Name="{Binding Name}"
IsChecked="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</DataTemplate>
@@ -48,12 +63,12 @@
<DataGridTextColumn Header="{x:Static vm:ImportReviewViewModel.ColumnNote}" Binding="{Binding Note}" IsReadOnly="True" Width="Auto" />
</DataGrid.Columns>
</DataGrid>
<DockPanel>
<DockPanel Grid.Row="3">
<StackPanel DockPanel.Dock="Right" Orientation="Horizontal">
<ui:HyperlinkButton Padding="4,0" Content="{x:Static res:Strings.Import_SelectAll}" Command="{Binding SelectAllCommand}" xmlns:res="clr-namespace:FrameLedger.App" />
<ui:HyperlinkButton Padding="4,0" Content="{x:Static res:Strings.Import_SelectNone}" Command="{Binding SelectNoneCommand}" xmlns:res="clr-namespace:FrameLedger.App" />
</StackPanel>
<ui:TextBlock Appearance="Secondary" VerticalAlignment="Center" Text="{Binding SelectedText}" />
</DockPanel>
</StackPanel>
</Grid>
</UserControl>
+4 -7
View File
@@ -24,6 +24,10 @@
<!-- 11_UPDATER (P4 PR-5): Velopack must run before any window exists, so the
entry point is Program.Main rather than the generated App.Main. -->
<StartupObject>FrameLedger.App.Program</StartupObject>
<!-- beta.14 (D50): the file description Explorer and Task Manager show, and the Comments line. The company, product
and copyright are every assembly's (Directory.Build.props). -->
<AssemblyTitle>FrameLedger</AssemblyTitle>
<Description>FrameLedger: records game performance sessions and shows them over time. Identifies itself deliberately; see https://github.com/poli0981/frameledger</Description>
</PropertyGroup>
<ItemGroup>
@@ -57,13 +61,6 @@
<EmbeddedResource Include="..\..\guide\*.md" LogicalName="guide/%(Filename)%(Extension)" />
</ItemGroup>
<!-- beta.12: the source this build was made from, so the App's links into the repository open THIS version's documents
(Services/RepositoryLinks.cs). release.yml passes the tag (a rehearsal, its commit); a local build has none and links
to main. -->
<ItemGroup Condition="'$(FrameLedgerSourceRef)' != ''">
<AssemblyMetadata Include="FrameLedgerSourceRef" Value="$(FrameLedgerSourceRef)" />
</ItemGroup>
<ItemGroup>
<!-- P4 PR-6: the licence texts travel with the package (legal/THIRD_PARTY_NOTICES.md: "Full license texts must be
shipped in legal/licenses/ in release packages"). PUBLISH ONLY: a build output has no recipient, and copying
+13 -3
View File
@@ -8,9 +8,10 @@
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
xmlns:charts="clr-namespace:FrameLedger.App.Charts"
Title="{x:Static res:Strings.Compare_Header}">
Title="{x:Static res:Strings.Compare_Header}"
ScrollViewer.CanContentScroll="False">
<!-- 08_UI §Compare: the picker (2–5, cross-game), the overlaid percentile curves, the stat table; FR-6.2's guard is the view model's. -->
<ScrollViewer>
<ScrollViewer VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<ui:TextBlock FontTypography="Title" Text="{x:Static vm:CompareViewModel.Header}" />
<ui:TextBlock Margin="0,16,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:CompareViewModel.EmptyText}"
@@ -32,7 +33,16 @@
ItemsSource="{Binding ViewModel.Candidates}" SelectionMode="Single"
Visibility="{Binding ViewModel.IsEmpty, Converter={StaticResource InverseBoolToVis}}">
<DataGrid.Columns>
<DataGridCheckBoxColumn Binding="{Binding IsSelected, UpdateSourceTrigger=PropertyChanged}" Width="40" />
<!-- A template column, not DataGridCheckBoxColumn: that one's element style is WPF's own, an Aero2 box on the Fluent grid; MinWidth 0
and no padding, or WPF UI's CheckBox (MinWidth 120, padding 11) draws a sliver of the box in 40 px (beta.14). -->
<DataGridTemplateColumn Width="40">
<DataGridTemplateColumn.CellTemplate>
<DataTemplate DataType="{x:Type vm:CompareCandidateViewModel}">
<CheckBox MinWidth="0" Padding="0" HorizontalAlignment="Center" AutomationProperties.Name="{Binding Label}"
IsChecked="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>
<DataGridTextColumn Header="{x:Static res:Strings.Compare_Col_Game}" Binding="{Binding GameName}" IsReadOnly="True" Width="2*" />
<DataGridTextColumn Header="{x:Static res:Strings.Compare_Col_Date}" Binding="{Binding DateText}" IsReadOnly="True" Width="*" />
<DataGridTextColumn Header="{x:Static res:Strings.Compare_Col_Tier}" Binding="{Binding TierText}" IsReadOnly="True" Width="Auto" />
+3 -2
View File
@@ -8,8 +8,9 @@
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
xmlns:controls="clr-namespace:FrameLedger.App.Controls"
Title="{x:Static res:Strings.Dashboard_Header}">
<ScrollViewer>
Title="{x:Static res:Strings.Dashboard_Header}"
ScrollViewer.CanContentScroll="False">
<ScrollViewer VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<ui:TextBlock FontTypography="Title" Text="{x:Static vm:DashboardViewModel.Header}" />
@@ -9,13 +9,14 @@
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
xmlns:controls="clr-namespace:FrameLedger.App.Controls"
xmlns:charts="clr-namespace:FrameLedger.App.Charts"
Title="{x:Static res:Strings.Games_Header}">
Title="{x:Static res:Strings.Games_Header}"
ScrollViewer.CanContentScroll="False">
<!--
08_UI §Games › Game detail. The two rows — Supports (files on disk) and Last session measured (the
hooks) — are two cards and never mixed. The hooking control opens FR-2.1's dialog; a blocked pre-scan
disables it with the reason inline; a refusal is a persistent InfoBar on this page, never a toast.
-->
<ScrollViewer>
<ScrollViewer VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<ui:HyperlinkButton Padding="0" Command="{Binding ViewModel.BackCommand}" Content="{x:Static vm:GameDetailViewModel.BackText}" Icon="{ui:SymbolIcon ArrowLeft24}" />
@@ -385,7 +386,7 @@
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSensors, Converter={StaticResource BoolToVis}}" />
</StackPanel>
</TabItem>
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}">
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}" Visibility="{Binding ViewModel.AnyLatency, Converter={StaticResource BoolToVis}}">
<StackPanel Margin="0,12,0,0">
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SelectedNote}"
Visibility="{Binding ViewModel.SelectedNote, Converter={StaticResource NullToCollapsed}}" />
+3 -2
View File
@@ -10,14 +10,15 @@
xmlns:controls="clr-namespace:FrameLedger.App.Controls"
Title="{x:Static res:Strings.Games_Header}"
AllowDrop="True"
Drop="OnDrop">
Drop="OnDrop"
ScrollViewer.CanContentScroll="False">
<!--
08_UI §Games: search, sort, FR-1.1 add by pick or by dropping an .exe here. Since beta.11 (owner requests 2026-10-03):
the count in the title; a grid of cards that fills the width (UniformWrapPanel - a WrapPanel of 300 px cards left a
card's width unused at the right) or a list (ui.library_view); Refresh reads the library again, offers the games the
stores installed since, and marks the entries whose executable is gone.
-->
<ScrollViewer>
<ScrollViewer VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<Grid>
<Grid.ColumnDefinitions>
+2 -1
View File
@@ -7,7 +7,8 @@
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
Title="{x:Static res:Strings.Logs_Header}">
Title="{x:Static res:Strings.Logs_Header}"
ScrollViewer.CanContentScroll="False">
<Grid Margin="24,16,24,16">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
+14 -2
View File
@@ -7,8 +7,9 @@
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
Title="{x:Static res:Strings.Settings_Header}">
<ScrollViewer>
Title="{x:Static res:Strings.Settings_Header}"
ScrollViewer.CanContentScroll="False">
<ScrollViewer VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<ui:TextBlock FontTypography="Title" Text="{x:Static vm:SettingsViewModel.Header}" />
@@ -310,6 +311,17 @@
</ui:CardControl.Header>
<ui:ToggleSwitch AutomationProperties.Name="{x:Static res:Strings.Settings_FpsDecimals_Label}" IsChecked="{Binding ViewModel.FpsTwoDecimals, Mode=TwoWay}" />
</ui:CardControl>
<!-- beta.14 (owner request 2026-10-05): no scroll bars drawn; the wheel, the keyboard and touch still scroll. -->
<ui:CardControl Margin="0,8,0,0" Icon="{ui:SymbolIcon ArrowSortDownLines24}">
<ui:CardControl.Header>
<StackPanel>
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static res:Strings.Settings_HideScrollBars_Label}" />
<ui:TextBlock MaxWidth="520" HorizontalAlignment="Left" Appearance="Secondary" TextWrapping="Wrap"
Text="{x:Static res:Strings.Settings_HideScrollBars_Body}" />
</StackPanel>
</ui:CardControl.Header>
<ui:ToggleSwitch AutomationProperties.Name="{x:Static res:Strings.Settings_HideScrollBars_Label}" IsChecked="{Binding ViewModel.HideScrollBars, Mode=TwoWay}" />
</ui:CardControl>
<!--
Updates, logging, legal. The Privacy card — the `privacy.online_metadata` toggle — is not shown
+23 -2
View File
@@ -75,6 +75,24 @@ public static class Formats
/// <summary>A GPU's power as <c>215 W</c>; null → N/A.</summary>
public static string Power(double? watts) => watts is double w ? w.ToString("0", CultureInfo.CurrentCulture) + " W" : Strings.Common_NotAvailable;
/// <summary>
/// A share of time or of frames as <c>9.6%</c> (beta.14) — one decimal, because the small shares are the telling ones: a
/// game held at its limit reads 0.4 % below it, not "0%"; null → N/A, never 0%.
/// </summary>
public static string Share(double? pct) => pct is double v ? v.ToString("0.0", CultureInfo.CurrentCulture) + "%" : Strings.Common_NotAvailable;
/// <summary>A frame-time difference as <c>0.88 ms</c> (beta.14); null → N/A.</summary>
public static string Milliseconds(double? ms) => ms is double v ? string.Format(CultureInfo.CurrentCulture, Strings.Format_Milliseconds_Format, v) : Strings.Common_NotAvailable;
/// <summary>Application frames per joule as <c>0.31 FPS/W</c> (beta.14) — frames per second over watts; null → N/A.</summary>
public static string FramesPerJoule(double? perJoule) => perJoule is double v ? string.Format(CultureInfo.CurrentCulture, Strings.Format_FramesPerJoule_Format, v) : Strings.Common_NotAvailable;
/// <summary>A clock as <c>2,655 MHz</c> (beta.14); null → N/A.</summary>
public static string Frequency(double? mhz) => mhz is double f ? string.Format(CultureInfo.CurrentCulture, Strings.Format_Frequency_Format, f) : Strings.Common_NotAvailable;
/// <summary>A fan's speed as <c>1,450 RPM</c> (beta.14); null → N/A.</summary>
public static string Rpm(double? rpm) => rpm is double r ? string.Format(CultureInfo.CurrentCulture, Strings.Format_Rpm_Format, r) : Strings.Common_NotAvailable;
/// <summary><c>1485×835 → 2560×1440</c>, or one pair when only one is known, or N/A.</summary>
public static string Resolution(int? renderW, int? renderH, int? outputW, int? outputH)
{
@@ -407,13 +425,16 @@ public static class Formats
/// <summary>
/// How a session ended, in words (beta.8): a crash names its exception ("crashed (0xC0000005 access violation)"), an
/// exit code that is not one is an ordinary end with its code — End task's 1 said as what it is — and the other
/// statuses keep their words.
/// statuses keep their words. Since beta.14 a crash witnessed by the engine's crash reporter names it ("crashed (the
/// game started its crash reporter, CrashReportClient.exe)"): the exception's code first, then the reporter, then the log.
/// </summary>
public static string ExitText(ExitStatus status, CaptureNotes notes) => status switch
{
ExitStatus.Crashed => notes.ExitCode is { } code && ExitStatusMapper.IsExceptionCode(code)
? string.Format(CultureInfo.CurrentCulture, Strings.Exit_Crashed_Format, ExceptionName(code))
: Strings.Exit_CrashEvent,
: notes.CrashReporter is { Length: > 0 } reporter
? string.Format(CultureInfo.CurrentCulture, Strings.Exit_CrashReporter_Format, reporter)
: Strings.Exit_CrashEvent,
ExitStatus.Normal => notes.ExitCode switch
{
null or 0 => Strings.Exit_EndedNormally,
@@ -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.Controls;
using System.Windows.Data;
using FrameLedger.App.Dialogs;
using FrameLedger.App.ViewModels;
@@ -10,7 +11,11 @@ using Wpf.Ui.Controls;
namespace FrameLedger.App.Services;
/// <summary>FR-1.2's review checklist in WPF UI: a <c>ContentDialog</c> whose primary button follows the tick count; Cancel adds nothing.</summary>
/// <summary>
/// FR-1.2's review checklist in WPF UI: a <c>ContentDialog</c> whose primary button follows the tick count; Cancel adds nothing.
/// The dialog's own scrolling is off (beta.14): its content row then has the height the window leaves, the list fills it and is
/// the one thing that scrolls — a scrolling list inside a scrolling dialog pushed the intro out of sight at the list's end.
/// </summary>
public sealed class ImportReviewPrompt : IImportReview
{
private readonly IContentDialogService _dialogs;
@@ -21,18 +26,24 @@ public sealed class ImportReviewPrompt : IImportReview
{
ArgumentNullException.ThrowIfNull(candidates);
var viewModel = new ImportReviewViewModel(candidates);
var dialog = new ContentDialog
{
Title = ImportReviewViewModel.Title,
Content = new ImportReviewContent(viewModel),
PrimaryButtonText = Strings.Import_Add,
CloseButtonText = Strings.Common_Cancel,
DefaultButton = ContentDialogButton.Primary,
DialogMaxWidth = 900,
};
ContentDialog dialog = Create(viewModel);
_ = dialog.SetBinding(ContentDialog.IsPrimaryButtonEnabledProperty, new Binding(nameof(ImportReviewViewModel.CanImport)) { Source = viewModel, Mode = BindingMode.OneWay });
ContentDialogResult result = await _dialogs.ShowAsync(dialog, ct).ConfigureAwait(true);
return result == ContentDialogResult.Primary ? viewModel.Selected : null;
}
/// <summary>The dialog as shown, without a host: a test lays it out in one of its own.</summary>
internal static ContentDialog Create(ImportReviewViewModel viewModel, ContentDialogHost? host = null)
{
ContentDialog dialog = host is null ? new ContentDialog() : new ContentDialog(host);
dialog.Title = ImportReviewViewModel.Title;
dialog.Content = new ImportReviewContent(viewModel);
dialog.PrimaryButtonText = Strings.Import_Add;
dialog.CloseButtonText = Strings.Common_Cancel;
dialog.DefaultButton = ContentDialogButton.Primary;
dialog.DialogMaxWidth = 900;
ScrollViewer.SetVerticalScrollBarVisibility(dialog, ScrollBarVisibility.Disabled);
return dialog;
}
}
@@ -8,13 +8,13 @@ namespace FrameLedger.App.Services;
/// <summary>
/// Links into the repository at the source THIS build was made from (beta.12): <c>release.yml</c> passes the release's tag
/// (<c>-p:FrameLedgerSourceRef=v0.1.0-beta.12</c>, a rehearsal its commit), which the App csproj stamps as assembly
/// metadata; a local build carries none and links to <c>main</c>. Until beta.12 every link said <c>blob/main</c>, so an
/// (<c>-p:FrameLedgerSourceRef=v0.1.0-beta.12</c>, a rehearsal its commit), which <c>Directory.Build.props</c> stamps as
/// assembly metadata (the App csproj until beta.14); a local build carries none and links to <c>main</c>. Until beta.12 every link said <c>blob/main</c>, so an
/// installed release opened documents that had moved on since it was built — a different EULA from the one it showed.
/// </summary>
public static partial class RepositoryLinks
{
/// <summary>The metadata key the App csproj writes.</summary>
/// <summary>The metadata key <c>Directory.Build.props</c> writes.</summary>
public const string MetadataKey = "FrameLedgerSourceRef";
/// <summary>The branch a build without a stamped source links to.</summary>
@@ -0,0 +1,122 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
namespace FrameLedger.App.Services;
/// <summary>
/// <c>ui.hide_scrollbars</c> (beta.14, owner request 2026-10-05): the App draws no scroll bars, and every scroller still
/// scrolls — with the wheel, the keyboard and touch. A bar's visibility is bound in its scroller's template, so no style can
/// reach it; this sets the scroller's own <see cref="ScrollBarVisibility"/> instead. One class handler on
/// <see cref="ScrollViewer"/>'s <c>Loaded</c>, registered at start beside <see cref="DialogKeyboard"/>, sees every scroller the
/// App shows, those inside a control's template too (a DataGrid's, a TextBox's, a rendered document's, a dialog's). While
/// on, an axis whose bar is <see cref="ScrollBarVisibility.Auto"/> or <see cref="ScrollBarVisibility.Visible"/> becomes
/// <see cref="ScrollBarVisibility.Hidden"/> — WPF's "no bar, still scrolls" — and its own value is remembered on it;
/// <see cref="ScrollBarVisibility.Disabled"/> is never touched, because a disabled axis lays its content out at the viewport's
/// size and wraps text. Off puts every remembered value back, on screen at once and on the next load for the rest.
/// </summary>
public static class ScrollBarHiding
{
private static readonly DependencyProperty _ownVerticalProperty =
DependencyProperty.RegisterAttached("OwnVertical", typeof(ScrollBarVisibility?), typeof(ScrollBarHiding), new PropertyMetadata(null));
private static readonly DependencyProperty _ownHorizontalProperty =
DependencyProperty.RegisterAttached("OwnHorizontal", typeof(ScrollBarVisibility?), typeof(ScrollBarHiding), new PropertyMetadata(null));
private static volatile bool _hidden;
private static int _registered;
/// <summary>Whether the bars are hidden right now.</summary>
public static bool Hidden => _hidden;
/// <summary>Registers the class handler, once per process.</summary>
public static void Register()
{
if (Interlocked.Exchange(ref _registered, 1) == 0)
{
EventManager.RegisterClassHandler(typeof(ScrollViewer), FrameworkElement.LoadedEvent, new RoutedEventHandler(OnLoaded), handledEventsToo: true);
}
}
/// <summary>
/// Sets the preference and applies it to every scroller of every open window — at once on the App's own thread, where
/// Settings changes it; from any other thread the windows are visited when that thread's dispatcher next runs.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "VSTHRD001:Avoid legacy thread switching APIs", Justification = "a WPF application has no JoinableTaskFactory; the windows belong to the dispatcher's thread, and posting to it never blocks (UiThread does the same)")]
public static void Apply(bool hidden)
{
_hidden = hidden;
if (System.Windows.Application.Current is not { } app)
{
return;
}
if (app.Dispatcher.CheckAccess())
{
ApplyToWindows(app);
}
else
{
_ = app.Dispatcher.InvokeAsync(() => ApplyToWindows(app));
}
}
private static void ApplyToWindows(System.Windows.Application app)
{
foreach (Window window in app.Windows)
{
ApplyUnder(window);
}
}
/// <summary>Applies the current preference to every scroller under <paramref name="root"/>: an open window, or a test's tree.</summary>
public static void ApplyUnder(DependencyObject root)
{
ArgumentNullException.ThrowIfNull(root);
if (root is ScrollViewer viewer)
{
Set(viewer);
}
int count = VisualTreeHelper.GetChildrenCount(root);
for (int i = 0; i < count; i++)
{
ApplyUnder(VisualTreeHelper.GetChild(root, i));
}
}
private static void OnLoaded(object sender, RoutedEventArgs e)
{
if (sender is ScrollViewer viewer)
{
Set(viewer);
}
}
private static void Set(ScrollViewer viewer)
{
Axis(viewer, ScrollViewer.VerticalScrollBarVisibilityProperty, _ownVerticalProperty);
Axis(viewer, ScrollViewer.HorizontalScrollBarVisibilityProperty, _ownHorizontalProperty);
}
private static void Axis(ScrollViewer viewer, DependencyProperty axis, DependencyProperty own)
{
var remembered = (ScrollBarVisibility?)viewer.GetValue(own);
if (_hidden)
{
if (remembered is null && viewer.GetValue(axis) is ScrollBarVisibility current and (ScrollBarVisibility.Auto or ScrollBarVisibility.Visible))
{
viewer.SetValue(own, current);
viewer.SetCurrentValue(axis, ScrollBarVisibility.Hidden);
}
}
else if (remembered is { } value)
{
viewer.ClearValue(own);
viewer.SetCurrentValue(axis, value);
}
}
}
@@ -49,14 +49,28 @@ public static class SensorStatsTable
SensorSeriesCatalog.GameRamPrivate => Strings.Sensors_Series_GameRam,
SensorSeriesCatalog.GameRamWorkingSet => Strings.Sensors_Series_GameRamWs,
SensorSeriesCatalog.GameCommit => Strings.Sensors_Series_GameCommit,
SensorSeriesCatalog.GpuCoreClock => Strings.Sensors_Series_GpuCoreClock,
SensorSeriesCatalog.GpuMemClock => Strings.Sensors_Series_GpuMemClock,
SensorSeriesCatalog.GpuFan => Strings.Sensors_Series_GpuFan,
SensorSeriesCatalog.GpuMemTemp => Strings.Sensors_Series_GpuMemTemp,
SensorSeriesCatalog.GpuPowerLimit => Strings.Sensors_Series_GpuPowerLimit,
SensorSeriesCatalog.GpuThermalLimit => Strings.Sensors_Series_GpuThermalLimit,
_ => series,
};
/// <summary>
/// Each series in its own unit. Until beta.14 everything that was not a temperature, a load or a power was memory — so a
/// clock stored after it would have printed its MHz as megabytes; a series this build does not know prints as itself.
/// </summary>
private static Func<double?, string> FormatOf(string series) => series switch
{
SensorSeriesCatalog.GpuTemp or SensorSeriesCatalog.GpuHotspot or SensorSeriesCatalog.CpuTemp => Formats.Temperature,
SensorSeriesCatalog.GpuLoad or SensorSeriesCatalog.CpuLoad => Formats.Percent,
SensorSeriesCatalog.GpuTemp or SensorSeriesCatalog.GpuHotspot or SensorSeriesCatalog.CpuTemp or SensorSeriesCatalog.GpuMemTemp => Formats.Temperature,
SensorSeriesCatalog.GpuLoad or SensorSeriesCatalog.CpuLoad or SensorSeriesCatalog.GpuPowerLimit or SensorSeriesCatalog.GpuThermalLimit => Formats.Percent,
SensorSeriesCatalog.GpuPower => Formats.Power,
_ => Formats.Memory,
SensorSeriesCatalog.GpuCoreClock or SensorSeriesCatalog.GpuMemClock => Formats.Frequency,
SensorSeriesCatalog.GpuFan => Formats.Rpm,
SensorSeriesCatalog.VramAdapter or SensorSeriesCatalog.RamSystem or SensorSeriesCatalog.GameVramDedicated or SensorSeriesCatalog.GameVramShared
or SensorSeriesCatalog.GameRamPrivate or SensorSeriesCatalog.GameRamWorkingSet or SensorSeriesCatalog.GameCommit => Formats.Memory,
_ => static v => v?.ToString("N1", CultureInfo.CurrentCulture) ?? Strings.Common_NotAvailable,
};
}
+198
View File
@@ -106,6 +106,7 @@ public static class Strings
nameof(Chart_Axis_Fps),
nameof(Chart_Axis_Frametime),
nameof(Chart_Axis_Percentile),
nameof(Chart_Axis_RenderScale),
nameof(Chart_Axis_Sensor),
nameof(Chart_Axis_Time),
nameof(Chart_Axis_TimeFromFirstFrame),
@@ -115,6 +116,7 @@ public static class Strings
nameof(Chart_Note_NoApplicationFrames),
nameof(Chart_Note_OutsideRange_Format),
nameof(Chart_Note_PresentsTiming),
nameof(Chart_RenderScale_NotMeasured),
nameof(Chart_Series_AppFrames),
nameof(Chart_Series_Displayed),
nameof(Chart_Series_GpuLoad),
@@ -156,19 +158,28 @@ public static class Strings
nameof(Compare_Metric_Display),
nameof(Compare_Metric_Displayed),
nameof(Compare_Metric_Duration),
nameof(Compare_Metric_Efficiency),
nameof(Compare_Metric_FrameToFrame),
nameof(Compare_Metric_GameRamMedian),
nameof(Compare_Metric_GameRamPeak),
nameof(Compare_Metric_GameVramMedian),
nameof(Compare_Metric_GameVramPeak),
nameof(Compare_Metric_GpuCoreClock),
nameof(Compare_Metric_MaxCpuTemp),
nameof(Compare_Metric_MaxGpuMemTemp),
nameof(Compare_Metric_MaxGpuTemp),
nameof(Compare_Metric_Median),
nameof(Compare_Metric_Monitor),
nameof(Compare_Metric_Native),
nameof(Compare_Metric_P01Low),
nameof(Compare_Metric_P1Low),
nameof(Compare_Metric_PowerLimit),
nameof(Compare_Metric_Presented),
nameof(Compare_Metric_RenderScale),
nameof(Compare_Metric_StutterPct),
nameof(Compare_Metric_TimeBelow60),
nameof(Compare_Metric_TimeBelowRefresh),
nameof(Compare_Metric_Vsync),
nameof(Compare_Metric_Window),
nameof(Compare_Mixed_Body),
nameof(Compare_Mixed_Legend),
@@ -304,6 +315,7 @@ public static class Strings
nameof(Exit_Crashed),
nameof(Exit_Crashed_Format),
nameof(Exit_CrashEvent),
nameof(Exit_CrashReporter_Format),
nameof(Exit_Degraded),
nameof(Exit_EndedNormally),
nameof(Exit_Ex_AccessViolation),
@@ -374,12 +386,16 @@ public static class Strings
nameof(FirstRun_Title),
nameof(Format_Duration_HoursMinutes_Format),
nameof(Format_Duration_MinutesSeconds_Format),
nameof(Format_FramesPerJoule_Format),
nameof(Format_Frequency_Format),
nameof(Format_Memory_Gb_Format),
nameof(Format_Memory_Mb_Format),
nameof(Format_Milliseconds_Format),
nameof(Format_Playtime_Hours_Format),
nameof(Format_Playtime_Minutes_Format),
nameof(Format_Resolution_Format),
nameof(Format_Resolution_Single_Format),
nameof(Format_Rpm_Format),
nameof(Format_Temperature_Format),
nameof(Fps_Census_NoRuntime),
nameof(Fps_Census_NoRuntime_Tooltip),
@@ -675,8 +691,13 @@ public static class Strings
nameof(Rules_Update_NoAgent),
nameof(Rules_Update_Title),
nameof(Sensors_Axis_Gb),
nameof(Sensors_Axis_Mhz),
nameof(Sensors_Axis_Rpm),
nameof(Sensors_Axis_Watts),
nameof(Sensors_Clocks_Header),
nameof(Sensors_Empty),
nameof(Sensors_Limit_Power),
nameof(Sensors_Limit_Thermal),
nameof(Sensors_Ram_Header),
nameof(Sensors_Series_CpuLoad),
nameof(Sensors_Series_CpuTemp),
@@ -685,10 +706,16 @@ public static class Strings
nameof(Sensors_Series_GameRamWs),
nameof(Sensors_Series_GameVram),
nameof(Sensors_Series_GameVramShared),
nameof(Sensors_Series_GpuCoreClock),
nameof(Sensors_Series_GpuFan),
nameof(Sensors_Series_GpuHotspot),
nameof(Sensors_Series_GpuLoad),
nameof(Sensors_Series_GpuMemClock),
nameof(Sensors_Series_GpuMemTemp),
nameof(Sensors_Series_GpuPower),
nameof(Sensors_Series_GpuPowerLimit),
nameof(Sensors_Series_GpuTemp),
nameof(Sensors_Series_GpuThermalLimit),
nameof(Sensors_Series_Ram),
nameof(Sensors_Series_VramAdapter),
nameof(Sensors_Temps_Header),
@@ -749,6 +776,7 @@ public static class Strings
nameof(Settings_AutoCheck_Body),
nameof(Settings_AutoCheck_Label),
nameof(Settings_Capture_Header),
nameof(Settings_Channel_Auto_Format),
nameof(Settings_Channel_Beta),
nameof(Settings_Channel_Stable),
nameof(Settings_Data_Header),
@@ -769,6 +797,8 @@ public static class Strings
nameof(Settings_Header),
nameof(Settings_HideAntiCheatHooking_Body),
nameof(Settings_HideAntiCheatHooking_Label),
nameof(Settings_HideScrollBars_Body),
nameof(Settings_HideScrollBars_Label),
nameof(Settings_HookedGames_Label),
nameof(Settings_HookedGames_Revoke),
nameof(Settings_Interval_Body),
@@ -842,14 +872,27 @@ public static class Strings
nameof(Summary_Notes_Placeholder),
nameof(Summary_NotFound),
nameof(Summary_Open),
nameof(Summary_RenderScale_Header),
nameof(Summary_Save),
nameof(Summary_Saved),
nameof(Summary_Show_Displayed),
nameof(Summary_Show_Sensors),
nameof(Summary_Stat_Avg),
nameof(Summary_Stat_Below30_Format),
nameof(Summary_Stat_BelowRefresh_Format),
nameof(Summary_Stat_Capture),
nameof(Summary_Stat_Capture_Format),
nameof(Summary_Stat_Clocks_Format),
nameof(Summary_Stat_Cpu),
nameof(Summary_Stat_Display),
nameof(Summary_Stat_DisplayedLow_Format),
nameof(Summary_Stat_Duration),
nameof(Summary_Stat_Efficiency),
nameof(Summary_Stat_Efficiency_Note),
nameof(Summary_Stat_FanMemTemp_Format),
nameof(Summary_Stat_Focus),
nameof(Summary_Stat_Focus_Format),
nameof(Summary_Stat_FrameToFrame),
nameof(Summary_Stat_GameRam),
nameof(Summary_Stat_GameRam_Suffix_Format),
nameof(Summary_Stat_GameRamWs),
@@ -857,16 +900,25 @@ public static class Strings
nameof(Summary_Stat_GameVram),
nameof(Summary_Stat_GameVram_Suffix_Format),
nameof(Summary_Stat_Gpu),
nameof(Summary_Stat_GpuClocks),
nameof(Summary_Stat_GpuLimits),
nameof(Summary_Stat_Limits_Format),
nameof(Summary_Stat_LoadTemp_Format),
nameof(Summary_Stat_Median),
nameof(Summary_Stat_MinMax),
nameof(Summary_Stat_MinMax_Format),
nameof(Summary_Stat_OfFrames_Format),
nameof(Summary_Stat_P01Low),
nameof(Summary_Stat_P1Low),
nameof(Summary_Stat_RaysPerPixel_Format),
nameof(Summary_Stat_RayTracing),
nameof(Summary_Stat_StdDev),
nameof(Summary_Stat_StdDev_Format),
nameof(Summary_Stat_Stutter),
nameof(Summary_Stat_Stutter_Format),
nameof(Summary_Stat_Tearing_Format),
nameof(Summary_Stat_TimeBelow60),
nameof(Summary_Stat_Vsync),
nameof(Summary_Tags_Placeholder),
nameof(Summary_Tier2_Body),
nameof(Summary_Tier2_Why_Blocked_Format),
@@ -931,28 +983,41 @@ public static class Strings
nameof(Trend_Metric_Displayed),
nameof(Trend_Metric_DisplayExclusive),
nameof(Trend_Metric_DisplayWindowed),
nameof(Trend_Metric_Efficiency),
nameof(Trend_Metric_FgFactor),
nameof(Trend_Metric_FrameToFrame),
nameof(Trend_Metric_GameRamMedian),
nameof(Trend_Metric_GameRamPeak),
nameof(Trend_Metric_GameVramMedian),
nameof(Trend_Metric_GameVramPeak),
nameof(Trend_Metric_GpuCoreClock),
nameof(Trend_Metric_Label),
nameof(Trend_Metric_MaxCpuTemp),
nameof(Trend_Metric_MaxGpuMemTemp),
nameof(Trend_Metric_MaxGpuTemp),
nameof(Trend_Metric_NativeFps),
nameof(Trend_Metric_P01Low),
nameof(Trend_Metric_P1Low),
nameof(Trend_Metric_PowerLimitShare),
nameof(Trend_Metric_PresentedFps),
nameof(Trend_Metric_RenderScale),
nameof(Trend_Metric_TimeBelow60),
nameof(Trend_Metric_TimeBelowRefresh),
nameof(Trend_Metric_VsyncShare),
nameof(Trend_Partial_Note),
nameof(Trend_Unit_Celsius),
nameof(Trend_Unit_Factor),
nameof(Trend_Unit_Fps),
nameof(Trend_Unit_FpsPerWatt),
nameof(Trend_Unit_Gigabytes),
nameof(Trend_Unit_Mhz),
nameof(Trend_Unit_Ms),
nameof(Trend_Unit_Percent),
nameof(Trend_Unit_Watts),
nameof(Uninstall_DataFolder_Body),
nameof(Uninstall_DataFolder_Title),
nameof(Update_AgentStillRunning),
nameof(Update_Available_Body_Delta_Format),
nameof(Update_Available_Body_Format),
nameof(Update_Available_Title_Format),
nameof(Update_Banner_Applying_Format),
@@ -974,6 +1039,7 @@ public static class Strings
nameof(Update_Notes_Header),
nameof(Update_NotInstalled),
nameof(Update_OpenReleases),
nameof(Update_PayloadInUse_Format),
nameof(Update_Toast_Body_Format),
nameof(Update_Toast_Title),
nameof(Update_Unsigned_Footer),
@@ -1137,6 +1203,8 @@ public static class Strings
public static string Chart_Axis_Percentile => ResourceManager.GetString(nameof(Chart_Axis_Percentile), Culture) ?? nameof(Chart_Axis_Percentile);
public static string Chart_Axis_RenderScale => ResourceManager.GetString(nameof(Chart_Axis_RenderScale), Culture) ?? nameof(Chart_Axis_RenderScale);
public static string Chart_Axis_Sensor => ResourceManager.GetString(nameof(Chart_Axis_Sensor), Culture) ?? nameof(Chart_Axis_Sensor);
public static string Chart_Axis_Time => ResourceManager.GetString(nameof(Chart_Axis_Time), Culture) ?? nameof(Chart_Axis_Time);
@@ -1155,6 +1223,8 @@ public static class Strings
public static string Chart_Note_PresentsTiming => ResourceManager.GetString(nameof(Chart_Note_PresentsTiming), Culture) ?? nameof(Chart_Note_PresentsTiming);
public static string Chart_RenderScale_NotMeasured => ResourceManager.GetString(nameof(Chart_RenderScale_NotMeasured), Culture) ?? nameof(Chart_RenderScale_NotMeasured);
public static string Chart_Series_AppFrames => ResourceManager.GetString(nameof(Chart_Series_AppFrames), Culture) ?? nameof(Chart_Series_AppFrames);
public static string Chart_Series_Displayed => ResourceManager.GetString(nameof(Chart_Series_Displayed), Culture) ?? nameof(Chart_Series_Displayed);
@@ -1237,6 +1307,10 @@ public static class Strings
public static string Compare_Metric_Duration => ResourceManager.GetString(nameof(Compare_Metric_Duration), Culture) ?? nameof(Compare_Metric_Duration);
public static string Compare_Metric_Efficiency => ResourceManager.GetString(nameof(Compare_Metric_Efficiency), Culture) ?? nameof(Compare_Metric_Efficiency);
public static string Compare_Metric_FrameToFrame => ResourceManager.GetString(nameof(Compare_Metric_FrameToFrame), Culture) ?? nameof(Compare_Metric_FrameToFrame);
public static string Compare_Metric_GameRamMedian => ResourceManager.GetString(nameof(Compare_Metric_GameRamMedian), Culture) ?? nameof(Compare_Metric_GameRamMedian);
public static string Compare_Metric_GameRamPeak => ResourceManager.GetString(nameof(Compare_Metric_GameRamPeak), Culture) ?? nameof(Compare_Metric_GameRamPeak);
@@ -1245,8 +1319,12 @@ public static class Strings
public static string Compare_Metric_GameVramPeak => ResourceManager.GetString(nameof(Compare_Metric_GameVramPeak), Culture) ?? nameof(Compare_Metric_GameVramPeak);
public static string Compare_Metric_GpuCoreClock => ResourceManager.GetString(nameof(Compare_Metric_GpuCoreClock), Culture) ?? nameof(Compare_Metric_GpuCoreClock);
public static string Compare_Metric_MaxCpuTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxCpuTemp), Culture) ?? nameof(Compare_Metric_MaxCpuTemp);
public static string Compare_Metric_MaxGpuMemTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxGpuMemTemp), Culture) ?? nameof(Compare_Metric_MaxGpuMemTemp);
public static string Compare_Metric_MaxGpuTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxGpuTemp), Culture) ?? nameof(Compare_Metric_MaxGpuTemp);
public static string Compare_Metric_Median => ResourceManager.GetString(nameof(Compare_Metric_Median), Culture) ?? nameof(Compare_Metric_Median);
@@ -1259,10 +1337,20 @@ public static class Strings
public static string Compare_Metric_P1Low => ResourceManager.GetString(nameof(Compare_Metric_P1Low), Culture) ?? nameof(Compare_Metric_P1Low);
public static string Compare_Metric_PowerLimit => ResourceManager.GetString(nameof(Compare_Metric_PowerLimit), Culture) ?? nameof(Compare_Metric_PowerLimit);
public static string Compare_Metric_Presented => ResourceManager.GetString(nameof(Compare_Metric_Presented), Culture) ?? nameof(Compare_Metric_Presented);
public static string Compare_Metric_RenderScale => ResourceManager.GetString(nameof(Compare_Metric_RenderScale), Culture) ?? nameof(Compare_Metric_RenderScale);
public static string Compare_Metric_StutterPct => ResourceManager.GetString(nameof(Compare_Metric_StutterPct), Culture) ?? nameof(Compare_Metric_StutterPct);
public static string Compare_Metric_TimeBelow60 => ResourceManager.GetString(nameof(Compare_Metric_TimeBelow60), Culture) ?? nameof(Compare_Metric_TimeBelow60);
public static string Compare_Metric_TimeBelowRefresh => ResourceManager.GetString(nameof(Compare_Metric_TimeBelowRefresh), Culture) ?? nameof(Compare_Metric_TimeBelowRefresh);
public static string Compare_Metric_Vsync => ResourceManager.GetString(nameof(Compare_Metric_Vsync), Culture) ?? nameof(Compare_Metric_Vsync);
public static string Compare_Metric_Window => ResourceManager.GetString(nameof(Compare_Metric_Window), Culture) ?? nameof(Compare_Metric_Window);
public static string Compare_Mixed_Body => ResourceManager.GetString(nameof(Compare_Mixed_Body), Culture) ?? nameof(Compare_Mixed_Body);
@@ -1533,6 +1621,8 @@ public static class Strings
public static string Exit_CrashEvent => ResourceManager.GetString(nameof(Exit_CrashEvent), Culture) ?? nameof(Exit_CrashEvent);
public static string Exit_CrashReporter_Format => ResourceManager.GetString(nameof(Exit_CrashReporter_Format), Culture) ?? nameof(Exit_CrashReporter_Format);
public static string Exit_Degraded => ResourceManager.GetString(nameof(Exit_Degraded), Culture) ?? nameof(Exit_Degraded);
public static string Exit_EndedNormally => ResourceManager.GetString(nameof(Exit_EndedNormally), Culture) ?? nameof(Exit_EndedNormally);
@@ -1673,10 +1763,16 @@ public static class Strings
public static string Format_Duration_MinutesSeconds_Format => ResourceManager.GetString(nameof(Format_Duration_MinutesSeconds_Format), Culture) ?? nameof(Format_Duration_MinutesSeconds_Format);
public static string Format_FramesPerJoule_Format => ResourceManager.GetString(nameof(Format_FramesPerJoule_Format), Culture) ?? nameof(Format_FramesPerJoule_Format);
public static string Format_Frequency_Format => ResourceManager.GetString(nameof(Format_Frequency_Format), Culture) ?? nameof(Format_Frequency_Format);
public static string Format_Memory_Gb_Format => ResourceManager.GetString(nameof(Format_Memory_Gb_Format), Culture) ?? nameof(Format_Memory_Gb_Format);
public static string Format_Memory_Mb_Format => ResourceManager.GetString(nameof(Format_Memory_Mb_Format), Culture) ?? nameof(Format_Memory_Mb_Format);
public static string Format_Milliseconds_Format => ResourceManager.GetString(nameof(Format_Milliseconds_Format), Culture) ?? nameof(Format_Milliseconds_Format);
public static string Format_Playtime_Hours_Format => ResourceManager.GetString(nameof(Format_Playtime_Hours_Format), Culture) ?? nameof(Format_Playtime_Hours_Format);
public static string Format_Playtime_Minutes_Format => ResourceManager.GetString(nameof(Format_Playtime_Minutes_Format), Culture) ?? nameof(Format_Playtime_Minutes_Format);
@@ -1685,6 +1781,8 @@ public static class Strings
public static string Format_Resolution_Single_Format => ResourceManager.GetString(nameof(Format_Resolution_Single_Format), Culture) ?? nameof(Format_Resolution_Single_Format);
public static string Format_Rpm_Format => ResourceManager.GetString(nameof(Format_Rpm_Format), Culture) ?? nameof(Format_Rpm_Format);
public static string Format_Temperature_Format => ResourceManager.GetString(nameof(Format_Temperature_Format), Culture) ?? nameof(Format_Temperature_Format);
public static string Fps_Census_NoRuntime => ResourceManager.GetString(nameof(Fps_Census_NoRuntime), Culture) ?? nameof(Fps_Census_NoRuntime);
@@ -2275,10 +2373,20 @@ public static class Strings
public static string Sensors_Axis_Gb => ResourceManager.GetString(nameof(Sensors_Axis_Gb), Culture) ?? nameof(Sensors_Axis_Gb);
public static string Sensors_Axis_Mhz => ResourceManager.GetString(nameof(Sensors_Axis_Mhz), Culture) ?? nameof(Sensors_Axis_Mhz);
public static string Sensors_Axis_Rpm => ResourceManager.GetString(nameof(Sensors_Axis_Rpm), Culture) ?? nameof(Sensors_Axis_Rpm);
public static string Sensors_Axis_Watts => ResourceManager.GetString(nameof(Sensors_Axis_Watts), Culture) ?? nameof(Sensors_Axis_Watts);
public static string Sensors_Clocks_Header => ResourceManager.GetString(nameof(Sensors_Clocks_Header), Culture) ?? nameof(Sensors_Clocks_Header);
public static string Sensors_Empty => ResourceManager.GetString(nameof(Sensors_Empty), Culture) ?? nameof(Sensors_Empty);
public static string Sensors_Limit_Power => ResourceManager.GetString(nameof(Sensors_Limit_Power), Culture) ?? nameof(Sensors_Limit_Power);
public static string Sensors_Limit_Thermal => ResourceManager.GetString(nameof(Sensors_Limit_Thermal), Culture) ?? nameof(Sensors_Limit_Thermal);
public static string Sensors_Ram_Header => ResourceManager.GetString(nameof(Sensors_Ram_Header), Culture) ?? nameof(Sensors_Ram_Header);
public static string Sensors_Series_CpuLoad => ResourceManager.GetString(nameof(Sensors_Series_CpuLoad), Culture) ?? nameof(Sensors_Series_CpuLoad);
@@ -2295,14 +2403,26 @@ public static class Strings
public static string Sensors_Series_GameVramShared => ResourceManager.GetString(nameof(Sensors_Series_GameVramShared), Culture) ?? nameof(Sensors_Series_GameVramShared);
public static string Sensors_Series_GpuCoreClock => ResourceManager.GetString(nameof(Sensors_Series_GpuCoreClock), Culture) ?? nameof(Sensors_Series_GpuCoreClock);
public static string Sensors_Series_GpuFan => ResourceManager.GetString(nameof(Sensors_Series_GpuFan), Culture) ?? nameof(Sensors_Series_GpuFan);
public static string Sensors_Series_GpuHotspot => ResourceManager.GetString(nameof(Sensors_Series_GpuHotspot), Culture) ?? nameof(Sensors_Series_GpuHotspot);
public static string Sensors_Series_GpuLoad => ResourceManager.GetString(nameof(Sensors_Series_GpuLoad), Culture) ?? nameof(Sensors_Series_GpuLoad);
public static string Sensors_Series_GpuMemClock => ResourceManager.GetString(nameof(Sensors_Series_GpuMemClock), Culture) ?? nameof(Sensors_Series_GpuMemClock);
public static string Sensors_Series_GpuMemTemp => ResourceManager.GetString(nameof(Sensors_Series_GpuMemTemp), Culture) ?? nameof(Sensors_Series_GpuMemTemp);
public static string Sensors_Series_GpuPower => ResourceManager.GetString(nameof(Sensors_Series_GpuPower), Culture) ?? nameof(Sensors_Series_GpuPower);
public static string Sensors_Series_GpuPowerLimit => ResourceManager.GetString(nameof(Sensors_Series_GpuPowerLimit), Culture) ?? nameof(Sensors_Series_GpuPowerLimit);
public static string Sensors_Series_GpuTemp => ResourceManager.GetString(nameof(Sensors_Series_GpuTemp), Culture) ?? nameof(Sensors_Series_GpuTemp);
public static string Sensors_Series_GpuThermalLimit => ResourceManager.GetString(nameof(Sensors_Series_GpuThermalLimit), Culture) ?? nameof(Sensors_Series_GpuThermalLimit);
public static string Sensors_Series_Ram => ResourceManager.GetString(nameof(Sensors_Series_Ram), Culture) ?? nameof(Sensors_Series_Ram);
public static string Sensors_Series_VramAdapter => ResourceManager.GetString(nameof(Sensors_Series_VramAdapter), Culture) ?? nameof(Sensors_Series_VramAdapter);
@@ -2423,6 +2543,8 @@ public static class Strings
public static string Settings_Capture_Header => ResourceManager.GetString(nameof(Settings_Capture_Header), Culture) ?? nameof(Settings_Capture_Header);
public static string Settings_Channel_Auto_Format => ResourceManager.GetString(nameof(Settings_Channel_Auto_Format), Culture) ?? nameof(Settings_Channel_Auto_Format);
public static string Settings_Channel_Beta => ResourceManager.GetString(nameof(Settings_Channel_Beta), Culture) ?? nameof(Settings_Channel_Beta);
public static string Settings_Channel_Stable => ResourceManager.GetString(nameof(Settings_Channel_Stable), Culture) ?? nameof(Settings_Channel_Stable);
@@ -2463,6 +2585,10 @@ public static class Strings
public static string Settings_HideAntiCheatHooking_Label => ResourceManager.GetString(nameof(Settings_HideAntiCheatHooking_Label), Culture) ?? nameof(Settings_HideAntiCheatHooking_Label);
public static string Settings_HideScrollBars_Body => ResourceManager.GetString(nameof(Settings_HideScrollBars_Body), Culture) ?? nameof(Settings_HideScrollBars_Body);
public static string Settings_HideScrollBars_Label => ResourceManager.GetString(nameof(Settings_HideScrollBars_Label), Culture) ?? nameof(Settings_HideScrollBars_Label);
public static string Settings_HookedGames_Label => ResourceManager.GetString(nameof(Settings_HookedGames_Label), Culture) ?? nameof(Settings_HookedGames_Label);
public static string Settings_HookedGames_Revoke => ResourceManager.GetString(nameof(Settings_HookedGames_Revoke), Culture) ?? nameof(Settings_HookedGames_Revoke);
@@ -2609,6 +2735,8 @@ public static class Strings
public static string Summary_Open => ResourceManager.GetString(nameof(Summary_Open), Culture) ?? nameof(Summary_Open);
public static string Summary_RenderScale_Header => ResourceManager.GetString(nameof(Summary_RenderScale_Header), Culture) ?? nameof(Summary_RenderScale_Header);
public static string Summary_Save => ResourceManager.GetString(nameof(Summary_Save), Culture) ?? nameof(Summary_Save);
public static string Summary_Saved => ResourceManager.GetString(nameof(Summary_Saved), Culture) ?? nameof(Summary_Saved);
@@ -2619,12 +2747,36 @@ public static class Strings
public static string Summary_Stat_Avg => ResourceManager.GetString(nameof(Summary_Stat_Avg), Culture) ?? nameof(Summary_Stat_Avg);
public static string Summary_Stat_Below30_Format => ResourceManager.GetString(nameof(Summary_Stat_Below30_Format), Culture) ?? nameof(Summary_Stat_Below30_Format);
public static string Summary_Stat_BelowRefresh_Format => ResourceManager.GetString(nameof(Summary_Stat_BelowRefresh_Format), Culture) ?? nameof(Summary_Stat_BelowRefresh_Format);
public static string Summary_Stat_Capture => ResourceManager.GetString(nameof(Summary_Stat_Capture), Culture) ?? nameof(Summary_Stat_Capture);
public static string Summary_Stat_Capture_Format => ResourceManager.GetString(nameof(Summary_Stat_Capture_Format), Culture) ?? nameof(Summary_Stat_Capture_Format);
public static string Summary_Stat_Clocks_Format => ResourceManager.GetString(nameof(Summary_Stat_Clocks_Format), Culture) ?? nameof(Summary_Stat_Clocks_Format);
public static string Summary_Stat_Cpu => ResourceManager.GetString(nameof(Summary_Stat_Cpu), Culture) ?? nameof(Summary_Stat_Cpu);
public static string Summary_Stat_Display => ResourceManager.GetString(nameof(Summary_Stat_Display), Culture) ?? nameof(Summary_Stat_Display);
public static string Summary_Stat_DisplayedLow_Format => ResourceManager.GetString(nameof(Summary_Stat_DisplayedLow_Format), Culture) ?? nameof(Summary_Stat_DisplayedLow_Format);
public static string Summary_Stat_Duration => ResourceManager.GetString(nameof(Summary_Stat_Duration), Culture) ?? nameof(Summary_Stat_Duration);
public static string Summary_Stat_Efficiency => ResourceManager.GetString(nameof(Summary_Stat_Efficiency), Culture) ?? nameof(Summary_Stat_Efficiency);
public static string Summary_Stat_Efficiency_Note => ResourceManager.GetString(nameof(Summary_Stat_Efficiency_Note), Culture) ?? nameof(Summary_Stat_Efficiency_Note);
public static string Summary_Stat_FanMemTemp_Format => ResourceManager.GetString(nameof(Summary_Stat_FanMemTemp_Format), Culture) ?? nameof(Summary_Stat_FanMemTemp_Format);
public static string Summary_Stat_Focus => ResourceManager.GetString(nameof(Summary_Stat_Focus), Culture) ?? nameof(Summary_Stat_Focus);
public static string Summary_Stat_Focus_Format => ResourceManager.GetString(nameof(Summary_Stat_Focus_Format), Culture) ?? nameof(Summary_Stat_Focus_Format);
public static string Summary_Stat_FrameToFrame => ResourceManager.GetString(nameof(Summary_Stat_FrameToFrame), Culture) ?? nameof(Summary_Stat_FrameToFrame);
public static string Summary_Stat_GameRam => ResourceManager.GetString(nameof(Summary_Stat_GameRam), Culture) ?? nameof(Summary_Stat_GameRam);
public static string Summary_Stat_GameRam_Suffix_Format => ResourceManager.GetString(nameof(Summary_Stat_GameRam_Suffix_Format), Culture) ?? nameof(Summary_Stat_GameRam_Suffix_Format);
@@ -2639,6 +2791,12 @@ public static class Strings
public static string Summary_Stat_Gpu => ResourceManager.GetString(nameof(Summary_Stat_Gpu), Culture) ?? nameof(Summary_Stat_Gpu);
public static string Summary_Stat_GpuClocks => ResourceManager.GetString(nameof(Summary_Stat_GpuClocks), Culture) ?? nameof(Summary_Stat_GpuClocks);
public static string Summary_Stat_GpuLimits => ResourceManager.GetString(nameof(Summary_Stat_GpuLimits), Culture) ?? nameof(Summary_Stat_GpuLimits);
public static string Summary_Stat_Limits_Format => ResourceManager.GetString(nameof(Summary_Stat_Limits_Format), Culture) ?? nameof(Summary_Stat_Limits_Format);
public static string Summary_Stat_LoadTemp_Format => ResourceManager.GetString(nameof(Summary_Stat_LoadTemp_Format), Culture) ?? nameof(Summary_Stat_LoadTemp_Format);
public static string Summary_Stat_Median => ResourceManager.GetString(nameof(Summary_Stat_Median), Culture) ?? nameof(Summary_Stat_Median);
@@ -2647,10 +2805,16 @@ public static class Strings
public static string Summary_Stat_MinMax_Format => ResourceManager.GetString(nameof(Summary_Stat_MinMax_Format), Culture) ?? nameof(Summary_Stat_MinMax_Format);
public static string Summary_Stat_OfFrames_Format => ResourceManager.GetString(nameof(Summary_Stat_OfFrames_Format), Culture) ?? nameof(Summary_Stat_OfFrames_Format);
public static string Summary_Stat_P01Low => ResourceManager.GetString(nameof(Summary_Stat_P01Low), Culture) ?? nameof(Summary_Stat_P01Low);
public static string Summary_Stat_P1Low => ResourceManager.GetString(nameof(Summary_Stat_P1Low), Culture) ?? nameof(Summary_Stat_P1Low);
public static string Summary_Stat_RaysPerPixel_Format => ResourceManager.GetString(nameof(Summary_Stat_RaysPerPixel_Format), Culture) ?? nameof(Summary_Stat_RaysPerPixel_Format);
public static string Summary_Stat_RayTracing => ResourceManager.GetString(nameof(Summary_Stat_RayTracing), Culture) ?? nameof(Summary_Stat_RayTracing);
public static string Summary_Stat_StdDev => ResourceManager.GetString(nameof(Summary_Stat_StdDev), Culture) ?? nameof(Summary_Stat_StdDev);
public static string Summary_Stat_StdDev_Format => ResourceManager.GetString(nameof(Summary_Stat_StdDev_Format), Culture) ?? nameof(Summary_Stat_StdDev_Format);
@@ -2659,6 +2823,12 @@ public static class Strings
public static string Summary_Stat_Stutter_Format => ResourceManager.GetString(nameof(Summary_Stat_Stutter_Format), Culture) ?? nameof(Summary_Stat_Stutter_Format);
public static string Summary_Stat_Tearing_Format => ResourceManager.GetString(nameof(Summary_Stat_Tearing_Format), Culture) ?? nameof(Summary_Stat_Tearing_Format);
public static string Summary_Stat_TimeBelow60 => ResourceManager.GetString(nameof(Summary_Stat_TimeBelow60), Culture) ?? nameof(Summary_Stat_TimeBelow60);
public static string Summary_Stat_Vsync => ResourceManager.GetString(nameof(Summary_Stat_Vsync), Culture) ?? nameof(Summary_Stat_Vsync);
public static string Summary_Tags_Placeholder => ResourceManager.GetString(nameof(Summary_Tags_Placeholder), Culture) ?? nameof(Summary_Tags_Placeholder);
public static string Summary_Tier2_Body => ResourceManager.GetString(nameof(Summary_Tier2_Body), Culture) ?? nameof(Summary_Tier2_Body);
@@ -2787,8 +2957,12 @@ public static class Strings
public static string Trend_Metric_DisplayWindowed => ResourceManager.GetString(nameof(Trend_Metric_DisplayWindowed), Culture) ?? nameof(Trend_Metric_DisplayWindowed);
public static string Trend_Metric_Efficiency => ResourceManager.GetString(nameof(Trend_Metric_Efficiency), Culture) ?? nameof(Trend_Metric_Efficiency);
public static string Trend_Metric_FgFactor => ResourceManager.GetString(nameof(Trend_Metric_FgFactor), Culture) ?? nameof(Trend_Metric_FgFactor);
public static string Trend_Metric_FrameToFrame => ResourceManager.GetString(nameof(Trend_Metric_FrameToFrame), Culture) ?? nameof(Trend_Metric_FrameToFrame);
public static string Trend_Metric_GameRamMedian => ResourceManager.GetString(nameof(Trend_Metric_GameRamMedian), Culture) ?? nameof(Trend_Metric_GameRamMedian);
public static string Trend_Metric_GameRamPeak => ResourceManager.GetString(nameof(Trend_Metric_GameRamPeak), Culture) ?? nameof(Trend_Metric_GameRamPeak);
@@ -2797,10 +2971,14 @@ public static class Strings
public static string Trend_Metric_GameVramPeak => ResourceManager.GetString(nameof(Trend_Metric_GameVramPeak), Culture) ?? nameof(Trend_Metric_GameVramPeak);
public static string Trend_Metric_GpuCoreClock => ResourceManager.GetString(nameof(Trend_Metric_GpuCoreClock), Culture) ?? nameof(Trend_Metric_GpuCoreClock);
public static string Trend_Metric_Label => ResourceManager.GetString(nameof(Trend_Metric_Label), Culture) ?? nameof(Trend_Metric_Label);
public static string Trend_Metric_MaxCpuTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxCpuTemp), Culture) ?? nameof(Trend_Metric_MaxCpuTemp);
public static string Trend_Metric_MaxGpuMemTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxGpuMemTemp), Culture) ?? nameof(Trend_Metric_MaxGpuMemTemp);
public static string Trend_Metric_MaxGpuTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxGpuTemp), Culture) ?? nameof(Trend_Metric_MaxGpuTemp);
public static string Trend_Metric_NativeFps => ResourceManager.GetString(nameof(Trend_Metric_NativeFps), Culture) ?? nameof(Trend_Metric_NativeFps);
@@ -2809,8 +2987,18 @@ public static class Strings
public static string Trend_Metric_P1Low => ResourceManager.GetString(nameof(Trend_Metric_P1Low), Culture) ?? nameof(Trend_Metric_P1Low);
public static string Trend_Metric_PowerLimitShare => ResourceManager.GetString(nameof(Trend_Metric_PowerLimitShare), Culture) ?? nameof(Trend_Metric_PowerLimitShare);
public static string Trend_Metric_PresentedFps => ResourceManager.GetString(nameof(Trend_Metric_PresentedFps), Culture) ?? nameof(Trend_Metric_PresentedFps);
public static string Trend_Metric_RenderScale => ResourceManager.GetString(nameof(Trend_Metric_RenderScale), Culture) ?? nameof(Trend_Metric_RenderScale);
public static string Trend_Metric_TimeBelow60 => ResourceManager.GetString(nameof(Trend_Metric_TimeBelow60), Culture) ?? nameof(Trend_Metric_TimeBelow60);
public static string Trend_Metric_TimeBelowRefresh => ResourceManager.GetString(nameof(Trend_Metric_TimeBelowRefresh), Culture) ?? nameof(Trend_Metric_TimeBelowRefresh);
public static string Trend_Metric_VsyncShare => ResourceManager.GetString(nameof(Trend_Metric_VsyncShare), Culture) ?? nameof(Trend_Metric_VsyncShare);
public static string Trend_Partial_Note => ResourceManager.GetString(nameof(Trend_Partial_Note), Culture) ?? nameof(Trend_Partial_Note);
public static string Trend_Unit_Celsius => ResourceManager.GetString(nameof(Trend_Unit_Celsius), Culture) ?? nameof(Trend_Unit_Celsius);
@@ -2819,8 +3007,14 @@ public static class Strings
public static string Trend_Unit_Fps => ResourceManager.GetString(nameof(Trend_Unit_Fps), Culture) ?? nameof(Trend_Unit_Fps);
public static string Trend_Unit_FpsPerWatt => ResourceManager.GetString(nameof(Trend_Unit_FpsPerWatt), Culture) ?? nameof(Trend_Unit_FpsPerWatt);
public static string Trend_Unit_Gigabytes => ResourceManager.GetString(nameof(Trend_Unit_Gigabytes), Culture) ?? nameof(Trend_Unit_Gigabytes);
public static string Trend_Unit_Mhz => ResourceManager.GetString(nameof(Trend_Unit_Mhz), Culture) ?? nameof(Trend_Unit_Mhz);
public static string Trend_Unit_Ms => ResourceManager.GetString(nameof(Trend_Unit_Ms), Culture) ?? nameof(Trend_Unit_Ms);
public static string Trend_Unit_Percent => ResourceManager.GetString(nameof(Trend_Unit_Percent), Culture) ?? nameof(Trend_Unit_Percent);
public static string Trend_Unit_Watts => ResourceManager.GetString(nameof(Trend_Unit_Watts), Culture) ?? nameof(Trend_Unit_Watts);
@@ -2831,6 +3025,8 @@ public static class Strings
public static string Update_AgentStillRunning => ResourceManager.GetString(nameof(Update_AgentStillRunning), Culture) ?? nameof(Update_AgentStillRunning);
public static string Update_Available_Body_Delta_Format => ResourceManager.GetString(nameof(Update_Available_Body_Delta_Format), Culture) ?? nameof(Update_Available_Body_Delta_Format);
public static string Update_Available_Body_Format => ResourceManager.GetString(nameof(Update_Available_Body_Format), Culture) ?? nameof(Update_Available_Body_Format);
public static string Update_Available_Title_Format => ResourceManager.GetString(nameof(Update_Available_Title_Format), Culture) ?? nameof(Update_Available_Title_Format);
@@ -2873,6 +3069,8 @@ public static class Strings
public static string Update_OpenReleases => ResourceManager.GetString(nameof(Update_OpenReleases), Culture) ?? nameof(Update_OpenReleases);
public static string Update_PayloadInUse_Format => ResourceManager.GetString(nameof(Update_PayloadInUse_Format), Culture) ?? nameof(Update_PayloadInUse_Format);
public static string Update_Toast_Body_Format => ResourceManager.GetString(nameof(Update_Toast_Body_Format), Culture) ?? nameof(Update_Toast_Body_Format);
public static string Update_Toast_Title => ResourceManager.GetString(nameof(Update_Toast_Title), Culture) ?? nameof(Update_Toast_Title);
+265 -1
View File
@@ -2050,7 +2050,7 @@
<comment>review</comment>
</data>
<data name="Settings_UpdateChannel_Body" xml:space="preserve">
<value>安定版のみ、または安定版とプレリリース。見つかった更新はバックグラウンドでダウンロードされ、再起動時にのみ適用されます。ゲームがフックされている間は適用されません。</value>
<value>自動は、このコピーに合わせます。プレリリース版はプレリリースを、正式版は正式リリースを探します。安定版、またはベータ(安定版とプレリリース)を選ぶこともできます。見つかった更新はバックグラウンドでダウンロードされ、再起動時にのみ適用されます。ゲームがフックされている間は適用されません。</value>
<comment>review</comment>
</data>
<data name="Settings_UpdateChannel_Label" xml:space="preserve">
@@ -3841,4 +3841,268 @@
<value>FrameLedger に対するあなたのライセンスです。参考として表示しています。プログラムを実行するために同意する必要はありません(GPLv3 第 9 条)。</value>
<comment>review</comment>
</data>
<data name="Settings_HideScrollBars_Label" xml:space="preserve">
<value>スクロール バーを非表示にする</value>
<comment>review</comment>
</data>
<data name="Settings_HideScrollBars_Body" xml:space="preserve">
<value>アプリ内のどこにもスクロール バーを表示しません。マウス ホイール、キーボード、タッチでのスクロールは引き続き使えます。</value>
<comment>review</comment>
</data>
<data name="Settings_Channel_Auto_Format" xml:space="preserve">
<value>自動({0})</value>
<comment>review</comment>
</data>
<data name="Update_Available_Body_Delta_Format" xml:space="preserve">
<value>バージョン {0} を今すぐダウンロードできます:約 {1} MB(お使いのバージョンからの変更分のみ。適用できない場合は {2} MB の完全なパッケージ)。適用は FrameLedger の再起動時のみで、ゲームがフックされている間は行われません。</value>
<comment>review</comment>
</data>
<data name="Update_PayloadInUse_Format" xml:space="preserve">
<value>{0} は FrameLedger が計測したゲームにまだ読み込まれているため、更新は途中で失敗します。そのゲームを終了してから、再起動して更新してください。</value>
<comment>review</comment>
</data>
<data name="Exit_CrashReporter_Format" xml:space="preserve">
<value>クラッシュ(ゲームがクラッシュ レポーター {0} を起動しました)</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuCoreClock" xml:space="preserve">
<value>GPU コアクロック MHz</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuMemClock" xml:space="preserve">
<value>GPU メモリクロック MHz</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuFan" xml:space="preserve">
<value>GPU ファン RPM</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuMemTemp" xml:space="preserve">
<value>GPU メモリ °C</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuPowerLimit" xml:space="preserve">
<value>GPU 電力制限 %</value>
<comment>review</comment>
</data>
<data name="Sensors_Series_GpuThermalLimit" xml:space="preserve">
<value>GPU 温度制限 %</value>
<comment>review</comment>
</data>
<data name="Format_Frequency_Format" xml:space="preserve">
<value>{0:N0} MHz</value>
<comment>review</comment>
</data>
<data name="Format_Rpm_Format" xml:space="preserve">
<value>{0:N0} RPM</value>
<comment>review</comment>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
<comment>review</comment>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>30 未満: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>表示 {0} Hz 未満: {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>フレームの {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>ティアリング許可: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>レイトレーシング</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>1 ピクセルあたり {0:0.00} レイ</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>ゲームがアクティブ</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>時間の {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>記録の品質</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>欠落 {0:N0} · 消失 {1:N0} · 障害 {2:N0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>表示: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>GPU クロック</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>コア {0} · メモリ {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>ファン {0} · メモリ {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU の制限</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>電力 {0} · 温度 {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>ゲーム自身のフレーム・GPU 電力のみ</value>
<comment>review</comment>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>レンダースケール</value>
<comment>review</comment>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>レンダースケール %</value>
<comment>review</comment>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>このセッションではレンダー解像度を測定していません。</value>
<comment>review</comment>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>クロックとファン</value>
<comment>review</comment>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
<comment>review</comment>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>RPM</value>
<comment>review</comment>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>電力制限</value>
<comment>review</comment>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>温度制限</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>リフレッシュレート未満の表示 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動 ms</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>レンダースケール %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>VSync の割合 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>平均GPUコアクロック MHz</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>GPU メモリ最高 °C</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>電力制限の割合 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>リフレッシュレート未満の表示</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>VSync の割合</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>レンダースケール</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>平均GPUコアクロック</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>GPU メモリ最高 °C</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>電力制限の割合</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
</root>
+199 -1
View File
@@ -1543,7 +1543,7 @@
<value>Start FrameLedger with Windows</value>
</data>
<data name="Settings_UpdateChannel_Body" xml:space="preserve">
<value>Stable, or stable plus pre-releases. A found update downloads in the background and is applied only when you restart — never while a game is hooked.</value>
<value>Automatic follows this copy: a pre-release looks for pre-releases, a release for releases. Or choose Stable, or Beta (stable plus pre-releases). A found update downloads in the background and is applied only when you restart — never while a game is hooked.</value>
</data>
<data name="Settings_UpdateChannel_Label" xml:space="preserve">
<value>Channel</value>
@@ -2891,4 +2891,202 @@ The documents below are the full terms; this summary does not replace them.</val
<data name="FirstRun_Doc_InformationNote" xml:space="preserve">
<value>Your licence to FrameLedger, shown for information: you do not need to accept it to run the program (GPLv3 section 9).</value>
</data>
<data name="Settings_HideScrollBars_Label" xml:space="preserve">
<value>Hide scroll bars</value>
</data>
<data name="Settings_HideScrollBars_Body" xml:space="preserve">
<value>No scroll bars are drawn anywhere in the app. Everything still scrolls with the mouse wheel, the keyboard and touch.</value>
</data>
<data name="Settings_Channel_Auto_Format" xml:space="preserve">
<value>Automatic ({0})</value>
</data>
<data name="Update_Available_Body_Delta_Format" xml:space="preserve">
<value>Version {0} can be downloaded now: about {1} MB — only what changed since your version, or the full {2} MB package if that cannot be applied. It is applied only when you restart FrameLedger, and never while a game is hooked.</value>
</data>
<data name="Update_PayloadInUse_Format" xml:space="preserve">
<value>{0} is still loaded in a game FrameLedger measured, and the update would fail half way. Close that game, then restart to update.</value>
</data>
<data name="Exit_CrashReporter_Format" xml:space="preserve">
<value>crashed (the game started its crash reporter, {0})</value>
</data>
<data name="Sensors_Series_GpuCoreClock" xml:space="preserve">
<value>GPU core clock MHz</value>
</data>
<data name="Sensors_Series_GpuMemClock" xml:space="preserve">
<value>GPU memory clock MHz</value>
</data>
<data name="Sensors_Series_GpuFan" xml:space="preserve">
<value>GPU fan RPM</value>
</data>
<data name="Sensors_Series_GpuMemTemp" xml:space="preserve">
<value>GPU memory °C</value>
</data>
<data name="Sensors_Series_GpuPowerLimit" xml:space="preserve">
<value>GPU held back by its power limit %</value>
</data>
<data name="Sensors_Series_GpuThermalLimit" xml:space="preserve">
<value>GPU held back by heat %</value>
</data>
<data name="Format_Frequency_Format" xml:space="preserve">
<value>{0:N0} MHz</value>
</data>
<data name="Format_Rpm_Format" xml:space="preserve">
<value>{0:N0} RPM</value>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS</value>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>below 30: {0}</value>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>display under {0} Hz: {1}</value>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>Frame to frame</value>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>{0} of frames</value>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>tearing allowed: {0}</value>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>Ray tracing</value>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>{0:0.00} rays per pixel</value>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>Game in focus</value>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>{0} of the time</value>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>Capture quality</value>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>{0:N0} gaps · {1:N0} lost · {2:N0} faults</value>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>displayed: {0}</value>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>GPU clocks</value>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>{0} core · {1} memory</value>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>fan {0} · memory {1}</value>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU held back</value>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>power {0} · heat {1}</value>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>the game's own frames, GPU power only</value>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>Render scale</value>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>Render scale %</value>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>The render resolution was not measured in this session.</value>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>Clocks and fan</value>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>RPM</value>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>held back by its power limit</value>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>held back by heat</value>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS %</value>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Display under refresh rate %</value>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>Frame to frame ms</value>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>Render scale %</value>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>VSync share %</value>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>Avg GPU core clock MHz</value>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Max GPU memory °C</value>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>Held back by power limit %</value>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS</value>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Display under refresh rate</value>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>Frame to frame</value>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>VSync share</value>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>Render scale</value>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>Avg GPU core clock</value>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Max GPU memory °C</value>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>Held back by power limit</value>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
</root>
+199 -1
View File
@@ -1538,7 +1538,7 @@
<value>Khởi động FrameLedger cùng Windows</value>
</data>
<data name="Settings_UpdateChannel_Body" xml:space="preserve">
<value>Ổn định, hoặc ổn định kèm bản tiền phát hành. Bản cập nhật tìm thấy sẽ tải ở nền và chỉ được áp dụng khi bạn khởi động lại — không bao giờ khi game đang được hook.</value>
<value>Tự động theo bản đang dùng: bản tiền phát hành tìm bản tiền phát hành, bản chính thức tìm bản chính thức. Hoặc chọn Ổn định, hay Beta (ổn định kèm bản tiền phát hành). Bản cập nhật tìm thấy sẽ tải ở nền và chỉ được áp dụng khi bạn khởi động lại — không bao giờ khi game đang được hook.</value>
</data>
<data name="Settings_UpdateChannel_Label" xml:space="preserve">
<value>Kênh</value>
@@ -2886,4 +2886,202 @@ Các văn bản bên dưới là điều khoản đầy đủ; bản tóm tắt
<data name="FirstRun_Doc_InformationNote" xml:space="preserve">
<value>Giấy phép của bạn đối với FrameLedger, hiển thị để bạn biết: bạn không cần chấp nhận nó để chạy chương trình (GPLv3 mục 9).</value>
</data>
<data name="Settings_HideScrollBars_Label" xml:space="preserve">
<value>Ẩn thanh cuộn</value>
</data>
<data name="Settings_HideScrollBars_Body" xml:space="preserve">
<value>Không vẽ thanh cuộn ở bất kỳ đâu trong ứng dụng. Mọi thứ vẫn cuộn được bằng con lăn chuột, bàn phím và cảm ứng.</value>
</data>
<data name="Settings_Channel_Auto_Format" xml:space="preserve">
<value>Tự động ({0})</value>
</data>
<data name="Update_Available_Body_Delta_Format" xml:space="preserve">
<value>Có thể tải phiên bản {0} ngay bây giờ: khoảng {1} MB — chỉ phần thay đổi so với phiên bản của bạn, hoặc gói đầy đủ {2} MB nếu phần đó không áp dụng được. Bản cập nhật chỉ được áp dụng khi bạn khởi động lại FrameLedger, và không bao giờ khi game đang được hook.</value>
</data>
<data name="Update_PayloadInUse_Format" xml:space="preserve">
<value>{0} vẫn đang được nạp trong một game mà FrameLedger đã đo, và bản cập nhật sẽ thất bại giữa chừng. Hãy đóng game đó, rồi khởi động lại để cập nhật.</value>
</data>
<data name="Exit_CrashReporter_Format" xml:space="preserve">
<value>bị crash (game đã mở trình báo lỗi crash của nó, {0})</value>
</data>
<data name="Sensors_Series_GpuCoreClock" xml:space="preserve">
<value>Xung nhịp lõi GPU MHz</value>
</data>
<data name="Sensors_Series_GpuMemClock" xml:space="preserve">
<value>Xung nhịp bộ nhớ GPU MHz</value>
</data>
<data name="Sensors_Series_GpuFan" xml:space="preserve">
<value>Quạt GPU vòng/phút</value>
</data>
<data name="Sensors_Series_GpuMemTemp" xml:space="preserve">
<value>Bộ nhớ GPU °C</value>
</data>
<data name="Sensors_Series_GpuPowerLimit" xml:space="preserve">
<value>GPU bị giới hạn công suất %</value>
</data>
<data name="Sensors_Series_GpuThermalLimit" xml:space="preserve">
<value>GPU bị giới hạn do nhiệt %</value>
</data>
<data name="Format_Frequency_Format" xml:space="preserve">
<value>{0:N0} MHz</value>
</data>
<data name="Format_Rpm_Format" xml:space="preserve">
<value>{0:N0} vòng/phút</value>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS</value>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>dưới 30: {0}</value>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>màn hình dưới {0} Hz: {1}</value>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame</value>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>{0} số frame</value>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>cho phép xé hình: {0}</value>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>Ray tracing</value>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>{0:0.00} tia mỗi điểm ảnh</value>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>Game đang được chọn</value>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>{0} thời gian</value>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>Chất lượng ghi</value>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>{0:N0} khoảng trống · {1:N0} bị mất · {2:N0} lỗi</value>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>hiển thị: {0}</value>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>Xung nhịp GPU</value>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>{0} lõi · {1} bộ nhớ</value>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>quạt {0} · bộ nhớ {1}</value>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU bị giới hạn</value>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>công suất {0} · nhiệt {1}</value>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>chỉ frame của game, chỉ công suất GPU</value>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>Tỉ lệ render</value>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>Tỉ lệ render %</value>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>Phiên này không đo được độ phân giải render.</value>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>Xung nhịp và quạt</value>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>vòng/phút</value>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>bị giới hạn công suất</value>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>bị giới hạn do nhiệt</value>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS %</value>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Màn hình dưới tần số quét %</value>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame ms</value>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>Tỉ lệ render %</value>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>Tỉ lệ VSync %</value>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>Xung nhịp lõi GPU TB MHz</value>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Bộ nhớ GPU tối đa °C</value>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>Bị giới hạn công suất %</value>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS</value>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Màn hình dưới tần số quét</value>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame</value>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>Tỉ lệ VSync</value>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>Tỉ lệ render</value>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>Xung nhịp lõi GPU TB</value>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Bộ nhớ GPU tối đa °C</value>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>Bị giới hạn công suất</value>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
</root>
@@ -22,4 +22,7 @@
<Color x:Key="Chart_Histogram">#CC4CC2FF</Color>
<!-- Not a second gold beside Chart_SensorSecondary (beta.8): the Sensors tab draws both. -->
<Color x:Key="Chart_Percentile">#FFFF79C6</Color>
<!-- beta.14: the seventh line on the temperatures plot (the card's memory temperature) — no colour above is 60 apart
from all six beside it. -->
<Color x:Key="Chart_SensorTertiary">#FFE6E6E6</Color>
</ResourceDictionary>
@@ -18,4 +18,6 @@
<Color x:Key="Chart_Histogram">#CC0A6FB3</Color>
<!-- Not Chart_SensorSecondary's gold (beta.8): the Sensors tab draws both, and in this theme they were one colour. -->
<Color x:Key="Chart_Percentile">#FF795548</Color>
<!-- beta.14: the seventh line on the temperatures plot (the card's memory temperature). -->
<Color x:Key="Chart_SensorTertiary">#FFBE008C</Color>
</ResourceDictionary>
@@ -16,6 +16,12 @@ public interface IUpdateClient
/// <summary>The installed version as the package manifest states it, or null when not installed.</summary>
string? CurrentVersion { get; }
/// <summary>
/// A package an earlier run downloaded and nobody applied, or null — read from the install folder, no feed request
/// (beta.14: with Velopack's own apply-at-start switched off, the App offers it as any other).
/// </summary>
UpdateCandidate? FindPendingRestart();
/// <summary>One feed request; null when the installed version is current.</summary>
/// <exception cref="UpdateException">The feed could not be read.</exception>
Task<UpdateCandidate?> CheckAsync(bool includePrereleases, CancellationToken ct = default);
@@ -0,0 +1,59 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.IO;
namespace FrameLedger.App.Update;
/// <summary>
/// Whether a library FrameLedger loads into games is still loaded in one (beta.14). The Overlay is never unloaded from a live
/// game (<c>17_HOOK_ENGINE</c>), so after a capture is stopped mid-game, or an Agent is restarted, the game keeps
/// <c>current\FrameLedger.Overlay.dll</c> mapped until it exits — and Velopack, which swaps the whole install folder, then
/// fails half way, after the App has already quit. A mapped image cannot be opened for writing (Windows answers with a
/// sharing violation), so the check asks the file system and opens no process: nothing about the game is read.
/// </summary>
public static class PayloadInUse
{
/// <summary>The libraries a game can hold: the Overlay FrameLedger injects, and the Vulkan layer a Vulkan game loads.</summary>
public static IReadOnlyList<string> Files { get; } = ["FrameLedger.Overlay.dll", "FrameLedger.VkLayer.dll"];
private const int _sharingViolation = unchecked((int)0x80070020);
private const int _lockViolation = unchecked((int)0x80070021);
private const int _userMappedFile = unchecked((int)0x800704C8);
/// <summary>The first of <see cref="Files"/> under <paramref name="directory"/> that something still holds, or null.</summary>
public static string? Find(string directory)
{
ArgumentException.ThrowIfNullOrWhiteSpace(directory);
foreach (string name in Files)
{
string path = Path.Combine(directory, name);
if (File.Exists(path) && IsHeld(path))
{
return name;
}
}
return null;
}
private static bool IsHeld(string path)
{
try
{
using (new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
return false;
}
}
catch (IOException ex) when (ex.HResult is _sharingViolation or _lockViolation or _userMappedFile)
{
return true;
}
catch (UnauthorizedAccessException)
{
// Not writable to this user: the updater could not replace it either.
return true;
}
}
}
+5 -2
View File
@@ -5,7 +5,8 @@ namespace FrameLedger.App.Update;
/// <summary>
/// The uninstall hook's decisions (<c>12_BUILD</c> §Publish &amp; package: "uninstalled → unregister the layer, remove
/// the scheduled task, ask about the data folder"), over delegates so a test runs it without a pipe, a registry, a
/// the scheduled task, ask about the data folder" — and since beta.14 remove "Start FrameLedger with Windows", which named an
/// executable the uninstaller deletes), over delegates so a test runs it without a pipe, a registry, a
/// Task Scheduler or a data folder. Every step is independent: a failure in one is logged and the next still
/// runs, and the data folder is deleted only on an explicit yes — a question that goes unanswered inside
/// Velopack's 30 s budget leaves the folder where it is.
@@ -14,6 +15,7 @@ public sealed class UninstallHook(
Func<bool> stopAgent,
Func<bool> unregisterLayer,
Func<bool> removeTask,
Func<bool> removeRunValue,
Func<bool> askDeleteData,
Action deleteData,
Action<string> log)
@@ -23,6 +25,7 @@ public sealed class UninstallHook(
bool agent = Step("agent shutdown", stopAgent);
bool layer = Step("vulkan layer unregister", unregisterLayer);
bool task = Step("logon task remove", removeTask);
bool run = Step("start with windows remove", removeRunValue);
bool asked = false;
bool deleted = false;
if (Step("data folder question", () =>
@@ -38,7 +41,7 @@ public sealed class UninstallHook(
});
}
var outcome = new UninstallOutcome(agent, layer, task, asked, deleted);
var outcome = new UninstallOutcome(agent, layer, task, run, asked, deleted);
log("uninstall: " + outcome);
return outcome;
}
@@ -4,4 +4,4 @@
namespace FrameLedger.App.Update;
/// <summary>What the uninstall hook did, for its log line and its test.</summary>
public sealed record UninstallOutcome(bool AgentAsked, bool LayerUnregistered, bool TaskRemoved, bool DataAsked, bool DataDeleted);
public sealed record UninstallOutcome(bool AgentAsked, bool LayerUnregistered, bool TaskRemoved, bool RunValueRemoved, bool DataAsked, bool DataDeleted);
+10 -2
View File
@@ -3,5 +3,13 @@
namespace FrameLedger.App.Update;
/// <summary>A release newer than the installed one, as the feed describes it: the version, its notes (the GitHub release body, Markdown), the full package's size.</summary>
public sealed record UpdateCandidate(string Version, string? NotesMarkdown, long SizeBytes);
/// <summary>
/// A release newer than the installed one, as the feed describes it: the version, its notes (the GitHub release body,
/// Markdown), the full package's size, and — since beta.14 — the size of the delta packages from the installed version
/// when the feed has them (<see cref="DeltaBytes"/>), which is what Velopack downloads unless they fail to apply.
/// </summary>
public sealed record UpdateCandidate(string Version, string? NotesMarkdown, long SizeBytes)
{
/// <summary>The deltas' size together, or null when there is none and the full package is the download.</summary>
public long? DeltaBytes { get; init; }
}
@@ -0,0 +1,41 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.App.Update;
/// <summary>
/// Which releases a check asks for (beta.14, owner decision D47). <c>update.channel</c> is <c>auto</c> unless the user chose:
/// a copy that is itself a pre-release looks for pre-releases and a release looks for releases. Until beta.14 the default was
/// <c>stable</c> while every release so far is a GitHub pre-release, so a copy left on its defaults never found an update —
/// the owner's own updater log read "No releases found" from the day the ledger was reset. A stored <c>stable</c> or
/// <c>beta</c> is a choice the user made, and it wins.
/// </summary>
public static class UpdateChannelPolicy
{
public const string Automatic = "auto";
public const string Stable = "stable";
public const string Beta = "beta";
/// <summary>Whether a version is a pre-release in SemVer's sense: a <c>-</c> before any build metadata (<c>0.1.0-beta.14</c>).</summary>
public static bool IsPrerelease(string? version)
{
if (string.IsNullOrWhiteSpace(version))
{
return false;
}
int build = version.IndexOf('+', StringComparison.Ordinal);
int dash = version.IndexOf('-', StringComparison.Ordinal);
return dash > 0 && (build < 0 || dash < build);
}
/// <summary>Whether a check on <paramref name="channel"/> asks for pre-releases, for a copy running <paramref name="runningVersion"/>.</summary>
public static bool IncludesPrereleases(string? channel, string? runningVersion) => channel switch
{
Beta => true,
Stable => false,
_ => IsPrerelease(runningVersion),
};
}
@@ -1,7 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
@@ -12,7 +11,7 @@ namespace FrameLedger.App.Update;
/// <summary>
/// <c>11_UPDATER</c> §Error mapping as a function of the exception Velopack's client threw: the HTTP status when
/// there is one (404 → <see cref="UpdateFailure.NotFound"/>, 403/429 → <see cref="UpdateFailure.RateLimited"/>,
/// 5xx → <see cref="UpdateFailure.Server"/>), the transport failures → <see cref="UpdateFailure.Offline"/>, a
/// 5xx → <see cref="UpdateFailure.Server"/>), the transport failures (never a local disk's) → <see cref="UpdateFailure.Offline"/>, a
/// checksum → <see cref="UpdateFailure.Corrupt"/>, the rest → <see cref="UpdateFailure.Unknown"/>. Walks the inner
/// chain, because the source wraps what its downloader threw.
/// </summary>
@@ -40,7 +39,9 @@ public static class UpdateFailureMapper
HttpRequestException { StatusCode: { } status } when (int)status >= 500 => UpdateFailure.Server,
HttpRequestException { StatusCode: null } => UpdateFailure.Offline,
HttpRequestException => UpdateFailure.Unknown,
TaskCanceledException or TimeoutException or SocketException or IOException => UpdateFailure.Offline,
// An I/O error is "offline" only from the network (beta.14): a full disk or a locked file is not, and an IOException
// that wraps a socket error is classified at the socket, one step down the chain.
TaskCanceledException or TimeoutException or SocketException or HttpIOException => UpdateFailure.Offline,
_ => null,
};
}
@@ -9,7 +9,7 @@ using Serilog;
namespace FrameLedger.App.Update;
/// <summary>
/// The startup leg of <c>11_UPDATER</c> §Flow: the silent check 5 s after the host is up (the spec's "5 s after UI
/// The startup leg of <c>11_UPDATER</c> §Flow: a package an earlier run left downloaded offered at once (beta.14), the silent check 5 s after the host is up (the spec's "5 s after UI
/// idle", measured from start because the shell shows synchronously inside it), and — on the first run after an
/// update — the logon task's action path re-validated, because the updater rewrote the install directory
/// (<c>LogonTaskState.Stale</c> is the signal; <c>--install-task</c> the repair, this user's own task).
@@ -27,6 +27,8 @@ internal sealed class UpdateHostedService(UpdateService updates, IMaintenanceSta
await RepairTaskAsync(stoppingToken).ConfigureAwait(false);
}
// A package an earlier run downloaded is offered first, from the install folder; the check then has nothing to do.
updates.AdoptPending();
await Task.Delay(_startupDelay, stoppingToken).ConfigureAwait(false);
await updates.CheckSilentlyAsync(stoppingToken).ConfigureAwait(false);
}
+22 -1
View File
@@ -24,7 +24,7 @@ public sealed class UpdatePrompts(IUrlOpener urls, BugReportFlow bugReports) : I
var body = new StackPanel();
body.Children.Add(new System.Windows.Controls.TextBlock
{
Text = string.Format(CultureInfo.CurrentCulture, Strings.Update_Available_Body_Format, candidate.Version, candidate.SizeBytes / (1024 * 1024)),
Text = OfferText(candidate),
TextWrapping = TextWrapping.Wrap,
});
if (!string.IsNullOrWhiteSpace(candidate.NotesMarkdown))
@@ -50,6 +50,27 @@ public sealed class UpdatePrompts(IUrlOpener urls, BugReportFlow bugReports) : I
return result == MessageBoxResult.Primary;
}
/// <summary>
/// The offer's first line. Since beta.14 it says the download Velopack will make: the deltas from the installed version
/// when the feed has them — 1.6 MB for beta.12 → beta.13 — with the full package named as the fallback; it said the full
/// package's ~102 MB even when the delta was what came.
/// </summary>
public static string OfferText(UpdateCandidate candidate)
{
ArgumentNullException.ThrowIfNull(candidate);
string full = Megabytes(candidate.SizeBytes);
return candidate.DeltaBytes is { } delta && delta < candidate.SizeBytes
? string.Format(CultureInfo.CurrentCulture, Strings.Update_Available_Body_Delta_Format, candidate.Version, Megabytes(delta), full)
: string.Format(CultureInfo.CurrentCulture, Strings.Update_Available_Body_Format, candidate.Version, full);
}
/// <summary>Whole megabytes, one decimal under ten ("1.5", "102").</summary>
private static string Megabytes(long bytes)
{
double mb = bytes / (1024.0 * 1024.0);
return mb.ToString(mb < 10 ? "0.#" : "0", CultureInfo.CurrentCulture);
}
public Task UpToDateAsync(string version, CancellationToken ct = default) =>
ShowAsync(Strings.Menu_Help_CheckUpdates, string.Format(CultureInfo.CurrentCulture, Strings.Update_UpToDate_Format, version), ct);
+61 -7
View File
@@ -20,12 +20,22 @@ namespace FrameLedger.App.Update;
/// the host once the pipe has dropped; Velopack waits for the exit, applies, and restarts the App, which starts
/// the Agent beside itself as it always does.
/// </summary>
/// <remarks>
/// beta.14 (the update audit): Velopack's own apply-at-start is off (<see cref="VelopackHooks"/>), so a package an earlier
/// run downloaded is adopted here (<see cref="AdoptPending"/>) and goes through FR-12 and the Agent's stop like any other —
/// until then the next start applied it inside <c>VelopackApp.Run</c>, killing the Agent, before any of this ran. The
/// channel follows the running copy unless the user chose one (<see cref="UpdateChannelPolicy"/>, D47); an apply waits
/// while a game still has the Overlay loaded (<see cref="PayloadInUse"/>) and while an Agent waits on the administrator
/// prompt; the stop budget outlasts the Agent's own shutdown grace.
/// </remarks>
public sealed partial class UpdateService : ObservableObject, IDisposable
{
private static readonly TimeSpan _defaultAgentStopTimeout = TimeSpan.FromSeconds(10);
/// <summary>The Agent's own shutdown grace (it finalizes its sessions inside it), and five seconds to leave after it.</summary>
internal static readonly TimeSpan DefaultAgentStopTimeout = IpcProtocol.AgentShutdownGrace + TimeSpan.FromSeconds(5);
private readonly TimeSpan _agentStopTimeout;
private readonly Func<bool> _agentHeld;
private readonly Func<string?> _payloadInUse;
private readonly IUpdateClient _client;
private readonly IAgentLink _agent;
private readonly RegisteredSettings _settings;
@@ -47,14 +57,17 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
/// <summary>
/// The flow over its ports; subscribes to the Agent link for the session facts FR-12 needs. <paramref name="agentStopTimeout"/>
/// is how long the apply waits for the Agent to stop after <c>Shutdown</c> (10 s), overridable as a test's clock;
/// <paramref name="agentHeld"/> is whether an Agent process still holds the data folder (the instance lock), a test's own.
/// is how long the apply waits for the Agent to stop after <c>Shutdown</c> (<see cref="DefaultAgentStopTimeout"/>), overridable
/// as a test's clock; <paramref name="agentHeld"/> is whether an Agent process still holds the data folder — its instance
/// lock, or the marker of one waiting on the administrator prompt — and <paramref name="payloadInUse"/> which library a game
/// still has loaded from the install folder, both a test's own.
/// </summary>
public UpdateService(IUpdateClient client, IAgentLink agent, RegisteredSettings settings, IUpdatePrompts prompts, IShellPresence shell, IMessageStrip strip,
TimeSpan? agentStopTimeout = null, Func<bool>? agentHeld = null)
TimeSpan? agentStopTimeout = null, Func<bool>? agentHeld = null, Func<string?>? payloadInUse = null)
{
_agentStopTimeout = agentStopTimeout ?? _defaultAgentStopTimeout;
_agentHeld = agentHeld ?? (static () => Infrastructure.Startup.AgentInstanceLock.IsHeld(Services.UiPaths.DataDirectory));
_agentStopTimeout = agentStopTimeout ?? DefaultAgentStopTimeout;
_agentHeld = agentHeld ?? (static () => AgentHolds(Services.UiPaths.DataDirectory));
_payloadInUse = payloadInUse ?? (static () => PayloadInUse.Find(AppContext.BaseDirectory));
_client = client ?? throw new ArgumentNullException(nameof(client));
_agent = agent ?? throw new ArgumentNullException(nameof(agent));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
@@ -82,6 +95,34 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
_agent.EventReceived -= OnAgentEvent;
}
/// <summary>
/// Whether an Agent holds <paramref name="dataDirectory"/>: its instance lock, or — since beta.14 — the marker of one waiting on
/// the administrator prompt, which holds no lock yet and was stopped by nothing (Velopack's updater killed it).
/// </summary>
internal static bool AgentHolds(string dataDirectory) =>
Infrastructure.Startup.AgentInstanceLock.IsHeld(dataDirectory) || Infrastructure.Startup.ElevationMarker.IsHeld(dataDirectory);
/// <summary>
/// A package an earlier run downloaded and nobody applied (beta.14): Ready, or Deferred while a session runs — no feed request.
/// Velopack applied it at the next start until then, before FR-12 or the Agent's stop could run. Called before the startup check.
/// </summary>
public void AdoptPending()
{
if (!_client.IsInstalled || Stage != UpdateStage.Idle || _client.FindPendingRestart() is not { } pending)
{
return;
}
Log.Information("update: {Version} was downloaded by an earlier run and is waiting for a restart", pending.Version);
_pending = pending;
Post(() =>
{
Version = pending.Version;
Percent = 100;
Settle();
});
}
/// <summary>The startup check: skipped for an uninstalled copy and when the setting is off; every failure is a log line, never a dialog (NFR-10).</summary>
public async Task CheckSilentlyAsync(CancellationToken ct = default)
{
@@ -172,6 +213,7 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
/// Then <c>Shutdown</c> to the Agent, the relaunch held, the pipe watched until it drops, the updater told to
/// wait for this process, and the host ended. An Agent that does not stop in time leaves everything as it was.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format string is a resource that follows the UI culture, which changes at runtime")]
public async Task RestartToUpdateAsync(CancellationToken ct = default)
{
UpdateCandidate? pending = _pending;
@@ -187,6 +229,16 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
return;
}
// A game FrameLedger measured earlier can still have the Overlay loaded from the install folder; the swap would fail
// half way after this App had quit. Asked before the Agent is stopped, so a refusal leaves it running.
if (_payloadInUse() is { } held)
{
Log.Information("update: {File} is still loaded by a running game; the apply waits", held);
Stage = UpdateStage.Ready;
_strip.Warn(Strings.Update_Banner_Title, string.Format(System.Globalization.CultureInfo.CurrentCulture, Strings.Update_PayloadInUse_Format, held));
return;
}
Stage = UpdateStage.Applying;
_agent.SetLaunchHold(true);
if (!await StopAgentAsync(ct).ConfigureAwait(true))
@@ -217,7 +269,9 @@ public sealed partial class UpdateService : ObservableObject, IDisposable
private async Task<UpdateCandidate?> CheckCoreAsync(CancellationToken ct)
{
Post(() => Stage = UpdateStage.Checking);
bool prereleases = string.Equals(await _settings.GetAsync(SettingsRegistry.UpdateChannel, ct).ConfigureAwait(false), "beta", StringComparison.Ordinal);
// D47 (beta.14): `auto` follows this copy; a stored `stable` or `beta` is the user's choice.
string channel = await _settings.GetAsync(SettingsRegistry.UpdateChannel, ct).ConfigureAwait(false);
bool prereleases = UpdateChannelPolicy.IncludesPrereleases(channel, _client.CurrentVersion ?? UiIdentity.Version);
UpdateCandidate? candidate = await _client.CheckAsync(prereleases, ct).ConfigureAwait(false);
if (candidate is null)
{
+33 -3
View File
@@ -21,6 +21,15 @@ namespace FrameLedger.App.Update;
/// is <see cref="UninstallHook"/> over the real pieces. A restart after an update sets <see cref="UpdateRestart"/>
/// so the host re-validates the logon task's action path.
/// </summary>
/// <remarks>
/// beta.14 (the update audit). <b>Velopack's apply-at-start is off</b>: it is on by default, and a package the startup check
/// downloaded was applied by the next start of this executable inside <see cref="VelopackApp.Run"/> — before FR-12 could
/// ask whether a session runs and before the Agent could be stopped; its updater killed the Agent instead ("Killing
/// process: …FrameLedger.Agent.exe", the owner's own log). <c>UpdateService.AdoptPending</c> offers such a package now.
/// Velopack's own diagnostics go to this App's log (<see cref="VelopackSerilogLogger"/>). An update Velopack starts itself — the
/// installer run over an installed copy — asks the Agent to stop first, as the uninstaller does; that hook runs in the
/// version being replaced, so it first works for the update after beta.14.
/// </remarks>
internal static class VelopackHooks
{
/// <summary>
@@ -34,9 +43,19 @@ internal static class VelopackHooks
private static readonly TimeSpan _exitTimeout = TimeSpan.FromSeconds(5);
public static VelopackApp Configure(VelopackApp app) => app
.SetAutoApplyOnStartup(false)
.SetLogger(new VelopackSerilogLogger())
.OnRestarted(static _ => UpdateRestart.Detected = true)
.OnBeforeUpdateFastCallback(static _ => BeforeUpdate())
.OnBeforeUninstallFastCallback(static _ => BeforeUninstall());
/// <summary>Velopack is about to replace this version: the Agent finalizes its sessions and leaves, rather than being killed.</summary>
private static void BeforeUpdate()
{
bool asked = StopAgent();
Log("update.log", "before update: " + (asked ? "the Agent was asked to stop" : "no Agent answered; nothing to stop"));
}
private static void BeforeUninstall()
{
string manifest = Path.Combine(VkLayerLaunchEnvironment.DefaultDirectory, VkLayerLaunchEnvironment.ManifestFileName);
@@ -44,11 +63,22 @@ internal static class VelopackHooks
stopAgent: StopAgent,
unregisterLayer: () => new VkLayerRegistration().Unregister(manifest),
removeTask: static () => new LogonTask().Remove() is null,
removeRunValue: static () =>
{
var run = new RunAtLogonRegistry();
if (!run.IsSet)
{
return false;
}
run.Apply(enabled: false);
return true;
},
askDeleteData: static () => UninstallHook.AreSeparate(UiPaths.DataDirectory, AppContext.BaseDirectory)
? System.Windows.MessageBox.Show(Strings.Uninstall_DataFolder_Body, Strings.Uninstall_DataFolder_Title, MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes
: throw new InvalidOperationException($"the install ({AppContext.BaseDirectory}) and the data folder ({UiPaths.DataDirectory}) overlap; nothing is deleted"),
deleteData: static () => Directory.Delete(UiPaths.DataDirectory, recursive: true),
log: Log);
log: static line => Log("uninstall.log", line));
hook.Run();
}
@@ -109,7 +139,7 @@ internal static class VelopackHooks
}
/// <summary>Serilog is not configured this early; the hook's own file under <c>logs/</c>, appended, never thrown from.</summary>
private static void Log(string line)
private static void Log(string file, string line)
{
try
{
@@ -120,7 +150,7 @@ internal static class VelopackHooks
}
Directory.CreateDirectory(UiPaths.Logs);
File.AppendAllText(Path.Combine(UiPaths.Logs, "uninstall.log"), $"[{DateTimeOffset.UtcNow:O}] {line}{Environment.NewLine}");
File.AppendAllText(Path.Combine(UiPaths.Logs, file), $"[{DateTimeOffset.UtcNow:O}] {line}{Environment.NewLine}");
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
@@ -0,0 +1,30 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using Serilog;
using Serilog.Events;
using Velopack.Logging;
namespace FrameLedger.App.Update;
/// <summary>
/// Velopack's own diagnostics in the App's log (beta.14), each line prefixed <c>velopack:</c> — whether an update came as a
/// delta or as the full package, which processes it stopped, why an apply failed. Until then they were only in Velopack's
/// file under <c>%LOCALAPPDATA%\velopack</c>, which the bug report does not collect. Set in <c>Program.Main</c>, before Serilog
/// is configured: each line reads <see cref="Log.Logger"/> when it is written, so the early ones go nowhere and the rest arrive.
/// </summary>
internal sealed class VelopackSerilogLogger : IVelopackLogger
{
public void Log(VelopackLogLevel logLevel, string? message, Exception? exception) =>
Serilog.Log.Logger.Write(Level(logLevel), exception, "velopack: {Message}", message ?? string.Empty);
internal static LogEventLevel Level(VelopackLogLevel level) => level switch
{
VelopackLogLevel.Trace => LogEventLevel.Verbose,
VelopackLogLevel.Debug => LogEventLevel.Debug,
VelopackLogLevel.Information => LogEventLevel.Information,
VelopackLogLevel.Warning => LogEventLevel.Warning,
VelopackLogLevel.Error => LogEventLevel.Error,
_ => LogEventLevel.Fatal,
};
}
@@ -12,7 +12,8 @@ namespace FrameLedger.App.Update;
/// (<c>11_UPDATER</c>): the stable channel is the releases GitHub does not mark pre-release, the beta channel adds the
/// ones it does (<c>13_CI_CD</c> §Branch &amp; release policy — <c>vX.Y.Z-beta.N</c>). One manager per check, because
/// the channel is a constructor argument there; the <see cref="UpdateInfo"/> a check returned is held for the
/// download and the apply that follow it.
/// download and the apply that follow it — or, since beta.14, the package an earlier run left downloaded
/// (<see cref="FindPendingRestart"/>), which is applied without a download.
/// </summary>
public sealed class VelopackUpdateClient : IUpdateClient
{
@@ -20,12 +21,37 @@ public sealed class VelopackUpdateClient : IUpdateClient
public const string RepositoryUrl = "https://github.com/poli0981/frameledger";
private readonly Lock _lock = new();
private (UpdateManager Manager, UpdateInfo Info, string Version)? _held;
private (UpdateManager Manager, UpdateInfo? Info, VelopackAsset Asset, string Version)? _held;
public bool IsInstalled => Probe(static m => m.IsInstalled, false);
public string? CurrentVersion => Probe(static m => m.CurrentVersion?.ToString(), null);
public UpdateCandidate? FindPendingRestart()
{
try
{
UpdateManager manager = Create(false);
if (manager.UpdatePendingRestart is not { } pending)
{
return null;
}
string version = pending.Version.ToString();
lock (_lock)
{
_held = (manager, null, pending, version);
}
return new UpdateCandidate(version, pending.NotesMarkdown, pending.Size);
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Serilog.Log.Debug(ex, "update: the install folder's pending package could not be read");
return null;
}
}
public async Task<UpdateCandidate?> CheckAsync(bool includePrereleases, CancellationToken ct = default)
{
ct.ThrowIfCancellationRequested();
@@ -42,10 +68,13 @@ public sealed class VelopackUpdateClient : IUpdateClient
string version = target.Version.ToString();
lock (_lock)
{
_held = (manager, info, version);
_held = (manager, info, target, version);
}
return new UpdateCandidate(version, target.NotesMarkdown, target.Size);
// Velopack downloads the deltas from the installed version when the feed has them (beta.13 on), the full
// package when it has none or a delta fails to apply; the offer says the first and names the second.
long? delta = info.DeltasToTarget is { Length: > 0 } deltas ? deltas.Sum(static d => d.Size) : null;
return new UpdateCandidate(version, target.NotesMarkdown, target.Size) { DeltaBytes = delta };
}
catch (Exception ex) when (IsFailure(ex, ct))
{
@@ -55,7 +84,14 @@ public sealed class VelopackUpdateClient : IUpdateClient
public async Task DownloadAsync(UpdateCandidate candidate, IProgress<int>? progress, CancellationToken ct = default)
{
(UpdateManager manager, UpdateInfo info) = Held(candidate);
(UpdateManager manager, UpdateInfo? info, _) = Held(candidate);
if (info is null)
{
// The package an earlier run downloaded: already in place, verified when it was downloaded.
progress?.Report(100);
return;
}
try
{
await manager.DownloadUpdatesAsync(info, p => progress?.Report(p), ct).ConfigureAwait(false);
@@ -69,8 +105,8 @@ public sealed class VelopackUpdateClient : IUpdateClient
/// <summary>Velopack's updater waits up to 60 s for this process to exit; the caller ends the host right after.</summary>
public void ApplyOnExit(UpdateCandidate candidate)
{
(UpdateManager manager, UpdateInfo info) = Held(candidate);
manager.WaitExitThenApplyUpdates(info.TargetFullRelease, silent: false, restart: true);
(UpdateManager manager, _, VelopackAsset asset) = Held(candidate);
manager.WaitExitThenApplyUpdates(asset, silent: false, restart: true);
}
/// <summary>
@@ -99,14 +135,14 @@ public sealed class VelopackUpdateClient : IUpdateClient
}
}
private (UpdateManager Manager, UpdateInfo Info) Held(UpdateCandidate candidate)
private (UpdateManager Manager, UpdateInfo? Info, VelopackAsset Asset) Held(UpdateCandidate candidate)
{
ArgumentNullException.ThrowIfNull(candidate);
lock (_lock)
{
if (_held is { } held && string.Equals(held.Version, candidate.Version, StringComparison.Ordinal))
{
return (held.Manager, held.Info);
return (held.Manager, held.Info, held.Asset);
}
}
@@ -182,13 +182,45 @@ public sealed partial class CompareViewModel : ObservableObject
{
Rows.Clear();
SessionRow[] rows = [.. picked.Select(static c => c.Row)];
AddFrameRows(rows);
AddMachineRows(rows);
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Duration, [.. rows.Select(static r => new CompareCell(Formats.Duration(r.DurationSeconds), false))]));
// beta.10: how each session was shown, both tiers. Facts, not scores: no mode is better than another, so none is best.
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Display, [.. rows.Select(static r => new CompareCell(DisplayText.Shares(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Window, [.. rows.Select(static r => new CompareCell(DisplayText.Window(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Monitor, [.. rows.Select(static r => new CompareCell(DisplayText.Monitor(DisplayText.Of(r)), false))]));
}
/// <summary>
/// The frame rate's rows, hooked sessions only. A statistic a present-only session has over its presents is labelled
/// <c>(presented)</c> in its cell (beta.14, rule 6) — beside a session whose same statistic is over the game's own frames,
/// an unlabelled number would compare two different things as one.
/// </summary>
private void AddFrameRows(SessionRow[] rows)
{
Rows.Add(Row(Strings.Compare_Metric_Native, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Generated or FpsReadoutKind.None } m ? m.Native : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Displayed, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Generated } m ? m.Displayed : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Presented, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Presented or FpsReadoutKind.IdentifiedUncounted } m ? m.Presented : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Median, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.MedianFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_P1Low, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.P1LowFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_P01Low, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.P01LowFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_StutterPct, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.StutterTimePct : null, static v => v is double d ? d.ToString("0.0", CultureInfo.CurrentCulture) + "%" : Strings.Common_NotAvailable, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_Median, rows, static r => Hooked(r, r.MedianFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_P1Low, rows, static r => Hooked(r, r.P1LowFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_P01Low, rows, static r => Hooked(r, r.P01LowFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_StutterPct, rows, static r => Hooked(r, r.StutterTimePct), Formats.Share, higherIsBetter: false, PresentedLabel));
// beta.14 (D49): pacing — less time below 60 and less change from frame to frame is better; the refresh share is the
// display's, over presents, generated frames included, and is named for it rather than labelled presented.
Rows.Add(Row(Strings.Compare_Metric_TimeBelow60, rows, static r => Hooked(r, r.TimeBelow60Pct), Formats.Share, higherIsBetter: false, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_TimeBelowRefresh, rows, static r => Hooked(r, r.TimeBelowRefreshPct), Formats.Share, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_FrameToFrame, rows, static r => Hooked(r, r.FrametimeDeltaMeanMs), Formats.Milliseconds, higherIsBetter: false, PresentedLabel));
// What the presents asked for, and the render scale: settings, not scores — no best.
Rows.Add(Row(Strings.Compare_Metric_Vsync, rows, static r => Hooked(r, r.VsyncPresentPct), Formats.Share, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_RenderScale, rows, static r => r.UpscaleRatio is > 0 ? 100.0 / r.UpscaleRatio.Value : null, Formats.Share, higherIsBetter: null));
}
/// <summary>The machine's rows, both tiers.</summary>
private void AddMachineRows(SessionRow[] rows)
{
Rows.Add(Row(Strings.Compare_Metric_MaxGpuTemp, rows, static r => r.MaxGpuTemp, Formats.Temperature, higherIsBetter: false));
// A load is neither better high nor low (beta.8): a GPU at 99 % may be the bottleneck or simply busy, so neither row
// names a best.
@@ -202,20 +234,28 @@ public sealed partial class CompareViewModel : ObservableObject
Rows.Add(Row(Strings.Compare_Metric_GameVramPeak, rows, static r => r.GameVramDedicatedMaxMb, Formats.Memory, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_GameRamMedian, rows, static r => r.GameRamPrivateMedianMb, Formats.Memory, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_GameRamPeak, rows, static r => r.GameRamPrivateMaxMb, Formats.Memory, higherIsBetter: null));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Duration, [.. rows.Select(static r => new CompareCell(Formats.Duration(r.DurationSeconds), false))]));
// beta.10: how each session was shown, both tiers. Facts, not scores: no mode is better than another, so none is best.
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Display, [.. rows.Select(static r => new CompareCell(DisplayText.Shares(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Window, [.. rows.Select(static r => new CompareCell(DisplayText.Window(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Monitor, [.. rows.Select(static r => new CompareCell(DisplayText.Monitor(DisplayText.Of(r)), false))]));
// beta.14 (D49): the card. A clock and a power limit are facts about the card, not scores; a cooler memory and more
// of the game's own frames per watt are better.
Rows.Add(Row(Strings.Compare_Metric_GpuCoreClock, rows, static r => r.AvgGpuCoreClockMhz, Formats.Frequency, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_MaxGpuMemTemp, rows, static r => r.MaxGpuMemTemp, Formats.Temperature, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_PowerLimit, rows, static r => r.PowerLimitPct, Formats.Share, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_Efficiency, rows, static r => r.AppFramesPerJoule, Formats.FramesPerJoule, higherIsBetter: true));
}
private static double? Hooked(SessionRow row, double? value) => row.Tier == Domain.Sessions.CaptureTier.Hooked ? value : null;
/// <summary>The <c>(presented)</c> label for a hooked session whose statistics are over presents; null otherwise.</summary>
private static string? PresentedLabel(SessionRow row) =>
row.Tier == Domain.Sessions.CaptureTier.Hooked && FpsPresentation.FromRow(row).Kind == FpsReadoutKind.Presented ? Strings.Summary_Lows_Presented : null;
/// <summary>
/// One row: the value per session, the best (never an N/A) flagged; a row where nothing has a value is all N/A and nothing
/// is best, and a row that ranks nothing (<paramref name="higherIsBetter"/> null) flags none. Since beta.8 the best is the
/// best as SHOWN: two sessions that both read "62" are both best — 62.4 against 62.3 is not a difference the reader sees.
/// </summary>
internal static CompareRowViewModel Row(string metric, IReadOnlyList<SessionRow> rows, Func<SessionRow, double?> value, Func<double?, string> text, bool? higherIsBetter)
internal static CompareRowViewModel Row(string metric, IReadOnlyList<SessionRow> rows, Func<SessionRow, double?> value, Func<double?, string> text, bool? higherIsBetter,
Func<SessionRow, string?>? label = null)
{
double?[] values = [.. rows.Select(value)];
double? best = higherIsBetter switch
@@ -225,9 +265,15 @@ public sealed partial class CompareViewModel : ObservableObject
null => null,
};
string? bestText = best.HasValue ? text(best) : null;
return new CompareRowViewModel(metric, [.. values.Select(v => new CompareCell(text(v), bestText is not null && v.HasValue && string.Equals(text(v), bestText, StringComparison.Ordinal)))]);
// The best is decided on the number as shown; a label beside it (beta.14) says what the number is over, not how good.
return new CompareRowViewModel(metric, [.. values.Select((v, i) => new CompareCell(
Labelled(text(v), v.HasValue ? label?.Invoke(rows[i]) : null),
bestText is not null && v.HasValue && string.Equals(text(v), bestText, StringComparison.Ordinal)))]);
}
private static string Labelled(string text, string? label) => label is null ? text : text + " " + label;
private void OnCandidateChanged(object? sender, PropertyChangedEventArgs e)
{
if (string.Equals(e.PropertyName, nameof(CompareCandidateViewModel.IsSelected), StringComparison.Ordinal))
@@ -191,6 +191,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
[ObservableProperty]
private bool _hasLatency;
/// <summary>
/// beta.14: any of the game's sessions measured PC latency, so the Latency tab is shown. Nothing measures Reflex today
/// (<c>sessions.reflex_active</c> is null on every row), and a tab that can only ever say "no data" was noise.
/// </summary>
[ObservableProperty]
private bool _anyLatency;
[ObservableProperty]
private TrendMetric _trendMetric = TrendMetric.PresentedFps;
@@ -344,6 +351,15 @@ public sealed partial class GameDetailViewModel : ObservableObject
new(TrendMetric.DisplayExclusiveShare, Strings.Trend_Metric_DisplayExclusive),
new(TrendMetric.DisplayBorderlessShare, Strings.Trend_Metric_DisplayBorderless),
new(TrendMetric.DisplayWindowedShare, Strings.Trend_Metric_DisplayWindowed),
new(TrendMetric.TimeBelow60, Strings.Trend_Metric_TimeBelow60),
new(TrendMetric.TimeBelowRefresh, Strings.Trend_Metric_TimeBelowRefresh),
new(TrendMetric.FrameToFrame, Strings.Trend_Metric_FrameToFrame),
new(TrendMetric.RenderScale, Strings.Trend_Metric_RenderScale),
new(TrendMetric.VsyncShare, Strings.Trend_Metric_VsyncShare),
new(TrendMetric.GpuCoreClock, Strings.Trend_Metric_GpuCoreClock),
new(TrendMetric.MaxGpuMemTemp, Strings.Trend_Metric_MaxGpuMemTemp),
new(TrendMetric.PowerLimitShare, Strings.Trend_Metric_PowerLimitShare),
new(TrendMetric.Efficiency, Strings.Trend_Metric_Efficiency),
];
/// <summary>The selected session's decoded series (null: none selected, Tier 2, or swept).</summary>
@@ -424,6 +440,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
}
Present(detail);
AnyLatency = detail.Sessions.Any(static s => s.ReflexActive == true);
ChooseDefaultMetric(detail);
await RebuildTrendAsync(ct).ConfigureAwait(true);
}
@@ -168,6 +168,8 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
public static string DistributionHeader => Strings.Summary_Distribution_Header;
public static string RenderScaleHeader => Strings.Summary_RenderScale_Header;
public static string SensorsHeader => Strings.GameDetail_Tab_Sensors;
public static string SensorStatsHeader => Strings.SensorStats_Header;
@@ -395,9 +397,32 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
IReadOnlyDictionary<string, Application.Recording.SensorSeriesStats> stats = Application.Recording.SensorSeriesStats.Parse(row.SensorStatsJson);
string? presented = IsHooked && FpsPresentation.FromRow(row).Kind == FpsReadoutKind.Presented ? Strings.Summary_Lows_Presented : null;
Stats.Clear();
AddFrameCards(row, presented);
AddPacingCards(row, presented);
AddMachineCards(row, stats);
// The table reads what finalize stored; a session from before beta.12 says so rather than computing it here.
SensorStats.Clear();
foreach (SensorStatRowModel line in SensorStatsTable.Rows(stats))
{
SensorStats.Add(line);
}
HasSensorStats = SensorStats.Count > 0;
SensorStatsMissing = !HasSensorStats && (HasSensorCharts || row.AvgGpuLoad is not null || row.MaxGpuTemp is not null) ? Strings.SensorStats_NotStored : null;
}
/// <summary>The frame rate's cards; <paramref name="presented"/> labels the statistics a present-only session has over presents.</summary>
private void AddFrameCards(SessionRow row, string? presented)
{
// CLAUDE.md rule 6 (beta.14): where frames were generated the 1% low is the game's own frames', and the presents' —
// what the display received — stands beside it, never instead of it.
string? displayedLow = IsHooked && Readout.Kind == FpsReadoutKind.Generated && row.DisplayedP1LowFps is double shown
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_DisplayedLow_Format, Formats.Fps(shown))
: null;
Stats.Add(new StatCardModel(Strings.Summary_Stat_Avg, Readout.Line));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Median, IsHooked ? Formats.Fps(row.MedianFps) : Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P1Low, IsHooked ? Formats.Fps(row.P1LowFps) : Strings.Common_NotAvailable, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P1Low, IsHooked ? Formats.Fps(row.P1LowFps) : Strings.Common_NotAvailable, presented ?? displayedLow));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P01Low, IsHooked ? Formats.Fps(row.P01LowFps) : Strings.Common_NotAvailable, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_MinMax, IsHooked ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_MinMax_Format, Formats.Fps(row.MinFps), Formats.Fps(row.MaxFps)) : Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_StdDev, IsHooked && row.FrametimeStdDevMs is double sd ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_StdDev_Format, sd) : Strings.Common_NotAvailable));
@@ -410,8 +435,55 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
string window = DisplayText.Window(display);
Stats.Add(new StatCardModel(Strings.Summary_Stat_Display, DisplayText.Headline(display),
string.Equals(window, Strings.Common_NotAvailable, StringComparison.Ordinal) ? null : window));
}
// The machine, both tiers: telemetry is what a not-hooked session still has. Load is the average, temperature the peak.
/// <summary>
/// beta.14 (D49), hooked sessions: how the frames were paced, what the presents asked for, ray tracing where it was
/// measured, focus, and how complete the record is. A session recorded before beta.14 reads N/A on the new ones.
/// </summary>
private void AddPacingCards(SessionRow row, string? presented)
{
string na = Strings.Common_NotAvailable;
var below = new List<string>(3);
if (IsHooked && row.TimeBelow30Pct is double below30)
{
below.Add(string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Below30_Format, Formats.Share(below30)));
}
// The refresh share is over what the display received — generated frames included — so it is named for the display.
if (IsHooked && row.TimeBelowRefreshPct is double belowRefresh && row.DisplayMonitorHz is int hz)
{
below.Add(string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_BelowRefresh_Format, hz, Formats.Share(belowRefresh)));
}
if (presented is not null)
{
below.Add(presented);
}
Stats.Add(new StatCardModel(Strings.Summary_Stat_TimeBelow60, IsHooked ? Formats.Share(row.TimeBelow60Pct) : na, below.Count == 0 ? null : string.Join(" · ", below)));
Stats.Add(new StatCardModel(Strings.Summary_Stat_FrameToFrame, IsHooked ? Formats.Milliseconds(row.FrametimeDeltaMeanMs) : na, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Vsync,
IsHooked && row.VsyncPresentPct is double vsync ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_OfFrames_Format, Formats.Share(vsync)) : na,
IsHooked && row.TearingAllowedPct is double tearing ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Tearing_Format, Formats.Share(tearing)) : null));
if (IsHooked && row.RtFramePct is double rt)
{
Stats.Add(new StatCardModel(Strings.Summary_Stat_RayTracing, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_OfFrames_Format, Formats.Share(rt)),
row.RaysPerPixel is double rays ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_RaysPerPixel_Format, rays) : null));
}
Stats.Add(new StatCardModel(Strings.Summary_Stat_Focus,
IsHooked && row.DrainTicks is > 0 && row.ForegroundTicks is long focused
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Focus_Format, Formats.Share(focused * 100.0 / row.DrainTicks.Value))
: na));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Capture,
IsHooked ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Capture_Format, row.GapCount, row.DroppedRecords, row.FaultCount) : na));
}
/// <summary>The machine, both tiers: telemetry is what a not-hooked session still has.</summary>
private void AddMachineCards(SessionRow row, IReadOnlyDictionary<string, Application.Recording.SensorSeriesStats> stats)
{
// Load is the average, temperature the peak.
Stats.Add(new StatCardModel(Strings.Summary_Stat_Gpu, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_LoadTemp_Format, Formats.Percent(row.AvgGpuLoad), Formats.Temperature(row.MaxGpuTemp))));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Cpu, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_LoadTemp_Format, Formats.Percent(row.AvgCpuLoad), Formats.Temperature(row.MaxCpuTemp))));
@@ -419,15 +491,18 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
Stats.Add(GameMemoryText.VramCard(row));
Stats.Add(GameMemoryText.RamCard(row, stats));
// The table reads what finalize stored; a session from before beta.12 says so rather than computing it here.
SensorStats.Clear();
foreach (SensorStatRowModel line in SensorStatsTable.Rows(stats))
{
SensorStats.Add(line);
}
HasSensorStats = SensorStats.Count > 0;
SensorStatsMissing = !HasSensorStats && (HasSensorCharts || row.AvgGpuLoad is not null || row.MaxGpuTemp is not null) ? Strings.SensorStats_NotStored : null;
// beta.14 (D49): the card's clocks, fan and memory temperature, what held it back (NVIDIA only), and frames per watt.
bool clocks = row.AvgGpuCoreClockMhz is not null || row.AvgGpuMemClockMhz is not null;
bool fan = row.AvgGpuFanRpm is not null || row.MaxGpuMemTemp is not null;
Stats.Add(new StatCardModel(Strings.Summary_Stat_GpuClocks,
clocks ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Clocks_Format, Formats.Frequency(row.AvgGpuCoreClockMhz), Formats.Frequency(row.AvgGpuMemClockMhz)) : Strings.Common_NotAvailable,
fan ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_FanMemTemp_Format, Formats.Rpm(row.AvgGpuFanRpm), Formats.Temperature(row.MaxGpuMemTemp)) : null));
Stats.Add(new StatCardModel(Strings.Summary_Stat_GpuLimits,
row.PowerLimitPct is not null || row.ThermalLimitPct is not null
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Limits_Format, Formats.Share(row.PowerLimitPct), Formats.Share(row.ThermalLimitPct))
: Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Efficiency, Formats.FramesPerJoule(row.AppFramesPerJoule),
row.AppFramesPerJoule is null ? null : Strings.Summary_Stat_Efficiency_Note));
}
/// <summary>
@@ -105,6 +105,10 @@ public sealed partial class SettingsViewModel : ObservableObject
[ObservableProperty]
private bool _fpsTwoDecimals;
/// <summary><c>ui.hide_scrollbars</c> (beta.14): no scroll bars drawn; every scroller still scrolls.</summary>
[ObservableProperty]
private bool _hideScrollBars;
[ObservableProperty]
private bool _onlineMetadata;
@@ -206,10 +210,16 @@ public sealed partial class SettingsViewModel : ObservableObject
new("ja", "日本語"),
];
/// <summary>
/// D47 (beta.14): Automatic first, its label saying what it resolves to for this copy — "Automatic (Beta)" on a
/// pre-release — then the two explicit choices, either of which wins over the copy.
/// </summary>
public static IReadOnlyList<Choice<string>> UpdateChannels { get; } =
[
new("stable", Strings.Settings_Channel_Stable),
new("beta", Strings.Settings_Channel_Beta),
new(Update.UpdateChannelPolicy.Automatic, string.Format(CultureInfo.CurrentCulture, Strings.Settings_Channel_Auto_Format,
Update.UpdateChannelPolicy.IsPrerelease(UiIdentity.Version) ? Strings.Settings_Channel_Beta : Strings.Settings_Channel_Stable)),
new(Update.UpdateChannelPolicy.Stable, Strings.Settings_Channel_Stable),
new(Update.UpdateChannelPolicy.Beta, Strings.Settings_Channel_Beta),
];
public static double MinSessionMinimum => SettingsRegistry.CaptureMinSessionSeconds.Minimum;
@@ -385,6 +395,18 @@ public sealed partial class SettingsViewModel : ObservableObject
Persist(SettingsRegistry.UiFpsDecimals, value);
}
partial void OnHideScrollBarsChanged(bool value)
{
if (_loading)
{
return;
}
// On screen at once — this page's own bars included — and on every scroller that loads from now on.
ScrollBarHiding.Apply(value);
Persist(SettingsRegistry.UiHideScrollBars, value);
}
partial void OnMinimizeToTrayChanged(bool value)
{
if (!_loading)
@@ -497,6 +519,7 @@ public sealed partial class SettingsViewModel : ObservableObject
UserModeExceptions = await _settings.GetBooleanAsync(SettingsRegistry.HookingUserModeExceptions).ConfigureAwait(true);
RunElevated = await _settings.GetBooleanAsync(SettingsRegistry.CaptureRunElevated).ConfigureAwait(true);
FpsTwoDecimals = await _settings.GetBooleanAsync(SettingsRegistry.UiFpsDecimals).ConfigureAwait(true);
HideScrollBars = await _settings.GetBooleanAsync(SettingsRegistry.UiHideScrollBars).ConfigureAwait(true);
OnlineMetadata = await _settings.GetBooleanAsync(SettingsRegistry.PrivacyOnlineMetadata).ConfigureAwait(true);
UpdateChannel = await _settings.GetAsync(SettingsRegistry.UpdateChannel).ConfigureAwait(true);
AutoCheckUpdates = await _settings.GetBooleanAsync(SettingsRegistry.UpdateAutoCheck).ConfigureAwait(true);
@@ -24,7 +24,7 @@
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<ui:TitleBar Grid.Row="0" Title="{Binding ViewModel.Title}" ShowMaximize="True" ShowMinimize="True" />
<ScrollViewer Grid.Row="1">
<ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto">
<StackPanel Style="{StaticResource PageRoot}">
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:SessionSummaryViewModel.NotFoundText}"
Visibility="{Binding ViewModel.NotFound, Converter={StaticResource BoolToVis}}" />
@@ -115,6 +115,9 @@
<charts:FrametimeChart x:Name="Frametime" Margin="0,6,0,0" Height="300" />
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.DistributionHeader}" />
<charts:DistributionChart x:Name="Distribution" Margin="0,6,0,0" Height="260" />
<!-- beta.14 (D49): the render scale over the session -->
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.RenderScaleHeader}" />
<charts:RenderScaleChart x:Name="RenderScale" Margin="0,6,0,0" Height="200" />
</StackPanel>
<!-- sensors, in either tier (beta.8): a session that was not hooked has nothing else to chart -->
@@ -63,6 +63,7 @@ public partial class SessionSummaryWindow : FluentWindow
{
Frametime.Show(ViewModel.Series, ViewModel.ShowDisplayed, ViewModel.ShowSensors);
Distribution.Show(ViewModel.Series);
RenderScale.Show(ViewModel.Series, ViewModel.Row);
Sensors.Show(ViewModel.SensorSeries);
}
@@ -20,6 +20,13 @@ public sealed record CaptureOutcome
/// </summary>
public bool HookingTurnedOff { get; init; }
/// <summary>
/// D48(b), beta.14: the guard's "could not read" refusal at the last re-scan, when the session concluded as the game's
/// exit rather than a safety unhook because the game itself had already exited (<see cref="ExitScanRelabel"/>); null
/// otherwise. Written to the notes as <c>scan_at_exit=</c>.
/// </summary>
public AntiCheatRefusalReason? ExitScanReason { get; init; }
/// <summary>
/// D33 (owner decision 2026-09-26): the family the game's user-mode exception covered for this session — published to
/// the Overlay and named to the guard at the injection and at every re-scan — or null when none was in force. The
@@ -431,6 +431,9 @@ public sealed class CaptureSession(
// about the game at the 30 s re-scan turns its hooking off exactly as one at the start does (2026-09-22).
AntiCheatVerdict final = end == SessionEndReason.SafetyUnhook && supervisor.LastVerdict is { } fired ? fired : verdict;
bool turnedOff = end == SessionEndReason.SafetyUnhook && await TurnHookingOffAsync(observed, final, ct).ConfigureAwait(false);
// D48(b): a re-scan that could not read, concluded as the game's exit (ExitScanRelabel) — its reason goes in the notes.
AntiCheatRefusalReason? exitScan = end == SessionEndReason.TargetExited && supervisor.LastVerdict is { IsAllowed: false } last
&& ExitScanRelabel.Applies(last.Reason) ? last.Reason : null;
return new CaptureOutcome
{
@@ -440,6 +443,7 @@ public sealed class CaptureSession(
Reason = end,
Verdict = final,
HookingTurnedOff = turnedOff,
ExitScanReason = exitScan,
ExceptionFamily = toleratedFamily,
AttachRefusal = ShmAttachRefusal.Ok,
Records = state.Records,
@@ -555,7 +559,7 @@ public sealed class CaptureSession(
await FlushNativeLogAsync(sink, alive, end, ct).ConfigureAwait(false);
// The switch's stop is the user's, not the guard's: it ends the session as its own reason rather
// than as the safety refusal a false mayContinue would otherwise read as.
return state.KillSwitchStopped ? SessionEndReason.KillSwitchEngaged : Conclude(end, faulted, mayContinue);
return state.KillSwitchStopped ? SessionEndReason.KillSwitchEngaged : Conclude(end, faulted, mayContinue, supervisor.LastVerdict, alive.HasExited);
}
/// <summary>
@@ -738,14 +742,18 @@ public sealed class CaptureSession(
/// <see cref="SessionEndClassifier"/> cannot know that, because the mapping stores
/// one status for both stops.
/// </remarks>
private static SessionEndReason Conclude(SessionEndReason end, Exception? faulted, bool mayContinue)
/// <remarks>
/// D48(b), beta.14: a refusal that says only that the guard could not read, concluded after the game itself has exited
/// (read after the last drain), is the game's exit — <see cref="ExitScanRelabel"/>. A finding never is.
/// </remarks>
private static SessionEndReason Conclude(SessionEndReason end, Exception? faulted, bool mayContinue, AntiCheatVerdict? lastVerdict, bool targetExited)
{
if (faulted is not null)
{
return SessionEndReason.SupervisionFaulted;
}
return mayContinue ? end : SessionEndReason.SafetyUnhook;
return mayContinue ? end : ExitScanRelabel.EndOf(lastVerdict, targetExited);
}
/// <summary>
@@ -0,0 +1,29 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using FrameLedger.Domain.AntiCheat;
namespace FrameLedger.Application.Capture;
/// <summary>
/// Owner decision D48(b), beta.14. The guard's 30 s re-scan reads every process in the game's tree; one that is
/// starting (an engine's crash reporter, as its game dies) or gone could not be read, the scan refused, and the session
/// ended as a <see cref="SessionEndReason.SafetyUnhook"/> — a "safety" stop for a game that had simply exited, which also
/// ended a user-mode exception's trial for good. When the refusal says only that the guard COULD NOT READ and the game
/// itself has exited by the time the session concludes, the session ends as the game's exit
/// (<see cref="SessionEndReason.TargetExited"/>), its exit code deciding normal or crashed, and the scan's reason is kept
/// in the notes (<c>scan_at_exit=</c>). A finding — any anti-cheat the guard identified — is never relabelled, and neither
/// is a refusal while the game still runs.
/// </summary>
public static class ExitScanRelabel
{
/// <summary>The guard's "could not read" refusals of the module check (<c>fl_guard.cpp</c> check 1) — never a finding.</summary>
public static bool Applies(AntiCheatRefusalReason reason) =>
reason is AntiCheatRefusalReason.ProcessUnreadable or AntiCheatRefusalReason.ModuleScanFailed or AntiCheatRefusalReason.ProcessTreeUnavailable;
/// <summary>The end a refused re-scan concludes as: the game's exit when <see cref="Applies"/> and it has exited, else a safety unhook.</summary>
public static SessionEndReason EndOf(AntiCheatVerdict? lastVerdict, bool targetExited) =>
targetExited && lastVerdict is { IsAllowed: false } refused && Applies(refused.Reason)
? SessionEndReason.TargetExited
: SessionEndReason.SafetyUnhook;
}
@@ -343,4 +343,42 @@ public sealed record SessionRow
public string? GameMemorySource { get; init; }
public string? SensorStatsJson { get; init; }
// --- Schema 0019 (beta.14, D49): pacing, the present arguments, the graphics card's clocks and limits, and efficiency
// (03_METRICS §Pacing, §Sync, §Sensor aggregates, §Efficiency). Null on a row written before beta.14 and wherever nothing
// measured the value — never a zero for an answer nobody gave.
/// <summary>Percent of the measured time below 30 FPS (<c>Domain.Metrics.FramePacing</c>).</summary>
public double? TimeBelow30Pct { get; init; }
public double? TimeBelow60Pct { get; init; }
/// <summary>Percent of the presented time below the monitor's refresh rate; null without <see cref="DisplayMonitorHz"/>.</summary>
public double? TimeBelowRefreshPct { get; init; }
/// <summary>Mean change from one frame time to the next, ms.</summary>
public double? FrametimeDeltaMeanMs { get; init; }
/// <summary>Percent of the presents that asked to wait for the display (a sync interval of one or more); Direct3D only.</summary>
public double? VsyncPresentPct { get; init; }
/// <summary>Percent of the presents that allowed tearing; Direct3D only.</summary>
public double? TearingAllowedPct { get; init; }
public double? AvgGpuCoreClockMhz { get; init; }
public double? AvgGpuMemClockMhz { get; init; }
public double? AvgGpuFanRpm { get; init; }
public double? MaxGpuMemTemp { get; init; }
/// <summary>Percent of the sensor ticks the card was held back by its power limit; NVIDIA (L3) only.</summary>
public double? PowerLimitPct { get; init; }
/// <summary>Percent of the sensor ticks the card was held back by heat; NVIDIA (L3) only.</summary>
public double? ThermalLimitPct { get; init; }
/// <summary>Application frames per joule of the card's power — FPS per watt; never over displayed frames (rule 6).</summary>
public double? AppFramesPerJoule { get; init; }
}
@@ -40,6 +40,18 @@ public readonly record struct CaptureNotes(string? End, string? GuardReason, str
/// <summary>D33: the family the game's user-mode exception let through while the session was hooked (<c>ac-exception=</c>).</summary>
public string? AcExceptionFamily { get; init; }
/// <summary>
/// D48(b), beta.14: the guard's "could not read" answer at the last re-scan of a session that ended as the game's exit
/// (<c>scan_at_exit=</c>), or null.
/// </summary>
public string? ScanAtExit { get; init; }
/// <summary>beta.14: the crash reporter the game started that made the session crashed (<c>crash_reporter=</c>), or null.</summary>
public string? CrashReporter { get; init; }
/// <summary>beta.14: a crash reporter the game started that did not count — the game kept running (<c>crash_reporter_seen=</c>).</summary>
public string? CrashReporterSeen { get; init; }
public static CaptureNotes Parse(string? notes)
{
if (string.IsNullOrWhiteSpace(notes))
@@ -47,7 +59,7 @@ public readonly record struct CaptureNotes(string? End, string? GuardReason, str
return default;
}
string? end = null, reason = null, family = null, signal = null, acException = null;
string? end = null, reason = null, family = null, signal = null, acException = null, scanAtExit = null, reporter = null, reporterSeen = null;
int? exitCode = null, launchError = null;
bool crashEvent = false;
foreach (string raw in notes.Split(';'))
@@ -77,6 +89,18 @@ public readonly record struct CaptureNotes(string? End, string? GuardReason, str
{
acException = Blank(part[_acExceptionPrefix.Length..]);
}
else if (part.StartsWith(_scanAtExitPrefix, StringComparison.Ordinal))
{
scanAtExit = Blank(part[_scanAtExitPrefix.Length..]);
}
else if (part.StartsWith(_reporterPrefix, StringComparison.Ordinal))
{
reporter = Blank(part[_reporterPrefix.Length..]);
}
else if (part.StartsWith(_reporterSeenPrefix, StringComparison.Ordinal))
{
reporterSeen = Blank(part[_reporterSeenPrefix.Length..]);
}
}
return new CaptureNotes(end, reason, family, signal)
@@ -85,6 +109,9 @@ public readonly record struct CaptureNotes(string? End, string? GuardReason, str
CrashEvent = crashEvent,
LaunchError = launchError,
AcExceptionFamily = acException,
ScanAtExit = scanAtExit,
CrashReporter = reporter,
CrashReporterSeen = reporterSeen,
};
}
@@ -132,6 +159,12 @@ public readonly record struct CaptureNotes(string? End, string? GuardReason, str
private const string _acExceptionPrefix = "ac-exception=";
private const string _scanAtExitPrefix = "scan_at_exit=";
private const string _reporterPrefix = "crash_reporter=";
private const string _reporterSeenPrefix = "crash_reporter_seen=";
private static string Clean(string? s) => string.IsNullOrEmpty(s) ? string.Empty : s.Replace(';', ',');
private static string? Blank(string s) => s.Length > 0 ? s : null;
@@ -0,0 +1,94 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Globalization;
namespace FrameLedger.Application.Recording;
/// <summary>
/// Whether an Application-log record is a crash of THIS session's game (beta.14). Until then a record with id 1000 or 1001
/// counted when any of its strings CONTAINED the executable's name: Windows' memory-leak report (<c>RADAR_PRE_LEAK_64</c>, a
/// WER 1001 naming <c>witcher3.exe</c>) marked a session that ended with exit code 0 as crashed on the owner's machine, and so
/// would a hang report, another program's crash whose name contains this one's (<c>Game.exe</c> in <c>MyGame.exe</c>), or a
/// crash of a same-image child. Now:
/// <list type="bullet">
/// <item>1000 from <c>Application Error</c>: the faulting application's name equals the executable's, its path (when given)
/// is the executable's, and its process id (when the session held one) is the session's.</item>
/// <item>1001 from <c>Windows Error Reporting</c>: the report is a crash (<see cref="CrashReports"/>) and its first parameter
/// equals the executable's name.</item>
/// </list>
/// The indices are Windows' own templates (read on Windows 11 with <c>Get-WinEvent -ListProvider</c>): 1000 [0] AppName,
/// [8] ProcessId, [10] AppPath; 1001 [2] EventName, [5] P1. Pid and creation time are typed values, not strings.
/// </summary>
public static class CrashEventMatcher
{
public const string ApplicationErrorProvider = "Application Error";
public const string WerProvider = "Windows Error Reporting";
/// <summary>The WER event names that are a crash; a hang (<c>AppHangB1</c>) or a leak report (<c>RADAR_PRE_LEAK_*</c>) is not.</summary>
public static IReadOnlySet<string> CrashReports { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
"APPCRASH", "BEX", "BEX64", "CLR20r3", "MoAppCrash", "MoBEX",
};
public static bool Matches(CrashLogRecord record, CrashQuery query)
{
ArgumentNullException.ThrowIfNull(record);
ArgumentNullException.ThrowIfNull(query);
return record.EventId switch
{
1000 when string.Equals(record.Provider, ApplicationErrorProvider, StringComparison.OrdinalIgnoreCase) => ApplicationError(record.Properties, query),
1001 when string.Equals(record.Provider, WerProvider, StringComparison.OrdinalIgnoreCase) => WerCrash(record.Properties, query),
_ => false,
};
}
private static bool ApplicationError(IReadOnlyList<object?> p, CrashQuery query)
{
if (!SameName(At(p, 0), query.ExeFileName))
{
return false;
}
if (At(p, 10) is string { Length: > 0 } appPath && !SamePath(appPath, query.ExePath))
{
return false;
}
return query.TargetPid == 0 || Number(At(p, 8)) is not { } pid || pid == (ulong)query.TargetPid;
}
private static bool WerCrash(IReadOnlyList<object?> p, CrashQuery query) =>
At(p, 2) is string eventName && CrashReports.Contains(eventName) && SameName(At(p, 5), query.ExeFileName);
private static object? At(IReadOnlyList<object?> p, int index) => index < p.Count ? p[index] : null;
private static bool SameName(object? value, string exeFileName) =>
value is string s && string.Equals(s.Trim(), exeFileName, StringComparison.OrdinalIgnoreCase);
private static bool SamePath(string a, string b)
{
try
{
return string.Equals(Path.GetFullPath(a.Trim()), Path.GetFullPath(b), StringComparison.OrdinalIgnoreCase);
}
catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
{
return false;
}
}
/// <summary>A number as the log gives it: an unsigned or signed integer, or text in decimal or <c>0x</c> hex.</summary>
internal static ulong? Number(object? value) => value switch
{
ulong u => u,
uint u => u,
long l when l >= 0 => (ulong)l,
int i when i >= 0 => (ulong)i,
string s when s.Trim().StartsWith("0x", StringComparison.OrdinalIgnoreCase)
&& ulong.TryParse(s.Trim()[2..], NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong hex) => hex,
string s when ulong.TryParse(s.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong dec) => dec,
_ => null,
};
}
@@ -0,0 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>One Application-log record as the matcher reads it: its id, its provider, and its properties in order (typed as the log gives them).</summary>
public sealed record CrashLogRecord(int EventId, string? Provider, IReadOnlyList<object?> Properties);
@@ -0,0 +1,15 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>
/// What a crash witness is asked about one session (beta.14): the executable, the pid the session held (0 when it held
/// none), the window <c>[start, end + grace]</c>, and whether the session ended because the game itself left — a crash
/// reporter only counts for a game that exited.
/// </summary>
public sealed record CrashQuery(string ExePath, int TargetPid, DateTimeOffset WindowStart, DateTimeOffset WindowEnd, bool TargetLeft)
{
/// <summary>The executable's file name, the form the event log names it by.</summary>
public string ExeFileName => Path.GetFileName(ExePath);
}
@@ -0,0 +1,26 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>
/// When a crash reporter the game started counts as its crash (beta.14). It must have started at least
/// <see cref="StartedWithTheGame"/> after the game — a reporter that starts with its game is a monitor, not a crash, and a
/// crash in the game's first seconds is under-reported rather than a monitor fabricating one — and the game must have left
/// within <see cref="ExitWithin"/> of it: a game that kept running reported an error it survived, which is a note and not
/// a crash.
/// </summary>
public static class CrashReporterRule
{
public static readonly TimeSpan StartedWithTheGame = TimeSpan.FromSeconds(10);
public static readonly TimeSpan ExitWithin = TimeSpan.FromSeconds(60);
public static bool Counts(CrashReporterSighting sighting, CrashQuery query, DateTimeOffset endedAt)
{
ArgumentNullException.ThrowIfNull(sighting);
ArgumentNullException.ThrowIfNull(query);
bool afterStart = sighting.ParentStartedAt is not { } gameStarted || sighting.StartedAt - gameStarted >= StartedWithTheGame;
return query.TargetLeft && afterStart && endedAt - sighting.StartedAt <= ExitWithin;
}
}
@@ -0,0 +1,10 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>
/// An engine's crash reporter seen starting as a child of a process (beta.14): its image, its parent's pid and — when the
/// watcher had seen the parent — the parent's image and start, and its own start.
/// </summary>
public sealed record CrashReporterSighting(string Image, int ParentPid, string? ParentImagePath, DateTimeOffset? ParentStartedAt, DateTimeOffset StartedAt);
@@ -0,0 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>What the crash witnesses said about one session (beta.14): the Application log, and the crash reporter the game started, counted or only seen.</summary>
internal readonly record struct CrashWitness(bool ApplicationLog, string? Reporter, bool ReporterCounted);
@@ -15,8 +15,9 @@ namespace FrameLedger.Application.Recording;
/// The crash-witness window is <c>[start, end + 30 s]</c>; the caller asks the
/// <see cref="ICrashEventSource"/> with exactly that and hands the answer in. The precedence is
/// the document's: our own safety stop is <c>unhooked_safety</c> whatever the process did next; the
/// capture side stopping on its own is <c>degraded</c>; an exception's exit code (<see cref="IsExceptionCode"/>) or an
/// event is <c>crashed</c> — since beta.8; any non-zero code was until then, End task's 1 included — and anything else,
/// capture side stopping on its own is <c>degraded</c>; an exception's exit code (<see cref="IsExceptionCode"/>), an
/// event, or — since beta.14 — an engine's crash reporter the game started before it left is <c>crashed</c> — since
/// beta.8; any non-zero code was until then, End task's 1 included — and anything else,
/// including a target still running when the session ends, is <c>normal</c> with its code in the notes.
/// </para>
/// <para>
@@ -29,7 +30,12 @@ public static class ExitStatusMapper
/// <summary>How long after the session's end an event may still be attributed to it.</summary>
public static readonly TimeSpan CrashWitnessGrace = TimeSpan.FromSeconds(30);
public static ExitStatus Map(SessionEndReason reason, int? exitCode, bool crashEventFound)
/// <summary>
/// The status from the end, the exit code and the witnesses. <c>crashReporterCounted</c> (beta.14): the game started an
/// engine's crash reporter and left within a minute (<see cref="CrashReporterRule"/>) — Unreal's crash ends with exit
/// code 3 and no event, so this is its only witness.
/// </summary>
public static ExitStatus Map(SessionEndReason reason, int? exitCode, bool crashEventFound, bool crashReporterCounted = false)
{
switch (reason)
{
@@ -44,7 +50,7 @@ public static class ExitStatusMapper
// A crash is an exception's exit code or the Application log's witness (beta.8). Any other non-zero code is
// the program's own exit — End task and taskkill leave 1 — and was a "crash" until 2026-09-25; the code stays
// in the notes, and the crash policy still counts it inside its window (CrashAutoDisablePolicy).
return crashEventFound || exitCode is { } code && IsExceptionCode(code) ? ExitStatus.Crashed : ExitStatus.Normal;
return crashEventFound || crashReporterCounted || exitCode is { } code && IsExceptionCode(code) ? ExitStatus.Crashed : ExitStatus.Normal;
}
}
@@ -68,9 +74,10 @@ public static class ExitStatusMapper
/// <summary>
/// What <c>sessions.capture_notes</c> carries about the end: the fine reason the four statuses
/// collapse, the exit code when there was one, the witness when there was one.
/// collapse, the exit code when there was one, the witness when there was one — and since beta.14 the crash reporter the
/// game started, if one was seen: <c>crash_reporter=</c> when it counted, <c>crash_reporter_seen=</c> when it did not.
/// </summary>
public static string Describe(SessionEndReason reason, int? exitCode, bool crashEventFound)
public static string Describe(SessionEndReason reason, int? exitCode, bool crashEventFound, string? crashReporter = null, bool crashReporterCounted = false)
{
string note = "end=" + reason;
if (exitCode is { } code)
@@ -83,6 +90,11 @@ public static class ExitStatusMapper
note += "; crash_event=application_log";
}
if (crashReporter is { Length: > 0 })
{
note += (crashReporterCounted ? "; crash_reporter=" : "; crash_reporter_seen=") + crashReporter;
}
return note;
}
}
@@ -148,9 +148,15 @@ public static class FgLadder
return "census_not_run";
}
return (census & FlRuntimeCensusFamilies.Fg) == FlRuntimeCensus.None ? "no_fg_runtime" : "fg_runtime_loaded";
return (census & FlRuntimeCensusFamilies.Fg) == FlRuntimeCensus.None ? NoFgRuntimeQualifier : "fg_runtime_loaded";
}
/// <summary>
/// The qualifier that says no frame-generation runtime was loaded, so the presents cannot include in-process generated
/// frames: the one case the presented rate is the application rate without a count (beta.14: efficiency reads it).
/// </summary>
public const string NoFgRuntimeQualifier = "no_fg_runtime";
/// <summary>DXGI's counter as a second witness beside a counted <c>none</c>; null when it was not read.</summary>
public static string? DxgiBesideNone(FlWriterState writer)
{
@@ -5,12 +5,13 @@ namespace FrameLedger.Application.Recording;
/// <summary>
/// The second witness for <c>crashed</c> (<c>04_CAPTURE</c> §Crash &amp; exit classification): an
/// Application Error (1000) or WER (1001) event naming the executable inside <c>[start, end + 30 s]</c>.
/// Application Error (1000) or WER (1001) crash report of THIS session's game inside its window
/// (<see cref="CrashEventMatcher"/> since beta.14 — a WER memory-leak report named the game and read as a crash).
/// A process that was killed, or that returned 0 after an unhandled exception's handler, exits with a
/// code that says nothing; the event log still does.
/// </summary>
public interface ICrashEventSource
{
/// <summary>Whether such an event exists; false when the log cannot be read — absence of evidence, not a crash.</summary>
bool FoundCrash(string exeFileName, DateTimeOffset windowStart, DateTimeOffset windowEnd);
bool FoundCrash(CrashQuery query);
}
@@ -0,0 +1,15 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
namespace FrameLedger.Application.Recording;
/// <summary>
/// The engine crash reporters the watcher saw a session's game start (beta.14, <c>Watch.CrashReporterWitness</c>): the third
/// witness for <c>crashed</c>, beside the exit code and the Application log, for the engines that handle a crash themselves —
/// Unreal starts <c>CrashReportClient.exe</c> and exits with code 3, which says nothing and reaches no event log.
/// </summary>
public interface ICrashReporterSightings
{
/// <summary>The first sighting the session's game started inside its window, or null; waits for a poll or two when the game just left.</summary>
Task<CrashReporterSighting?> FindAsync(CrashQuery query, CancellationToken ct = default);
}
@@ -37,7 +37,29 @@ public static class SensorSeriesCatalog
/// <summary>The game process's commit charge, MiB.</summary>
public const string GameCommit = "game_commit";
/// <summary>The series in storage order. The first eight predate beta.12; their names are on disk and never change.</summary>
/// <summary>The graphics card's core clock, MHz (beta.14, D49).</summary>
public const string GpuCoreClock = "gpu_core_clock";
/// <summary>Its memory clock, MHz.</summary>
public const string GpuMemClock = "gpu_mem_clock";
/// <summary>Its fan speed, RPM.</summary>
public const string GpuFan = "gpu_fan";
/// <summary>Its memory temperature, °C.</summary>
public const string GpuMemTemp = "gpu_mem_temp";
/// <summary>Held back by its power limit on the tick: 100 or 0 (<see cref="GpuLimitReasons"/>), so the mean is a share in percent.</summary>
public const string GpuPowerLimit = "gpu_power_limit";
/// <summary>Held back by heat on the tick: 100 or 0.</summary>
public const string GpuThermalLimit = "gpu_thermal_limit";
/// <summary>
/// The series in storage order: the first eight predate beta.12, the next five came with it and the last six with
/// beta.14. Their names are on disk and never change. The six of beta.14 were in the samples before it — the L2 and L3
/// layers read them — and stored nowhere.
/// </summary>
public static IReadOnlyList<(string Name, Func<TelemetrySample, double?> Select)> All { get; } =
[
(GpuTemp, static s => s.Sample.TempCoreC),
@@ -53,5 +75,11 @@ public static class SensorSeriesCatalog
(GameRamPrivate, static s => s.Game.RamPrivateMb),
(GameRamWorkingSet, static s => s.Game.RamWorkingSetMb),
(GameCommit, static s => s.Game.CommitMb),
(GpuCoreClock, static s => s.Sample.CoreClockMhz),
(GpuMemClock, static s => s.Sample.MemClockMhz),
(GpuFan, static s => s.Sample.FanRpm),
(GpuMemTemp, static s => s.Sample.TempMemoryC),
(GpuPowerLimit, static s => GpuLimitReasons.PowerLimited(s.Sample.ThrottleReasons)),
(GpuThermalLimit, static s => GpuLimitReasons.ThermalLimited(s.Sample.ThrottleReasons)),
];
}
@@ -29,11 +29,14 @@ public static class SessionAggregator
var ctx = new Context(input);
SessionRow row = ApplyFrames(skeleton, ctx);
row = ApplyPacing(row, ctx);
row = ApplySync(row, ctx);
row = ApplyFg(row, ctx);
row = ApplyUpscaler(row, ctx);
row = ApplyRt(row, ctx);
row = ApplyWriter(row, ctx);
row = WithSensorAggregates(row, input.Sensors);
row = ApplyEfficiency(row, ctx);
row = ApplyWitnesses(row, ctx);
return new AggregationResult
@@ -80,10 +83,55 @@ public static class SessionAggregator
};
}
/// <summary>
/// <c>03_METRICS</c> §Pacing (beta.14, D49): time below 30 and 60 FPS and frame to frame over the series the statistics are
/// over, time below the refresh rate over the presents the display received (<see cref="FramePacing"/>). The refresh rate is
/// the display tally's, on the skeleton before the aggregator runs; a session recovered from a crash file has none.
/// </summary>
private static SessionRow ApplyPacing(SessionRow row, Context c)
{
FramePacing pacing = FramePacing.From(c.Frames, c.Series, row.DisplayMonitorHz);
return row with
{
TimeBelow30Pct = pacing.TimeBelow30Pct,
TimeBelow60Pct = pacing.TimeBelow60Pct,
TimeBelowRefreshPct = pacing.TimeBelowRefreshPct,
FrametimeDeltaMeanMs = pacing.FrameToFrameMeanMs,
};
}
/// <summary><c>03_METRICS</c> §Sync (beta.14): what the dominant stream's presents asked for, and <c>sync_interval_mode</c>'s first writer.</summary>
private static SessionRow ApplySync(SessionRow row, Context c)
{
PresentArgsShares shares = PresentArgsShares.From(c.Dominant);
return row with
{
VsyncPresentPct = shares.VsyncPct,
TearingAllowedPct = shares.TearingAllowedPct,
SyncIntervalMode = Vocabulary.SyncIntervalMode(shares),
};
}
/// <summary>
/// <c>03_METRICS</c> §Efficiency (beta.14, D49): application frames per joule — the application frame rate over the card's
/// average power. Never the displayed rate (rule 6). The application rate is known where frame generation was counted
/// over the session (the window usable: its native rate, which a counted <c>none</c> makes the presented one); without a
/// count, the presented rate is the application rate only where no frame-generation runtime was loaded. A session whose
/// generation changed state publishes a steady state's rate, scoped to a share of the session, and has no session-wide
/// rate to divide: null, as is every case the census could not clear.
/// </summary>
private static SessionRow ApplyEfficiency(SessionRow row, Context c)
{
double? applicationFps = c.FgUsable ? row.NativeFps
: string.Equals(row.PresentedQualifier, FgLadder.NoFgRuntimeQualifier, StringComparison.Ordinal) ? row.PresentedFps
: null;
return row with { AppFramesPerJoule = EnergyEfficiency.FramesPerJoule(applicationFps, row.AvgGpuPowerW) };
}
private static SessionRow ApplyFg(SessionRow row, Context c)
{
FgWindow? fg = c.Fg;
bool usable = fg is { Refusal: null } && c.Verdict is FgVerdict.Named or FgVerdict.ActiveUnidentified or FgVerdict.None or FgVerdict.NoneInputsTagged;
bool usable = c.FgUsable;
// 03_METRICS §Frame Generation (2026-09-17): a session refused as non-uniform still publishes the state it
// spent most of its generating time in, scoped and with its share -- never the session average.
@@ -199,7 +247,7 @@ public static class SessionAggregator
SeriesAggregates cpuLoad = SeriesAggregates.Of(sensors.Select(static t => t.System.CpuLoadPct));
SeriesAggregates cpuTemp = SeriesAggregates.Of(sensors.Select(static t => t.System.CpuTempC));
SeriesAggregates ram = SeriesAggregates.Of(sensors.Select(static t => t.System.RamUsedMb));
return (row with
return (row.WithGpuClocks(s) with
{
AvgCpuLoad = cpuLoad.Average,
AvgCpuTemp = cpuTemp.Average,
@@ -215,6 +263,21 @@ public static class SessionAggregator
}).WithGameMemory(sensors);
}
/// <summary>
/// The card's clocks, fan, memory temperature and what held it back (beta.14, D49; <c>03_METRICS</c> §Sensor aggregates) —
/// both tiers. The limits are shares of the ticks that carried reasons at all, which only NVIDIA's layer reports; null
/// elsewhere, never "not limited".
/// </summary>
private static SessionRow WithGpuClocks(this SessionRow row, IReadOnlyList<GpuSample> s) => row with
{
AvgGpuCoreClockMhz = SeriesAggregates.Of(s.Select(static x => x.CoreClockMhz)).Average,
AvgGpuMemClockMhz = SeriesAggregates.Of(s.Select(static x => x.MemClockMhz)).Average,
AvgGpuFanRpm = SeriesAggregates.Of(s.Select(static x => x.FanRpm)).Average,
MaxGpuMemTemp = SeriesAggregates.Of(s.Select(static x => x.TempMemoryC)).Max,
PowerLimitPct = SeriesAggregates.Of(s.Select(static x => GpuLimitReasons.PowerLimited(x.ThrottleReasons))).Average,
ThermalLimitPct = SeriesAggregates.Of(s.Select(static x => GpuLimitReasons.ThermalLimited(x.ThrottleReasons))).Average,
};
/// <summary>
/// The game process's own memory (beta.12, D43; <c>03_METRICS</c> §Game process memory) and every series' statistics —
/// both tiers, from the same 1 Hz samples. Null where no tick carried the field: a session before beta.12, the DLL
@@ -373,6 +436,7 @@ public static class SessionAggregator
Withheld = Fg?.IsNone == true ? FgLadder.WithholdNone(census, input.Modules, input.Writer) : null;
FgIdentity = FgLadder.Identity(dominantRecords);
Verdict = FgLadder.Resolve(FgIdentity, Fg, Withheld);
FgUsable = Fg is { Refusal: null } && Verdict is FgVerdict.Named or FgVerdict.ActiveUnidentified or FgVerdict.None or FgVerdict.NoneInputsTagged;
// 03_METRICS §Core definitions: the median, the lows, min / max, σ and the stutter rule are over ft_app. Where
// generated frames were counted (beta.8) that is application frame to application frame, never present to
@@ -411,6 +475,9 @@ public static class SessionAggregator
public FgVerdict Verdict { get; }
/// <summary>The window's count stands for the session: no refusal, and a verdict that publishes a factor or a counted none.</summary>
public bool FgUsable { get; }
/// <summary>Generated frames were counted, or a technology named: the frame statistics are over application frames.</summary>
public bool Generating { get; }
@@ -48,12 +48,16 @@ public sealed class SessionRecorder : ISessionRecorder
private readonly ISessionObserver? _observer;
private readonly IDriverProfileSource? _profiles;
private readonly UserModeExceptionLapsePolicy? _exceptionLapse;
private readonly ICrashReporterSightings? _reporters;
public SessionRecorder(ICaptureSessionFactory sessions, IGameRepository games, IHardwareSnapshotRepository snapshots,
IHardwareSnapshotSource hardware, IPartialSessionStore partials, SessionFinalizer finalizer, ICrashEventSource crashes,
Func<RecorderOptions, ITelemetryPoller?> pollers, TimeProvider clock, RecorderOptions? options = null, ISessionObserver? observer = null,
IRecorderPolicy? policy = null, IDriverProfileSource? profiles = null, UserModeExceptionLapsePolicy? exceptionLapse = null)
IRecorderPolicy? policy = null, IDriverProfileSource? profiles = null, UserModeExceptionLapsePolicy? exceptionLapse = null,
ICrashReporterSightings? reporters = null)
{
// beta.14: the engine crash reporters the watcher saw the game start; null where nothing watches (the tests, the console).
_reporters = reporters;
// D33: ends a game's user-mode exception when a session under it ends badly; null in every recorder that has no
// consent store to write to (the tests, the unshipped host), where no exception can be in force either.
_exceptionLapse = exceptionLapse;
@@ -189,10 +193,15 @@ public sealed class SessionRecorder : ISessionRecorder
bool hooked = outcome.AttachRefusal == ShmAttachRefusal.Ok;
// A held Tier-2 session's duration is the game's (2026-09-22), so the Application-log witness applies to it too.
bool hadPid = hooked || outcome.TargetPid != 0 || outcome.HeldUnhooked;
bool crashEvent = hadPid && _crashes.FoundCrash(Path.GetFileName(request.NormalisedExePath), header.StartedAt, endedAt + ExitStatusMapper.CrashWitnessGrace);
ExitStatus exit = ExitStatusMapper.Map(outcome.Reason, outcome.ExitCode, crashEvent);
// beta.14: the query ties every witness to THIS game's process — its pid, its path — inside the session's window.
bool targetLeft = outcome.ExitCode is not null || outcome.Reason is SessionEndReason.TargetExited or SessionEndReason.LaunchTargetExited;
var query = new CrashQuery(request.NormalisedExePath, outcome.TargetPid, header.StartedAt, endedAt + ExitStatusMapper.CrashWitnessGrace, targetLeft);
CrashReporterSighting? reporter = hadPid && _reporters is { } reporters ? await reporters.FindAsync(query, ct).ConfigureAwait(false) : null;
bool reporterCounted = reporter is { } seen && CrashReporterRule.Counts(seen, query, endedAt);
bool crashEvent = hadPid && _crashes.FoundCrash(query);
ExitStatus exit = ExitStatusMapper.Map(outcome.Reason, outcome.ExitCode, crashEvent, reporterCounted);
SessionRow skeleton = Skeleton(header, outcome, endedAt, exit, crashEvent, hooked) with { DriverProfileJson = driverProfile };
SessionRow skeleton = Skeleton(header, outcome, endedAt, exit, new CrashWitness(crashEvent, reporter?.Image, reporterCounted), hooked) with { DriverProfileJson = driverProfile };
var input = new FinalizeInput
{
Skeleton = skeleton,
@@ -241,9 +250,9 @@ public sealed class SessionRecorder : ISessionRecorder
};
}
private static SessionRow Skeleton(PartialHeader h, CaptureOutcome o, DateTimeOffset endedAt, ExitStatus exit, bool crashEvent, bool hooked)
private static SessionRow Skeleton(PartialHeader h, CaptureOutcome o, DateTimeOffset endedAt, ExitStatus exit, CrashWitness crash, bool hooked)
{
string notes = ExitStatusMapper.Describe(o.Reason, o.ExitCode, crashEvent);
string notes = ExitStatusMapper.Describe(o.Reason, o.ExitCode, crash.ApplicationLog, crash.Reporter, crash.ReporterCounted);
if (o.LaunchError is { } launchError)
{
notes += "; launch_error=" + launchError.ToString(System.Globalization.CultureInfo.InvariantCulture);
@@ -266,6 +275,13 @@ public sealed class SessionRecorder : ISessionRecorder
notes += "; " + CaptureNotes.AcExceptionSlot(excepted);
}
// D48(b), beta.14: the last re-scan could not read the game's tree as the game exited, and the session ended as
// that exit rather than as a safety unhook; what the scan said stays with the row.
if (o.ExitScanReason is { } scanAtExit)
{
notes += "; scan_at_exit=" + scanAtExit;
}
// The session that turned the game's hooking off says so in its notes (2026-09-22): the row's block names
// the finding, and the notes travel into every bug bundle.
if (o.HookingTurnedOff)
Loaded 100 of 170 files, more files were not shown because too many files have changed in this diff. Show more