Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 22cbc5f93c release: 0.1.0-beta.9 - the CHANGELOG section, the accuracy block's release line, README's release lines, HANDOFF's status pointer
The ninth pre-release: one narrow exception a user can make, per game, for a game whose only
anti-cheat runs in user mode and that FrameLedger has measured hooked at least twice (owner
decision D33): the guard's tolerance and the Overlay's channel (#236), the Agent's eligibility,
grant, marks and ends with schema 0014 (#237), and the option, the list, the disclosure and the
legal text in the App (#238). Same unsigned installer; the Legal Gate opens once for the
Disclaimer 2.7 and the EULA 1.3 (owner's leave 2026-09-26). The Privacy Policy is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-26 05:16:37 +07:00
poli0981andClaude Opus 5.5 f32c10d758 feat(app): the user-mode anti-cheat exception in Settings and on the game page - its option, its list, its versioned disclosure, and the legal text that says it (D33) (#238)
Owner decision D33 (2026-09-26), beta.9 PR-3 of 4, on the guard (#236) and the Agent (#237).
This is the part a user sees; every state it shows is the Agent's, read from its columns,
and every grant is the Agent's to make.

- Settings > Capture: "Allow hooking in games with user-mode anti-cheat that were measured
  before" (hooking.usermode_ac_exceptions, off by default) and under it the User-mode
  exceptions list - eligible games (Make exception...), games held back only by the session
  count, games carrying an exception (Withdraw), each with its finding, its successful hooked
  sessions and its state. Off, only kept exceptions are listed, suspended. "Checking..." until
  the Agent has answered about every blocked game; Refresh re-reads.
- The disclosure: AntiCheatExceptionPrompt / AntiCheatExceptionDialogContent over the new
  Safety_Exception_* family (Shared, versioned by AntiCheatExceptionDisclosure.Version; ja
  English verbatim marked for review). Why it is offered, the risk at the same grain as FR-2.1's
  dialog (a ban possibly days later, invisible to FrameLedger), what is still refused, how it
  ends, that it turns nothing on, offline/single-player; the primary button bound to the ticked
  "I accept the risk of a ban for this game", Enter = Keep it blocked.
- AntiCheatExceptions: the handshake on HelloAck.ExceptionDisclosureVersion (no dialog against
  other text), then SetAntiCheatException; Granted / Withdrawn / Refused (TooFewSessions, the
  guard's finding, BlockNotExceptionable, could not verify) / OptionOff / VersionMismatch /
  AgentUnavailable, each said in the user's language.
- The game page: a User-mode exception card (ExceptionView over GameRow.AcException) - eligible,
  checking, not eligible and why (too few sessions; "the guard also found Kernel driver in the
  game folder (NEPKernel.sys)"; "... is not user-mode throughout"), in force, suspended, ended
  and why. An exception in force brings the Hooking card back even while anti-cheat cards are
  hidden, its switch usable through FR-2.1's dialog, the finding still under it.
- Marks: the library card says Exception; a session hooked under one is "Hooked · exception"
  in the Sessions tab (tooltip names the family) and has a line in its summary.
- Legal (owner-approved): Disclaimer 2.6 -> 2.7 (sec. 2A describes the exception and its risk;
  sec. 2's "no setting" sentence points to it), EULA 1.2 -> 1.3 (the code-injection clause
  names it), the accuracy block (all three copies, re-dated 2026-09-26), SECURITY.md (what in
  the exception is a security report), README's Hard refusal row. Privacy stays 2.4. The Legal
  Gate re-shows the two changed documents.

Tests: AntiCheatExceptionsTests (handshake, declined sends nothing, our version sent, the
Agent's answers, withdrawal needs no dialog, the button waits for the tick),
GameDetailViewModelTests (eligible offers it; in force makes the switch usable; off =
suspended; the card says Exception; why not eligible - one session, Aniimo's driver, a
kernel-level family), SettingsViewModelTests (off by default; the list follows the Agent's
columns; off lists only a kept exception).

Docs: 08_UI (the game page card, the Settings list), 09_I18N (Safety_Exception_*),
20_OPEN_QUESTIONS (the decision recorded, what stays the owner's), 19_SAFETY (status),
CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 22:16:06 +00:00
poli0981andClaude Opus 5.5 9b5d1cd486 feat: the Agent grants, keeps and ends a user-mode anti-cheat exception - eligibility from its own facts, the Overlay told first, every re-scan naming the family, schema 0014 (D33) (#237)
Owner decision D33 (2026-09-26), beta.9 PR-2 of 4, on PR-1's native half. Nothing in the
App asks for an exception yet (PR-3 adds the option, the list and the disclosure); this is
everything the Agent does once something does.

- The option: hooking.usermode_ac_exceptions (SettingsRegistry, off by default, Agent-read)
  behind IUserModeExceptionSwitch. Off suspends every exception and deletes none.
- Eligibility: AntiCheatPreScanSweep asks each BLOCKED entry, while the option is on, one
  question - a tolerant pre-scan naming the block's family (PreScanGameAsync(exe, family)),
  keyed on the rules, the executable and the block text so it re-runs only on a change -
  and counts ISessionRepository.CountSuccessfulHookedAsync every pass (hooked, frames,
  exit_status normal). UserModeExceptionRules.IsEligible: a module/file/folder block, the
  guard let exactly that family through, >= 2 sessions. A block is still never scanned for
  a new one and never cleared.
- The grant: SetAntiCheatException {gameId, enabled, disclosureVersion} (07_IPC). The
  Agent's disclosure version (AntiCheatExceptionDisclosure.Version, also in HelloAck), the
  option on, an exceptionable block, then the Agent's OWN facts - a tolerant pre-scan of the
  file on disk and the session count - and the store writes the grant only over facts that
  make the game eligible (ConsentWriteOutcome.NotEligible otherwise), bound in SQL to the
  block they were reached about. A grant turns nothing on: hooking is FR-2.1's SetHookEnabled,
  which under an exception in force names the family and answers prescan "exception".
- The session: HookRequest.FromConsent derives ToleratedFamily from the stored grant only
  (UserModeExceptionRules.CoveredFamily: option on, grant on these bytes, block naming that
  family) and only when the Overlay's channel was published first
  (IOverlayToleranceChannel -> Infrastructure.Capture.OverlayToleranceChannel, the
  Local\FrameLedger.Tolerate.<pid> mapping with a stated O:<user>D:P(A;;GR;;;<user>) DACL, a
  name already taken refused). The gate hands the guard the NAME; GuardSupervisor names it
  to every 30 s re-scan. A blocked row whose exception does not apply is hooking-off before
  the process is opened. The hooked session is marked (sessions.ac_exception_family,
  "; ac-exception=<family>" in the notes, CaptureNotes reads it, CSV header line).
- The end: UserModeExceptionLapsePolicy after the row is stored - NewFinding (a finding
  about the game at the start or the re-scan), SafetyUnhook, OverlayStopped, SessionCrashed
  while hooked; the sweep ends a grant on other bytes (ExecutableChanged, with the option off
  too) or one the facts no longer support (NoLongerEligible - never on a scan that could not
  look); Change executable ends it; the user withdraws it (Withdrawn). An end turns hooking
  off while the block stands and keeps the consent stamp and the grant's history.
- Schema 0014: fourteen games.ac_exception_* columns (eligibility + key, grant, end) and
  sessions.ac_exception_family, ADD COLUMN only. GameRow.AcException, GameConsentRecord
  .Exception, StoredBlock (Reason|Family|Signal read back).
- IAntiCheatGuard: every method takes string? toleratedFamily - required, so every caller
  states which it means; still four methods of int/string/CancellationToken
  (NoSecondMatcherTests unchanged but for the note).

Tests: UserModeExceptionRulesTests, UserModeExceptionLapsePolicyTests, D33 cases in
AntiCheatPreScanSweepTests (option off asks nothing, keyed question, live count, title list
never asked, the Aniimo shape, ends), HookRequestFromConsentTests, HookedCaptureGateTests
(both entries), GuardSupervisorTests, CaptureSessionTests (the channel before the injection,
option off / other bytes -> hooking-off without opening the process, a failed channel is no
exception, a start-time finding), SessionRecorderTests (the mark; a crash ends it),
AgentCommandHandlerTests (disclosure/option, facts, refusals, SetHookEnabled under it,
withdrawal), SqliteGameConsentStoreTests, SqliteSessionRepositoryTests, LedgerDatabaseTests
(0014), OverlayToleranceChannelTests (read by the user, write refused, squatted name, NUL/
newline), IpcCodecTests, SettingsRegistryTests.

Docs: 02_SPEC (FR-2.3 note, FR-2.8), 04_CAPTURE (the gate's one branch), 06_DATA_MODEL (schema
0014, the setting, writer ownership), 07_IPC (SetAntiCheatException, HelloAck, SetHookEnabled,
section D built), 19_SAFETY (status), HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 21:22:22 +00:00
poli0981andClaude Opus 5.5 01d3afd504 feat(guard): the native half of the user-mode exception - the guard tolerates one named user-mode family and keeps scanning, and the Overlay learns it before its loader detour exists (D33) (#236)
Owner decision D33 (2026-09-26, beta.9 PR-1 of 4): a per-game exception for anti-cheat
that is user-mode throughout, bound to evidence (>= 2 successful Tier-1 sessions), chosen
with CLAUDE.md rule 2 and D22 quoted back. This PR is the part the guard and the Overlay
own; nothing asks for it yet (NativeAntiCheatGuard passes no family), so every game is
judged exactly as in beta.8. The Agent's half is PR-2, the App's and the legal text PR-3.

- ABI: FlGuardEvaluate, FlGuardedInject, FlGuardedInjectWhenReady and FlStaticPreScanGame
  take `const char* toleratedFamilies` - family NAMES, never evidence; nullptr/"" is
  today's behaviour. No new entry point, and nothing of the withdrawn bypass comes back.
- fl::guard::FamilyIsUserModeOnly / ResolveTolerance / MatchNameTolerating: the guard
  itself decides which names it honours - a family with no drivers or services entry and
  no .sys among its files, in the floor AND the rules file (the floor cannot shrink, so
  data can make a family kernel-level and never the reverse). At most 8 names.
- Tolerant scans keep scanning past a tolerated hit (module sink, CheckModules, the tree
  walk), so a second family, a suspicious module or a .sys further in still refuses - the
  load-order fail-open S22(b) closed for the exemption. A .sys is refused whichever family
  matched it. Title lists, drivers, services, the fuzzy tier, scan failures,
  TargetUnreadable, WOW64 and the kill switch are untouched; the Vulkan branch evaluates
  strictly (the layer's self-scan goes inert on any anti-cheat module).
- kAllowedUserModeException = 28 (the slot the withdrawn bypass left): an allow that names
  the family and signal it let through. Managed: AntiCheatRefusalReason
  .AllowedUnderUserModeException, AntiCheatVerdict.RanUnderException / AllowedUnderException;
  IsFindingAboutTheGame stays false for it; Refused() cannot carry either allow.
- fl_tolerance.h: Local\FrameLedger.Tolerate.<pid>, FlTolerance (16 + 8 x 64 = 528 B), the
  Agent's channel to the Overlay BEFORE injection (the ring is the Overlay's, created after
  its detour would need the answer). Mirrored as Shared.FlTolerance / ToleranceLayout and
  held by ShmLayoutMirrorTests through fl-layout-dump.
- Overlay: InitThread reads the mapping once, before InstallLoaderHook, resolves each name
  against its own compiled floor and honours only a user-mode family (a 64-bit mask over the
  floor's module families, logged as TOLERANCE). Hook_LoadLibraryExW tests one bit before
  the early stop.
- NativeAntiCheatGuard: the parameter crosses as NUL-terminated UTF-8 byte[] (CA2101 rejects
  [MarshalAs(LPUTF8Str)] string), the shape FlGuardCheckRules already used.

Overhead: the present path is unchanged - no per-frame hook body was edited. The loader
detour gains one acquire load of a uint64, a shift and a compare on the floor-match branch
only (a branch taken approximately never); the mapping is read once on the init thread.

Tests: guard_test [D33] (6 cases, 73 assertions): the user-mode matrix, ResolveTolerance,
the allow and its family/signal, everything outside the family still refusing (EAC named,
BattlEye after NEP2, a suspicious module, vgk.sys, vgc, a title list, the Aniimo shape with
NEPKernel.sys, an incomplete walk, an unreadable process), the pre-scan answering as the
chokepoint does, and an integration case: a decoy NEP2.dll loaded 2.5 s after injection
does not stop the Overlay when the mapping names NetEase Yidun, and does when it names
Easy Anti-Cheat. AntiCheatVerdictTests, ShmLayoutMirrorTests, ReasonTextTests follow the
new reason.

Docs: CLAUDE.md rule 2 (amendment D33), 19_SAFETY (new section The user-mode exception,
cross-references), 17_HOOK_ENGINE (the detour note, overhead), 07_IPC (section D, the
tolerance mapping), HANDOFF (the beta.9 train: decision, evidence, traps), CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 20:33:40 +00:00
poli0981andClaude Opus 5.5 1a655237f5 release: 0.1.0-beta.8 - the CHANGELOG section, the accuracy block re-dated and extended, README's release lines, the Privacy Policy 2.4, HANDOFF's status pointer (#235)
The eighth pre-release: anti-cheat found before anyone asks (#227-#229), what a
game's files and the NVIDIA driver say about it (#230, #231), reasons that read
as what they are (#232), a Trend that works and FPS with two decimals (#233),
and a frame-generation session's numbers and charts over application frames
(#234). Same unsigned installer; the Legal Gate opens once for the Privacy
Policy 2.4 (owner's leave 2026-09-25: it names the library-wide anti-cheat check,
the files' version information and the NVIDIA driver's per-game settings).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 17:06:15 +00:00
poli0981andClaude Opus 5.5 9e7eed6351 fix: a frame-generation session's lows are over application frames, a pause is a gap and not time, and the charts draw what they say (#234)
Owner request 2026-09-25 (beta.8, item 8: fix the charts that are not reasonable). Measured first on the
owner's Onimusha demo capture (DLSS FG x3, read from a copy of the ledger): generated frames are submitted
half a millisecond after their application frame, so the stored median over presents read 2,073 FPS on a
60 FPS game, and the chart's "native" line was each frame's interval to the generated one before it.

- Domain: FrameTimeSeries.ApplicationFrames (application frame to application frame; a gap or an uncounted
  present breaks the chain); MeasuredSeconds - D leaves out every interval a gap sat in, so AverageFps is the
  kept intervals over the seconds they span; RecordWindow.SecondsOf and FgWindow.From take the gap set.
- Application: SessionAggregator takes median / lows / min / max / sigma / stutter over application frames
  where generated frames were counted (segments too), the Displayed 1% low over presents, and no frame
  statistic when a technology was named and no application frame counted. CaptureSession marks a gap before
  the first record stamped at or after the resume's QPC (test red before the fix). SessionFinalizer writes
  frame_blobs.first_present_ms (schema 0013).
- App: SessionSeriesLoader charts the dominant swapchain, application-frame intervals, every present when
  all were generated (noted), sensors on the frames' axis when the blob says where the first present is,
  Tier-2 sensors alone. FrametimeChart: labels (Application frames / Presents), no 0 ms frames after gaps,
  a note on present timing and closed-up gaps, segment labels, the overlay only when aligned.
  DistributionChart: histogram over p0.5-p99.5 with centred bars and an outside count; PercentileCurve
  drawn where ten frames lie beyond each side (FR-4.8 generalised) with the 1% / 0.1% lows marked.
  SensorsChart: watt axis, "Memory", VRAM 0 left out, distinct colours in both themes (light Percentile
  was SensorSecondary's gold), both tiers; the summary window gets a Sensors section. The game page
  reloads when one of its sessions completes.
- The live 5 s window reads the survivors' rate over a drop, not the survivors spread over the lost time.
- Docs: 03_METRICS, 04_CAPTURE, 06_DATA_MODEL, 08_UI, HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 16:52:59 +00:00
poli0981andClaude Opus 5.5 aba58dfd7d fix: the Trend tab draws on first open with Native and Presented as two metrics, FPS can show two decimals, and every steady-state factor carries its share (#233)
Owner request 2026-09-25 (beta.8, items 6 and 7: does Trend really work; FPS with up to two
decimals behind a setting).

- Trend: the page draws what the view model holds when it is made (the load finished before
  the page subscribed, so every first open was blank); the date axis is made before the theme
  and the label (DateTimeTicksBottom replaced the axis and dropped both); "Average" is two
  metrics - Presented FPS on sessions that counted no generated frame, Native FPS where frame
  generation was measured - and the tab opens on Native when the newest measured session counted
  generated frames; machine metrics count Tier-2 sessions; partial points (settings changed, or a
  steady state for Native/Displayed/factor) are hollow with a note; one hardware marker per day;
  the metric list in the page's language; the empty text names the metric.
- FPS decimals: ui.fps_decimals (off by default; Settings > Window), FpsDecimals holder read at
  start and moved at once, Formats.FpsNumber "62.40" / "62", rounded half away from zero.
- Rule 6: the readout line (Average card, Compare) and the Sessions grid's FG column carry the
  steady share; "Lifetime average" is labelled as the last measured session it is.
- Compare: the best cell's accent colour (a local Foreground outranked the trigger), best as
  shown (ties by displayed text), loads unranked, the 0-100 percentile axis (AutoScale ran after
  SetLimitsX), and PNG exports with an opaque background (ChartTheme.SavePng).
- Docs: 08_UI, 06_DATA_MODEL (ui.fps_decimals), HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 16:39:06 +00:00
poli0981andClaude Opus 5.5 2c02978b5b fix: reasons read as what they are - End task is not a crash, a refusal no anti-cheat names is not "detected", every end reason has its words (#232)
Owner request 2026-09-25 (beta.8, item 5: clearer reasons - 32-bit game, exe missing,
process killed...).

- Exit classification: a crash is an exception's exit code (NTSTATUS 0xC0000000-0xC0FFFFFF
  but 0xC000013A, 0xE06D7363 C++, 0xE0434352 .NET, 0x80000003) or the event log's witness;
  End task's 1, a program's -1, Ctrl+C are ordinary ends with the code in the notes.
  CrashAutoDisablePolicy takes the exit code too and still counts every non-zero exit in
  its window (the safety did not loosen); its row reason says "ended abnormally".
- capture_notes: the guard slot has three positions, guard=Reason|Family|Signal, none
  dropped and no ';' inside one (an empty family used to be dropped and the signal read as
  the family; a ';' in a signal cut it). Old rows are read by the rule that separates them:
  findings and the gate's own refusals carry a family, every other reason's second part
  was its signal. exit_code, crash_event and the new launch_error are read back.
- A launch that cannot start keeps Windows' reason (IProcessLauncher.Start(..., out
  win32Error), a default interface overload; CaptureOutcome.LaunchError).
- App: every SessionEndReason has its sentence (Formats.EndReasonText, enum-walk test);
  every familyless guard refusal says what happened (Formats.GuardSentence) in the
  summary, the safety notice and the enable-time refusal instead of "<signal> was
  detected in this game"; the summary says how it ended ("crashed (0xC0000005 access
  violation)", "ended with exit code 1 - what End task and taskkill leave"); the missing
  executable bar and notice say whether the drive or the file is missing.
- Docs: 04_CAPTURE (classification corrected, notes format, launch error), 19_SAFETY (crash
  safety counts abnormal ends), 08_UI, HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 16:02:50 +00:00
poli0981andClaude Opus 5.5 7d6b670173 feat: a session records the NVIDIA driver profile it ran under, and says what the NVIDIA App overrides - DLSS preset and mode, frame generation, Smooth Motion (#231)
Owner request 2026-09-25 (beta.8, item 4: detect whether the NVIDIA App overrides DLSS
settings - FG, RR, the model preset - through NVAPI).

- NVAPI bridge ABI 2: FlNvDriverProfile(exePath, ids, count, out) reads, through DRS, the
  profile the driver applies to an executable (FindApplicationByName on the full path;
  none named -> the current global profile) and the value, location and "someone set it"
  of each id asked. Read-only: a session is created, loaded, read and destroyed; the
  bridge has no DRS setter. A path too long for NVAPI's string is refused, never
  truncated. FlNvDriverProfileSize for the mirror.
- The ids and their values' meanings are NVIDIA's NvApiDriverSettings.h (MIT), written as
  Application.Capture.NvidiaDriverSettings (18 constants, no header vendored); Smooth
  Motion is community-documented only and labelled so.
- NvapiDriverProfileSource (IDriverProfileSource) over the bridge; SessionRecorder reads
  the profile beside every session (both tiers), bounded at 5 s, and a failed read costs
  the column, never the session. Schema 0012: sessions.driver_profile (DriverProfileRecord
  JSON). ngx_driver_words keeps ratio/mode/preset/fg fields beside its masks.
- App: the session summary says the profile and what it overrides ("DLSS override (preset K,
  Quality) - Frame Generation override (x4, latest preset)") and what the driver reported
  applying in the game's process from its override bits; the game page's Details card has
  an "NVIDIA App override" row from the newest session that read one. Configuration, never
  a measurement (03_METRICS).
- Fixed: ctest fl_nvapi_bridge passed on its branch line alone (PASS_REGULAR_EXPRESSION
  ignores the exit code) while its reference-counting check failed on every GPU machine;
  the check is corrected and a FAIL_REGULAR_EXPRESSION added.
- Docs: 18_GPU_VENDOR_APIS (ABI 2, read-only DRS, the ctest trap), 03_METRICS, 06_DATA_MODEL
  (0012), 08_UI, HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 15:49:57 +00:00
poli0981andClaude Opus 5.5 efcee1d08d feat: the game page says what the game's files say - x64 or x86, file and store versions, the DLSS/FSR/XeSS files it ships - and a 32-bit game's hooking cannot be turned on (#230)
Owner request 2026-09-25 (beta.8, item 3: game version, DLSS/FSR versions, 32/64-bit).

- Schema 0011: games.exe_machine / exe_file_version / exe_product_version /
  library_versions, written whole by the detection sweep (DetectionWrite). A NULL
  exe_machine is stale once, so every library entry is read under this build.
- PeImports.ReadArchitecture: the COFF machine and, for .NET, the CLR header's flags
  (Domain.Detection.ExecutableArchitecture: x64 | x86 | arm64 | arm | anycpu |
  anycpu32 | other | unknown) - an AnyCPU assembly carries an I386 machine and runs as
  64-bit unless it prefers or requires 32-bit.
- GameFileProbe: the files a capability rule names, with the numeric version of their
  VS_FIXEDFILEINFO (bounded at 48); RuleEvaluator.NamesFile shares the matcher.
- Known not hookable (x86, anycpu32, arm64, arm): SetHookEnabled answers
  Refused ExecutableNotX64 before anything is scanned or stamped; the sweep turns off
  hooking on a row enabled before this build (hook_autodisabled_reason); the page
  disables the switch with the reason and offers no re-enable. A switch that is on can
  still be turned off.
- App: a Details card (runs as, file/product version, store build labelled with its
  store, engine, shipped libraries), the subtitle says "Steam build 20374416", and the
  session summary lists the runtime libraries (runtime_modules, recorded since P2 and
  shown nowhere) against the copy the game ships.
- Rules 2026.09.5: fsr gains ffx_fsr3*.dll, xess gains libxess_dx11.dll (+ fixture).
- Docs: 05_DETECTION (what the files say about themselves), 06_DATA_MODEL (0011),
  07_IPC (ExecutableNotX64), 08_UI (Details, loaded libraries), HANDOFF traps, CHANGELOG.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 15:34:41 +00:00
252 changed files with 13345 additions and 607 deletions

No files matched your search

+169
View File
@@ -27,6 +27,104 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
## [Unreleased]
_Nothing yet — entries continue here after `0.1.0-beta.9`._
## [0.1.0-beta.9] - 2026-09-26
**The ninth pre-release: one narrow exception you can make yourself for a game whose only anti-cheat runs in user
mode and that FrameLedger has measured before.** The same unsigned installer: verify its hash against
`SHA256SUMS.txt`, then *More info → Run anyway*. What changed for a user:
- **A user-mode anti-cheat exception, per game, off by default** (Settings ▸ Capture). It is offered only where the
only anti-cheat found runs entirely in user mode — no driver or service, no driver file in the game's folder — the
game is on no title list, and FrameLedger has measured it hooked successfully at least twice. You make it one game
at a time, after a disclosure that states the ban risk; the guard still runs every check under it and ends it on
anything new, a crash or safety stop under it, or a game update. Sessions under it are marked.
- **The Disclaimer (2.7) and the EULA (1.3) say so**, so the Legal Gate opens once after the update. The Privacy
Policy is unchanged.
**Updating from `0.1.0-beta.8`:**
- Quit the App (tray icon → Exit) and end `FrameLedger.Agent.exe` before running the installer.
- Schema 0014 adds columns; the database opens in place. Nothing changes for any game until you turn the option on.
- With the option on, the Agent looks at each game whose hooking it turned off within a minute and lists the ones
that qualify; a game shipping a kernel driver (Aniimo's `NEPKernel.sys`, for one) never does.
### Added
- **A user-mode anti-cheat exception you can make yourself, per game** (owner decision D33). Settings ▸ Capture ▸
*Allow hooking in games with user-mode anti-cheat that were measured before* — off by default. On, it lists the games
FrameLedger found eligible: the only anti-cheat in the game runs entirely in user mode (no driver or service, no
driver file anywhere in the game's folder), the game is on no title list, and FrameLedger has measured it hooked
successfully at least twice. **Make exception…** shows a disclosure — the ban risk, possibly days later and invisible
to FrameLedger; what is still refused; how the exception ends — and asks you to accept the risk for that game. The
exception turns nothing on: you then turn hooking on for the game on its page, through the usual consent dialog, and
the guard still runs every check and refuses anything else it finds. The game's page shows the exception's state
(eligible; not eligible and why; in force; suspended; ended and why), the library card says **Exception**, and a
session hooked under it is marked in the Sessions tab and its summary. It ends by itself on a new finding, a crash or
safety stop under it, FrameLedger stopping because another anti-cheat loaded, or a game update; turning the option
off suspends every exception. Aniimo stays blocked: it ships a kernel driver (`NEPKernel.sys`).
- **Groundwork for the user-mode anti-cheat exception** (owner decision D33, 2026-09-26; the option, the list and the
disclosure arrive later in this train). The guard can now be asked to let ONE named anti-cheat family through, and
grants it only for a family whose every signal — in the built-in floor and in the rules file — is user-mode: no
driver, no service, no `.sys` (on today's rules NetEase Yidun, AhnLab HackShield, Anybrain and FredaikisAntiCheat).
It still runs every check and keeps scanning past what it let through, so a second anti-cheat, a kernel driver in
the game's folder, a title list, a driver or service on the machine, or a scan that could not finish still refuses;
a pass that let something through says so and names it. The injected Overlay learns the same family before it
starts watching the game's module loads, so a late-loading module of that family does not stop it and any other
anti-cheat still does. Nothing asks for any of this yet: every game is judged exactly as in beta.8.
- **The Agent can grant, keep and end a user-mode anti-cheat exception** (D33; the Settings option, the list and the
disclosure arrive in the next PR, so nothing in the App asks for one yet). With the option on
(`hooking.usermode_ac_exceptions`, off by default), the Agent's library scan asks each blocked game one question —
would the guard let exactly its blocking family through, with no kernel driver and nothing else found — and counts
its successful hooked sessions; a game with both and at least two sessions is eligible. A grant rests on facts the
Agent gathers itself when asked, is bound to the executable's bytes and turns nothing on: hooking is the usual
consent dialog afterwards. Under it the Agent tells the Overlay the family before injecting, names it to the guard at
the start and at every 30 s re-scan, and marks the session with it. It ends — hooking off, the block standing, the
reason kept — on a new finding, a safety unhook, the Overlay stopping for another anti-cheat, a crash while hooked, a
game update, or when the user withdraws it; turning the option off suspends every exception without deleting any.
Schema 0014 adds the columns; the database opens in place.
### Changed
- **Legal: Disclaimer 2.7 and EULA 1.3.** Disclaimer §2A describes the user-mode exception and its risk; the EULA's
code-injection clause names it and what making one means. The accuracy block and SECURITY.md say it too. The Legal
Gate shows the two changed documents once more; the Privacy Policy is unchanged (2.4).
## [0.1.0-beta.8] - 2026-09-25
**The eighth pre-release: anti-cheat is found before you ask, a session says what the game and the driver were, and
a frame-generation session's numbers and charts are the application's.** The same unsigned installer: verify its
hash against `SHA256SUMS.txt`, then *More info → Run anyway*. What changed for a user:
- **Anti-cheat is looked for harder, and before you ask.** Twenty-two families (74 entries), any kernel driver in a
game's folder, and per-title lists by Steam app id and executable name. The Agent checks every game in your library
on its own, turns hooking off for those with anti-cheat, and their pages show what was found instead of the hooking
switch. Their sessions are still recorded, with play time and sensors.
- **A game's page says what its files say** — 64-bit or 32-bit, the file and store versions, the DLSS / FSR / XeSS
libraries it ships — and a 32-bit game's hooking cannot be turned on.
- **NVIDIA App overrides are shown**: each session records the driver profile the game ran under (DLSS preset and
mode, frame generation, Smooth Motion), read from the driver and never changed.
- **Reasons read as what they are**: End task is not a crash, a refusal says what happened, a launch that could not
start says why, a missing executable says whether its drive is disconnected.
- **Trend works on first open**, with Native and Presented FPS as two metrics, and FPS can show two decimals
(Settings ▸ Window).
- **A frame-generation session's lows, median and stutter are over application frames**, a pause no longer counts as
one long frame, and the charts draw what they say — including the sensors of a session that was not hooked.
- **The Privacy Policy (2.4) is updated**, so the Legal Gate opens once after the update: it now names what the
software reads to check every library game for anti-cheat, the version information of the game's files, and the
NVIDIA driver's settings for your games — all on your PC, none of it sent anywhere.
**Updating from `0.1.0-beta.7`:**
- Quit the App (tray icon → Exit) and end `FrameLedger.Agent.exe` before running the installer.
- Schemas 0010–0013 add columns; the database opens in place.
- Shortly after the Agent starts it checks every game in your library for anti-cheat, once; a game where it finds
some has its hooking turned off for good, with a notice if hooking was on.
- Sessions recorded before keep the numbers they were stored with; the corrected lows and the in-step sensor overlay
apply to sessions recorded from now on.
### Added
- **FrameLedger finds the anti-cheat games in your library on its own, and hides their hooking switch** (owner decision
@@ -40,6 +138,29 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
such a game are still recorded, with play time and sensors. The scan reads the game's files only: it opens no process
and decides nothing on its own — every session start still runs the full check. Schema 0010 adds three columns; the
database opens in place, and the first scan of the library runs when the Agent starts.
- **The game page has a Details card: what the game's files say about it.** Whether the executable is 64-bit (x64),
32-bit (x86), ARM or .NET "any CPU"; its file and product versions; the store's build ("Steam build 20374416" — the
subtitle labels it that way too, instead of a bare number); the engine; and the upscaler and frame-generation files
it ships with their versions — "DLSS: nvngx_dlss.dll 3.7.10.0", Streamline, FSR, XeSS. FSR is named by its file: its
DLL's version is the SDK's, and FrameLedger does not guess which FSR that is. The capture agent reads every game in
the library once after the update. Schema 0011 adds four columns; the database opens in place.
- **A session's summary lists the libraries the game had loaded** — recorded since the first beta and shown nowhere
until now — and says when one differs from the copy the game ships ("nvngx_dlss.dll 310.2.1.0 (the game ships
3.7.10.0: another copy was loaded, for example by the driver or the NVIDIA App)").
- **FPS with two decimals** (Settings ▸ Window ▸ *Show FPS with two decimals*, off by default): every FPS figure reads
"62.40" instead of "62". Whole numbers now round half up (62.5 is 63); they rounded half to even.
- **FrameLedger says when the NVIDIA App overrides a game's DLSS.** Each session now records the NVIDIA driver profile
the game ran under — read from the driver's own settings, never from the game — and its summary says what that
profile overrides: "NVIDIA profile “…”: DLSS override (preset K, Quality) · Frame Generation override (×4)", Ray
Reconstruction, Streamline's override, a forced frame-generation mode, Smooth Motion. It also says what the driver
reported applying inside the game ("DLSS DLL chosen by the driver · preset K · Quality"), and the game page's Details
card names the overrides from the newest session. These are the driver's settings, not measurements: what FrameLedger
measured is shown as before. FrameLedger only reads these settings; it never changes them. Schema 0012 adds one
column; the database opens in place.
- **A 32-bit game's hooking switch cannot be turned on, and the page says why**: FrameLedger's hook runs in 64-bit
games only. Until now the switch turned on and every launch was refused by the guard. A 32-bit game whose hooking
was already on has it turned off the first time the capture agent reads it; its sessions are still recorded, with
play time and sensors.
### Changed
@@ -70,6 +191,8 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
like any finding. Every driver found in a game so far was an anti-cheat's; this catches the next one before anyone
names it. It is code, so no rules file can remove it — and a game that ships a driver for another reason loses
hooking with no way back, which is the trade the owner took.
- **FSR 3's and XeSS's DX11 libraries count as "Supports FSR" / "Supports XeSS"** (rules `2026.09.5`):
`ffx_fsr3_x64.dll` / `ffx_fsr3upscaler_x64.dll` and `libxess_dx11.dll` matched no rule before.
- **The guard holds 256 blocklist entries instead of 64** (2 × 74 no longer fitted the worst case of the compiled-in
floor plus a drifted file). The parsed rules are ~530 KB, so they are now reset in place instead of being copied from
a temporary: the Vulkan layer parses them on whichever of a game's threads creates its Vulkan instance, and a
@@ -77,6 +200,52 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
### Fixed
- **A frame-generation session's lows, median, min / max, σ and stutter count are over application frames**, as
`03_METRICS` always said they were: they were computed over every present, generated ones included, so a ×2
session's 1% low could sit above its native average, and a game that submits its generated frames in a burst —
the owner's Onimusha demo capture, DLSS frame generation ×3 — read a median of 2,073 FPS at a native 60. Sessions
recorded before this release keep the numbers they were stored with; their charts use the corrected rule.
- **Pausing capture no longer puts a pause-long frame and the paused minutes into the session.** The first frame
after a resume was measured from the last one before the pause; it follows a gap now, and every average is over
the time that was measured. Records lost when the capture agent fell behind are left out of that time the same way,
so an average reads the rate the game ran at rather than the survivors spread over the lost time.
- **The charts are honest about what they draw.** The frametime chart's default line is application frame to
application frame (it was each frame's interval to the generated frame before it), of the one swapchain the
statistics are over (two swapchains' intervals were drawn interleaved); the every-present line no longer draws
0 ms frames after gaps and says that presents are timed at submission; segments are labelled with their settings;
the sensor overlay is in step with the frames (it was drawn from the session's start, tens of seconds early —
schema 0013 records where the first frame sits, so sessions recorded before keep the overlay off). The histogram
is binned over the 0.5th–99.5th percentile with its bars centred on their bins; the percentile curve and its
1% / 0.1% low markers are drawn only where the session has the frames for them, the rule the stat cards follow.
The Sensors charts put power on a watt axis, call the memory plot *Memory*, leave out VRAM readings of 0, give
every line its own colour in the light theme too, and chart **sessions that were not hooked** — their sensors
were recorded and shown nowhere.
- **A game's page updates when one of its sessions finishes** — its sessions, trend and header kept what the page
opened with until it was left and reopened.
- **The Trend tab was blank the first time a game's page opened.** It is drawn at once, on a date axis that keeps its
label and the theme's colours. "Average" is two metrics now — Native FPS and Presented FPS — so a line never mixes
the two, and never shows a presented rate that includes generated frames. Temperatures, loads, power and memory
include sessions recorded without hooking; points that describe only part of their session are drawn hollow; several
hardware changes on one day are one marker.
- **A steady-state frame-generation factor always shows the share of the session it covers** — the average card,
Compare and the Sessions grid's FG× column dropped it. The game header's "Lifetime average" was the last measured
session and is labelled so.
- **Compare**: the best value is highlighted in the accent colour (it was only bold), two values that read the same are
both best, CPU and GPU load are not ranked, the percentile chart spans 0–100 again, and exported PNGs have a solid
background.
- **Ending a game with End task is no longer a "crash".** Every non-zero exit code was one, and Task Manager leaves 1.
A crash is now an exception's exit code or Windows' own crash record, and the session summary says how each session
ended: "crashed (0xC0000005 access violation)", "ended with exit code 1 — what End task and taskkill leave". The
crash safety still counts an early abnormal exit of either kind, so hooking still turns itself off after two in a row.
- **Reasons read as what they are.** Every way a session can end has its own sentence, a refusal that names no
anti-cheat says what happened ("the game is 32-bit…", "the game's process could not be opened") instead of calling
its detail "detected in this game", a launch that could not start says why (for example "the game requires
administrator rights"), and a missing executable says whether its drive is disconnected or the file is gone. A
refusal's details were stored so that a detail could be read as an anti-cheat's name; they are stored in three fixed
places now, and older sessions are read correctly.
- **The NVIDIA bridge's native test could not fail on a machine with an NVIDIA GPU.** It was registered to pass on
its "which branch" line alone, which makes ctest ignore the exit code; its reference-counting check had been failing
on every GPU machine unseen. The check is corrected and a failed assertion now fails the test.
- **Turning hooking on for an Unreal game now sees its `EasyAntiCheat` folder.** The scan that runs when hooking is
enabled was given the executable's own folder — `<game>\<Project>\Binaries\Win64\` for Unreal titles — and scanned
exactly that, while `EasyAntiCheat\` sits at the game's root. The session-time scan always looked at the root, so no
+1
View File
@@ -16,6 +16,7 @@ A C++ DLL (`FrameLedger.Overlay.dll`) is injected into games the user explicitly
> **Amended 2026-09-22 (owner decision): the override of 2026-09-21 is withdrawn, and the sentence above is the rule again.** For one day (releases `0.1.0-beta.3` and `beta.4`) a per-game override existed. The owner withdrew it: no entry point, no message, no column (schema 0008 drops 0007's five), no string. Do not add one in any form.
>
> **A finding turns the game's hooking off** (`19_SAFETY` §What a finding does to the game). An anti-cheat named in the game itself — its process, its title lists, its folder — is written to the row exactly as the pre-scan always wrote it (`hook_enabled = 0`, `hook_blocked_reason`, `hook_prescan_state = 'blocked'`), and since 2026-09-22 also when the guard finds it at a session's start or at the 30 s re-scan (`AntiCheatVerdict.IsFindingAboutTheGame`). A machine-wide driver or service refuses that session only. The notice, the game's page, the session's notes and the Agent's log all say it happened. Nothing clears the block, as before.
> **Amended 2026-09-26 (owner decision D33): one narrow, evidence-bound exception.** Asked with the 2026-09-22 withdrawal and this rule quoted back, the owner chose a per-game exception for anti-cheat that is **user-mode throughout** — a Settings option off by default, then the user ticks each eligible game through a versioned disclosure (bans are possible and can arrive days later). Eligible only when every finding about the game is `BlockedModule` / `AntiCheatFile` / `AntiCheatDirectory` of ONE family whose floor-and-file footprint has no driver, service or `.sys` (`fl::guard::FamilyIsUserModeOnly` — the GUARD decides, from a family NAME the caller passes), no `.sys` is anywhere in the install tree, no title list names the game, and the ledger holds ≥ 2 successful Tier-1 sessions of it. Drivers, services, title lists, the `.sys` rule, the fuzzy tier, scan failures, `TargetUnreadable`, 32-bit, the kill switch and Vulkan are never excepted. The guard runs every check and keeps scanning past the tolerated family (`kAllowedUserModeException`, reason 28); the Overlay learns the family from `Local\FrameLedger.Tolerate.<pid>` before its loader detour exists. A new finding, a crash / safety unhook / floor stop under it, or an executable change ends it; the block is never cleared. **No other form of override is to be added** (`19_SAFETY` §The user-mode exception).
3. **Never implement evasion.** No manual mapping, no PE header erasure, no thread hiding, no signature obfuscation, no unlinking from the PEB module list. Injection uses documented `LoadLibraryW`. The DLL keeps its real name, real exports, and version info. A performance tool must be *visible* to anti-cheat, not hidden from it. Any PR that makes FrameLedger harder to detect is rejected on principle.
4. **Never read or write game memory outside our own hooks.** We read arguments passed to APIs we hooked and COM/handle objects we legitimately own. No pattern scanning for game internals, no reading player/entity state, no writing to game memory. Ever.
5. **The hook must never crash the game.** Every hook body: SEH-guarded, allocation-free, lock-free, no logging, no exceptions crossing the boundary. On repeated faults, self-disable (`17_HOOK_ENGINE` §Fault policy).
+17 -10
View File
@@ -5,8 +5,8 @@
> No telemetry. No accounts. All data stays on your machine.
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-09-23.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.7`** (2026-09-23), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), 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
@@ -24,7 +24,9 @@
> named FSR 3 from the older DLLs, and FSR without a version from the newer ones, which host both
> FSR 3.1 and FSR 4. FSR 2, and FSR shipped any other way, is not identified. For DLSS titles that
> bypass Streamline, the NVIDIA driver's own per-process record is stored with the session and shown
> as *DLSS (driver-reported)*. Intel XeSS is **not** read (its SDK licence
> as *DLSS (driver-reported)*. The NVIDIA driver's profile for the game — the DLSS and frame-generation
> overrides the NVIDIA App sets — is read, never changed, and shown as the driver's settings beside what
> was measured. Intel XeSS is **not** read (its SDK licence
> forbids it), and neither is an upscaler compiled into the game: those read `N/A`, or "Unknown
> upscaler" when another vendor's hook ran in the game. Vulkan and OpenGL titles read `N/A`.
> - **Quality preset:** not reported on any title measured. The one route this software may use — the
@@ -45,7 +47,8 @@
> FG are named from the calls the game makes; any other generator (XeSS-FG, one compiled into the game)
> is shown only as active with the technology not identified, and is never named. Where a technology is
> named but its frames could not be counted, or frame generation is not measured, the software shows
> **Presented FPS** with a note on what it may include — never a Native figure.
> **Presented FPS** with a note on what it may include — never a Native figure. Where generated frames
> were counted, the lows, median and stutter are taken over application frames only.
> - **Ray tracing:** Yes/No measured on Direct3D 12 from ray-dispatch and acceleration-structure-build
> calls; the technique and path tracing are `N/A`, and so is ray tracing on other APIs.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
@@ -62,9 +65,13 @@
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
> back on for that executable.
> named in its process or in its folder (any kernel driver there counts), or the game on a title list by its
> store id or executable name — turns hooking off for that game, whether found by the Agent's own check of every
> game in the library, before injection, at a session's start or by the 30 s re-check; the game's page says so,
> and nothing turns it back on for that executable — except a user-mode exception you make yourself, per game,
> in Settings (off by default): only where the only finding is one anti-cheat that runs entirely in user mode, with
> no driver file in the game's folder, on a game already measured successfully at least twice. The guard still
> runs every check under it and ends it on anything new; a ban remains possible.
>
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
@@ -100,7 +107,7 @@ FrameLedger is built to keep that risk small and to be honest about it:
| Safeguard | |
|---|---|
| **Off by default** | Injection is disabled for every game until you enable it individually, after a consent prompt |
| **Hard refusal** | Known anti-cheat/anti-tamper components are detected before injection and every 30 s during a session. Detected ⇒ FrameLedger refuses, or stops capturing at the next scan — so up to 30 s can pass before it reacts to anti-cheat that loads mid-session. For Direct3D/OpenGL that means hooks are removed; for Vulkan it means the layer goes passthrough, because a layer cannot leave the loader chain of a running game. **There is no override — not in settings, not in a config file, not on the command line**<br><br>✅ **Both halves run since 2026-09-10.** The *pre-injection* refusal runs every documented check, and during every capture the Agent re-runs them every 30 s: the component inside the game removes its hooks within one frame of being told to, and within 65 s if it stops hearing from the scanner. *(Until 2026-09-15 this cell said the in-session re-scan did not run at all, which stopped being true when the Agent's capture loop landed.)* For a Vulkan title the stop is the layer's own: it checks the scanner's counter on every present and goes passthrough within one present of the stop flag, or after 65 s without a scan — a title that has stopped presenting is not stopped by that deadline, and presents nothing to be observed either. |
| **Hard refusal** | Known anti-cheat/anti-tamper components are detected before injection and every 30 s during a session. Detected ⇒ FrameLedger refuses, or stops capturing at the next scan — so up to 30 s can pass before it reacts to anti-cheat that loads mid-session. For Direct3D/OpenGL that means hooks are removed; for Vulkan it means the layer goes passthrough, because a layer cannot leave the loader chain of a running game. **There is no override — not in settings, not in a config file, not on the command line**<br><br>**One narrow exception since beta.9 (owner decision D33):** per game, after its own disclosure and only while a Settings option (off by default) is on, a game whose only finding is one anti-cheat that runs entirely in user mode — no driver file in its folder, on no title list — and that FrameLedger has measured successfully at least twice may be hooked under a user-mode exception. The guard still runs every check under it, refuses anything else it finds, and ends it on anything new; a ban remains possible (`legal/DISCLAIMER.md` §2A).<br><br>✅ **Both halves run since 2026-09-10.** The *pre-injection* refusal runs every documented check, and during every capture the Agent re-runs them every 30 s: the component inside the game removes its hooks within one frame of being told to, and within 65 s if it stops hearing from the scanner. *(Until 2026-09-15 this cell said the in-session re-scan did not run at all, which stopped being true when the Agent's capture loop landed.)* For a Vulkan title the stop is the layer's own: it checks the scanner's counter on every present and goes passthrough within one present of the stop flag, or after 65 s without a scan — a title that has stopped presenting is not stopped by that deadline, and presents nothing to be observed either. |
| **No evasion, ever** | FrameLedger does not hide, rename, obfuscate, or disguise itself. It keeps its real name, real exports, and version info. It is meant to be plainly visible to any security software that looks. This is an architectural rule, not a setting |
| **Read-only** | It never reads or writes game memory, never modifies game behavior, never touches saves or input, and never changes GPU clocks, fans, or power limits |
| **Always a way out** | FrameLedger refuses rather than pushes through. When the guard finds anti-cheat, or the hook fails, or you have not enabled a game, it **stops** — and records the session anyway: start, end, duration, whatever hardware sensors your machine provides, and the reason there is nothing else. Every measured value reads `N/A`; it never estimates one.<br><br>**The way out is that it does not inject, not that it measures another way.** An earlier version of this row promised a no-injection measurement mode. It was designed around Intel PresentMon, that was dropped on 2026-08-27 after measurement, and no replacement was chosen — so **frame times require hooking**. Said in this row rather than a footnote because the row is in the SAFETY table, and a reader deciding whether to enable a game needs the real alternative, not a comfortable one |
@@ -137,7 +144,7 @@ Elevation is **optional — for everything.** Hooked capture is the normal path
## Install
> **The latest pre-release is `v0.1.0-beta.7` (2026-09-23); before it `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.9` (2026-09-26); before it `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**.
@@ -165,4 +172,4 @@ If you find a game with anti-cheat that FrameLedger fails to detect, please open
---
**Status:** pre-release (beta). Seven 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). Nine 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.
+9
View File
@@ -31,6 +31,15 @@ now turns the game's hooking off. What IS a security report: any way to reach an
setting, a crafted rules file, a pipe message, a database edit the Agent honours — or a finding about a game that
does not turn its hooking off.
Since 0.1.0-beta.9 one narrow exception exists (owner decision D33, `docs/19_SAFETY_AND_ANTICHEAT.md` §The user-mode
exception): per game, only for one anti-cheat family that is user-mode throughout, with the guard still running every
check. The grant is a record in your own database, like the consent stamp; what keeps it narrow is the guard, which
decides itself which family it may let through. So these are security reports too: the guard letting through a family
that has a driver, a service or a `.sys` in the floor or the rules; an exception applying to a game with a kernel
driver in its folder, on a title list, or with a second anti-cheat; the Agent writing a grant on a pipe message
without its own tolerant pre-scan and session count; an exception that survives a new finding, a crash or safety stop
under it, or a changed executable; and the Overlay tolerating a family the guard did not.
## A safety gap — a game with anti-cheat that FrameLedger fails to detect
This is treated with the same priority as a security report, and it takes the **public** route: open
+2 -1
View File
@@ -15,9 +15,10 @@ Requirement IDs (`FR-x`, `NFR-x`) are referenced by other docs, commits, and tes
### FR-2 Hooking consent & control (new, safety-critical — see `19_SAFETY`)
- FR-2.1 Hooking is **off by default for every game**. Enabling requires a per-game consent dialog stating what is injected, why, and the anti-cheat/ban risk.
- FR-2.2 The static anti-cheat pre-scan disables the toggle outright for titles shipping anti-cheat; the reason is shown and the control is not clickable. Since 2026-09-25 (beta.8, owner decision) the Agent runs that pre-scan over every library entry itself — once per rules version and executable, whether or not hooking was ever asked for — and by default the game's page shows only the finding in place of the Hooking card (Settings: *Hide hooking on anti-cheat games*, `ui.hide_anticheat_hooking`); the library card says "Anti-cheat". The reason is always on the page (`19_SAFETY` §What a finding does to the game).
- FR-2.3 The runtime guard refuses injection and refuses to continue a session when anti-cheat is detected. **No override exists anywhere in the UI, config, or CLI.**
- FR-2.3 The runtime guard refuses injection and refuses to continue a session when anti-cheat is detected. **No override exists anywhere in the UI, config, or CLI.** *(Since 2026-09-26 one narrow, evidence-bound exception exists — FR-2.8. It is not an override: the guard still runs every check and decides itself which anti-cheat family it may let through.)*
- FR-2.4 Global "disable all hooking" kill switch in Settings; also honored by the Vulkan layer.
- FR-2.7 (owner decision 2026-09-22; it was a per-game override for one day, withdrawn) A finding about a game — anti-cheat named in its process, on its title lists or in its folder — turns hooking off for that game wherever the guard makes it: at the pre-scan, at a session's start, at the 30 s re-scan, or (since 2026-09-25) at the Agent's pre-scan of the library. The row carries the reason, the game's page and the notice say so, and nothing overrides it (`19_SAFETY` §What a finding does to the game).
- FR-2.8 (owner decision D33, 2026-09-26) **The user-mode anti-cheat exception.** A Settings option, off by default, lets the user grant a per-game exception to a game whose only anti-cheat findings are ONE family that is user-mode throughout (no driver, service or `.sys` in the floor or the rules), whose install tree holds no `.sys`, which is on no title list, and which FrameLedger has measured hooked at least twice (successful Tier-1 sessions). The Agent computes that eligibility itself; the user grants each game through a versioned disclosure that states the ban risk; hooking is then turned on through FR-2.1's dialog as ever. Machine-wide drivers and services, title lists, kernel drivers in the game folder, the fuzzy tier, a scan that could not finish, an unreadable process, a 32-bit game, the kill switch and Vulkan are never excepted. A new finding, a crash / safety unhook / Overlay stop under it, or a changed executable ends it; the option off suspends it; the block itself is never cleared and stays shown (FR-2.2). Sessions under it are marked with the family (`19_SAFETY` §The user-mode exception).
- FR-2.5 Repeated crashes shortly after injection auto-disable hooking for that game, with an explanation and a manual re-enable path.
- FR-2.6 Users can always see, per session, which tier produced the data.
+33
View File
@@ -55,8 +55,32 @@ entirely rather than counted as one long frame. Including it would fabricate a
stutter — the exact artifact these metrics exist to detect honestly. Gaps count
toward the session's data-quality warnings.
> **Since beta.8 a pause is a gap, and a gap is not time either.** The Overlay records nothing while FR-3.9's pause
> holds, so the first record after the resume is QPC-apart from the last one before it by the whole pause: counted, a
> fabricated minutes-long frame in every statistic — the Overlay's own comment on its pause check (`MayObserve`) names that
> artefact — and paused minutes in every average. `CaptureSession` reads the QPC as it tells the ring to resume and marks
> a gap before the first record stamped at or after it (`CaptureSessionTests.TheFirstRecordPresentedAfterAResumeFollowsAGap`,
> red before the fix). And **`D`, the time base of every average, is the time the kept intervals span** — first to last
> present less every interval a gap sat in (`FrameTimeSeries.MeasuredSeconds`, `FgWindow.Seconds`): Presented FPS is
> the kept intervals over the seconds they span, and Native / Displayed leave the gaps out of their seconds too. For
> lost records this reads the survivors' rate (a drop is the Agent falling behind, not the game) where it read the
> survivors spread over the lost time — a rate nobody measured; with no gap nothing changes.
**Lows use application frames only.** Generated frames smooth display cadence but do not represent simulation stalls; mixing them hides real stutter. A secondary "Displayed 1% Low" is stored for the Displayed chart series but never replaces the headline.
> **And since beta.8 (2026-09-25) they are computed that way — until then they were not.** Where generated frames were
> counted (`fg_mode` a technology, or `active`), `SessionAggregator` took the median, the lows, min / max, σ and the stutter
> rule over every present of the dominant stream: the 1% low of a ×2 session sat above its native average, and on the
> owner's Onimusha demo capture (DLSS FG ×3, which submits each generated frame half a millisecond after its application
> frame) the stored median read **2,073 FPS on a 60 FPS game**. `ft_app` is now `Domain.Metrics.FrameTimeSeries.ApplicationFrames`:
> the interval between two consecutive presents that carried an application frame's token, the generated presents between
> them adding no interval of their own; a gap or a present that does not claim the count breaks the chain. The segments'
> lows follow; the Displayed 1% low stays over every present. **A technology named and no application frame counted**
> (`no_evaluations`, `not_counted`) has no frame statistic at all — N/A rather than a low over presents that include
> generated frames. Per-present attribution is accurate to one present (§Frame Generation); it was measured regular —
> application, generated, generated, repeating — on that capture. **Rows written before beta.8 keep their stored
> numbers**, as with the steady state (#198); their charts are drawn from the blob with the new rule.
> **When frame generation is NOT measured, the lows are taken over presents and labelled
> `(presented)`** — added 2026-09-03 with Presented FPS. On a title with no in-process frame
> generation that is exactly the application-frame low; on one that generates frames through a
@@ -477,6 +501,15 @@ carries the three shapes.
## Upscaling — measured, not guessed (Tier 1)
> **The NVIDIA driver's overrides are a configuration, not a measurement (beta.8, 2026-09-25).** A session now also
> stores the driver profile its executable ran under (`sessions.driver_profile`: the NVIDIA App's DLSS, Ray
> Reconstruction and frame-generation overrides, read from the driver's settings store — never from the game's process
> or memory, CLAUDE.md rule 4) and the driver's own per-process override report in full (`ngx_driver_words`: preset,
> mode, ratio beside the masks). Both are shown as what the driver was set to do and what it says it did — "NVIDIA
> profile …: DLSS override (preset K, Quality)" — and neither changes a measured value, a rung of the upscaler ladder or
> the frame-generation factor: those stay what the hooks saw. A profile override the hooks contradict is two true
> statements about different things, and the page shows both.
From the upscaler hooks we get, per frame:
- `upscaler`: the technology **actually executing** (`dlss`, `fsr2`, `fsr3`, `fsr4`, `xess`, `nis`, `none`) — from the API that was called, not from a DLL sitting on disk.
+35 -2
View File
@@ -227,6 +227,18 @@ Its result is authoritative: no code path may inject without a passing check, an
What the Agent checks **before** asking the guard is the thing the native side structurally cannot see: **per-game consent** (CLAUDE.md rule 1). Consent is a record of something a human did, so `HookedCaptureGate` refuses an unconsented or un-enabled game without the guard ever being called.
> **The user-mode exception (D33, 2026-09-26) — one branch, and it only narrows.** A blocked game is refused
> `PreviouslyBlocked` before the guard is asked, as ever, UNLESS `HookRequest.FromConsent` found its exception in
> force: `hooking.usermode_ac_exceptions` on, a grant on the row made on the executable on disk, the block naming that
> family (`UserModeExceptionRules.CoveredFamily`) — and the session could publish the Overlay's channel
> (`IOverlayToleranceChannel`, `07_IPC` §D) BEFORE building the request. Then the gate hands the guard the family's
> NAME through the same entry (`GuardedInjectAsync` / `…WhenReadyAsync`), the guard decides whether to honour it and
> runs every check, and every 30 s re-scan names it again (`GuardSupervisor(guard, toleratedFamily)`). A blocked row
> whose exception does not apply is hooking-off before the process is opened, like any other. A hooked session under
> it is marked (`sessions.ac_exception_family`, `; ac-exception=<family>` in the notes), and a finding about the game,
> a safety unhook, the Overlay's own stop or a crash while hooked ends the exception (`UserModeExceptionLapsePolicy`,
> after the row is stored). `19_SAFETY` §The user-mode exception is the rule; this is where the loop applies it.
> **Where it lives, corrected 2026-08-06.** This sentence said "lives in SQLite", and was the
> only line in the tree that said where consent lives — while no database, no `games` table
> and no consent writer existed in any `.cs` file (§S27). The port is
@@ -315,6 +327,12 @@ than a tuning knob. ~~There is no UI thread in P2; the pipe reader (P3) joins as
the pipe's tasks touches the ring or the recorder, and the session loop never waits on a client. The command half (PR-1b) is the
`Channel` producer this sentence anticipated.
> **The pause is a gap (beta.8).** FR-3.9's pause stops the Overlay recording; the loop reads the QPC as it tells the ring
> to resume (`ApplyPause`, before `SetPaused(false)`, on the Overlay's own clock — `Stopwatch` is `QueryPerformanceCounter`)
> and marks a gap before the first drained record stamped at or after it (`MarkResume`). A record drained after the
> resume but stamped before it is a straggler the pause had not reached. `03_METRICS` §Data gaps says what a gap then
> does to the statistics and to `D`.
## Telemetry poller
1 Hz on its own thread: `CompositeTelemetrySource.TryRead` (`18_GPU_VENDOR_APIS` — DXGI/PDH baseline, LibreHardwareMonitor sensors, NVAPI extras on NVIDIA) + optional CPU sample when the Agent is elevated and PawnIO is present. Never called from the game process, never faster than 500 ms. Samples carry the session QPC epoch for timeline alignment.
@@ -403,8 +421,8 @@ because a layer cannot leave a running game's loader chain.
## Crash & exit classification
- Normal: presenting PID exit code 0.
- `crashed`: nonzero exit code, **or** an Application Error (1000) / WER (1001) event log record naming the exe within `[start, end + 30 s]`.
- 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.
- `degraded`: Overlay self-disabled after faults, or ring layout mismatch mid-session.
- `interrupted`: Agent died mid-session; recovered from `.partial` on next start.
@@ -422,6 +440,21 @@ Crash-within-60s-of-injection happening twice for the same game ⇒ **hooking au
> exit code and the witness (`end=TargetExited; exit_code=-1073741819; crash_event=application_log`).
> `CrashAutoDisablePolicy` counts only crashes inside the 60 s window after the attach — `hook_crash_count`
> is that count and nothing else — and disables on the second; it never re-enables.
>
> **Corrected 2026-09-25 (beta.8, owner item 5): End task is not a crash.** The owner's sessions ended by Task Manager
> read *Crashed* — every non-zero code was one, and `TerminateProcess` leaves 1. A crash is now an exception's code or
> the event log's witness; any other code is `normal` with the code in the notes, and the session summary says it
> ("ended with exit code 1 — what End task and taskkill leave…", "crashed (0xC0000005 access violation)", "0xC0000006
> in-page I/O error: a disk or drive failed…"). **The safety policy did not get looser:** it takes the exit code beside
> the status and still counts every non-zero exit inside its window — a game the hook hung that the user then ended is
> the shape it exists for — and its row reason says "ended abnormally", not "crashed" (`19_SAFETY` §Crash & stability).
>
> **The notes' guard slot has three positions since the same day:** `guard=Reason|Family|Signal`, every slot present
> and `;` never inside one (`CaptureNotes.GuardSlot`). It was `Reason/Family/Signal` with an empty family dropped, so
> a refusal no family names put its signal where the family goes — and the notice read "Access is denied was detected
> in this game" — and a signal with a `;` was cut there. Old rows are read by the one rule that separates them: findings
> and the gate's own refusals carry a family, every other reason's second part was its signal. A launch that cannot
> start keeps Windows' reason (`launch_error=740`; `IProcessLauncher.Start(…, out win32Error)`).
## Live progress
+34 -3
View File
@@ -235,7 +235,7 @@ Everything else in the table is in the data and has a fixture; `rules-validate.p
> is fetched (CLAUDE.md rule 8's "opt-in store metadata" is the online lookup, which does not exist). First-run
> step 4 now points at File ▸ Import library… rather than saying "later build".
**Publisher/version order:** store manifest → PE `CompanyName`/`ProductVersion` → *(opt-in)* Steam `appdetails` lookup, cached 7 days.
**Publisher/version order:** store manifest → PE `CompanyName`/`ProductVersion` → *(opt-in)* Steam `appdetails` lookup, cached 7 days. *(Since beta.8 the PE versions are stored beside the store's rather than instead of it — §What the files say about themselves; the page labels a store's value with its store, "Steam build 20374416".)*
## Capability hints (explicitly labelled as such)
@@ -243,8 +243,8 @@ Files shipped with a game tell us what it *supports*. These populate a **"Suppor
- DLSS SR `nvngx_dlss.dll` · DLSS-G `nvngx_dlssg.dll` · **Ray Reconstruction `nvngx_dlssd.dll`**
- Streamline `sl.interposer.dll`, `sl.dlss_g.dll`, `sl.reflex.dll`
- FSR `ffx_fsr2_*.dll`, `ffx_frameinterpolation_*.dll`, `amd_fidelityfx_*.dll`, `ffx_api*.dll` — a hint still, even though `amd_fidelityfx_dx12.dll` / `_upscaler_dx12.dll` / `_framegeneration_dx12.dll` are *hooked* since 2026-09-04: the measured chip comes from the dispatch, never from the file
- XeSS `libxess.dll`, XeFG `libxess_fg.dll`
- FSR `ffx_fsr2_*.dll`, `ffx_fsr3*.dll` (since rules 2026.09.5 — FSR 3's `ffx_fsr3_x64.dll` / `ffx_fsr3upscaler_x64.dll` matched nothing before), `ffx_frameinterpolation_*.dll`, `amd_fidelityfx_*.dll`, `ffx_api*.dll` — a hint still, even though `amd_fidelityfx_dx12.dll` / `_upscaler_dx12.dll` / `_framegeneration_dx12.dll` are *hooked* since 2026-09-04: the measured chip comes from the dispatch, never from the file
- XeSS `libxess.dll`, `libxess_dx11.dll` (since rules 2026.09.5), XeFG `libxess_fg.dll`
- DXR-capable: `d3d12.dll` usage + RT-capable GPU (capability only — says nothing about the game)
- **Vulkan (since P4 PR-2, 2026-09-14) — a code-level fact, not a rule.** The rules can only ask about files
beside the executable, and the Vulkan loader is not one of them (`vulkan-1.dll` lives in System32). So
@@ -257,6 +257,37 @@ Files shipped with a game tell us what it *supports*. These populate a **"Suppor
The UI wording is deliberate: **"Supports DLSS-G"** (capability, from files) versus **"Frame Generation: DLSS-G ×1.9"** (measured, from this session). Users conflating these is exactly the confusion the old design created.
### What the files say about themselves (beta.8, 2026-09-25, schema 0011)
The owner asked for the game's version, the DLSS / FSR versions and whether a game is 32- or 64-bit. The sweep read
most of it already and kept none of it; since beta.8 it keeps four more facts per game, written whole with each
detection (`DetectionWrite`, `games.exe_machine` / `exe_file_version` / `exe_product_version` / `library_versions`):
- **What the executable runs as** — `PeImports.ReadArchitecture`, from the same bounded header read as the imports:
the COFF machine and, for a .NET executable, the CLR header's flags (`Domain.Detection.ExecutableArchitecture`:
`x64 | x86 | arm64 | arm | anycpu | anycpu32 | other | unknown`). An "AnyCPU" assembly carries an I386 machine and
runs as a 64-bit process unless it prefers or requires 32-bit, which is why the machine alone is not the answer.
`x86`, `anycpu32`, `arm64` and `arm` are **known not hookable** — the hook is an x64 DLL loaded with `LoadLibraryW`
(CLAUDE.md rule 3) — so enabling hooking on one is refused before anything is scanned or stamped
(`Refused { reason: "ExecutableNotX64", signal: <id> }`, `07_IPC`), and a row enabled before this build read the file
has its hooking turned off by the sweep (`hook_autodisabled_reason` = `executable is x86: the hook runs in x64
processes only`). `unknown` and `other` are not: the guard's `TargetIsWow64` at a session's start stays the check.
A row whose `exe_machine` is NULL is stale once, so every library entry is read under this build.
- **The executable's own versions** — the PE `FileVersion` and `ProductVersion` strings. The file's word, kept apart
from `game_version`, which is the store's (a Steam build id, a GOG or Epic version string) or the user's. For an
Unreal title the file version is often the *engine's*; the page labels both and does not pick one.
- **What it ships, with versions** — every file a capability rule names among those the walk listed, with the
numeric version of its `VS_FIXEDFILEINFO` (the version *string* may carry text, and Streamline stamps `2,8,0,0`):
`nvngx_dlss.dll 3.7.10.0`, `sl.interposer.dll 2.8.0.0`, `ffx_fsr2_api_x64.dll …`. Bounded at 48 files. A file with
no version resource is listed with none — it is shipped either way. FSR is named by its file, never mapped to an
"FSR 2.2" number: the DLL's version is the SDK's, and no table of that mapping has been measured.
**Shipped is not loaded.** `library_versions` is what the game folder holds. What the process loaded is
`sessions.runtime_modules` (Tier 1), and the two differ exactly when something else supplied the DLL — the NVIDIA
App's DLSS override loads the driver's `nvngx_dlss.dll` from the driver store under the same name. The session
summary prints the loaded list and names such a difference ("the game ships 3.7.10.0: another copy was loaded");
it does not claim who loaded it.
## Anti-cheat pre-scan (static)
Before a game is ever launched with hooking enabled, the static scan checks for anti-cheat SDKs shipped alongside it (`EasyAntiCheat/` directory, BattlEye binaries, EOS anti-cheat components, etc.). A hit **disables the hooking toggle for that game entirely** in the UI, with an explanation — the user cannot enable it, so the guard never even has to fire at launch. Prevention beats interception.
+62 -2
View File
@@ -2,7 +2,7 @@
`%LOCALAPPDATA%\FrameLedger\ledger.db`. Pragmas: `journal_mode=WAL`, `synchronous=NORMAL`, `foreign_keys=ON`, `busy_timeout=5000`. `Microsoft.Data.Sqlite` + Dapper; all writes in explicit transactions.
**Writer ownership:** Agent writes `sessions`, `session_segments`, `frame_blobs`, `sensor_blobs`, `hardware_snapshots`, the hook-state columns on `games`, **and since P4 PR-1 (2026-09-14) the *detected* columns on `games`** — `engine`, `engine_version`, `platform` under the per-field provenance rule (`05_DETECTION` §Caching: a `user` field is never touched), `capability_flags` whole, and the cache key `detection_rules_version` / `detection_exe_size_bytes` / `detection_exe_mtime_ms` — through `IGameRepository.ApplyDetectionAsync` only. The UI and the Agent were both already writers of `games`; this adds columns to the Agent's half, not a third writer (HANDOFF §P4). **And since P4 PR-4 the UI's library import writes `platform`, `store_id` and `game_version` through `ApplyStoreMetadataAsync`** — the same per-field provenance rule, badged `detected` (a store's record is not the user's typing), on columns the UI already owned. **And since 2026-09-23 the Agent's relocator merges two entries for one executable under two drive letters** (`IGameMerge`, HANDOFF D26, `19_SAFETY` §A moved drive is the same executable): in one transaction it re-parents the dropped entry's `sessions` to the survivor (before the delete — `sessions.game_id` cascades), carries a block or a crash auto-disable still in force to the survivor (`hook_enabled` only ever to 0; `hook_blocked_reason` is copied, never originated or cleared), adds the crash counts, deletes the dropped `games` row, and then moves the survivor to the file's path (after the delete — `exe_path` is UNIQUE). It is the one Agent write that deletes a `games` row; it never touches a consent column. **And since 2026-09-23 the UI writes `record_sessions`** (schema 0009, FR-1.6): the entry's recording switch, which the Agent only reads — off, the watcher does not watch for the program. The script's one data change switches it off for entries an old import made for Steam's own tools (`SteamLibrarySource.KnownTools`, the ids as of the script); a twin merge keeps it off when either twin had it off. **And since 2026-09-25 the Agent's pre-scan of the library (`19_SAFETY` §What a finding does to the game) writes the hook-state columns of every entry, not only of those the user asked to hook** — `hook_prescan_state`, and on a finding `hook_enabled = 0` and `hook_blocked_reason` — and its own key, `hook_prescan_rules_version` / `hook_prescan_exe_size_bytes` / `hook_prescan_exe_mtime_ms` (schema 0010), through `IGameConsentStore.RecordPreScanAsync` only: columns that were already the Agent's, never over a block, never a new row. **Maintenance (P4 PR-7) adds no writer:** the retention sweep on demand is the Agent's, asked over the pipe; the UI's `VACUUM` rewrites pages with the same contents and changes no row (§Retention built note). UI writes `games` (user-editable fields — since P3 PR-3 that is the FR-1.3 metadata, the `*_default` tri-states, and `removed_at`; never a `hook_*` column), `session_annotations` (tags, notes, and since schema 0002 the FR-8.3 overrides — which is WHY they are on this table and not on `sessions`), `settings`, `legal_acceptance`. Both read everything. The ports say the same in their names: `IGameRepository.UpdateMetadataAsync` / `SetTriStateDefaultAsync` / `RemoveAsync`, `ISessionAnnotationRepository`, `RegisteredSettings`, `ILegalAcceptanceStore.RecordAsync` (all P3 PR-3).
**Writer ownership:** Agent writes `sessions`, `session_segments`, `frame_blobs`, `sensor_blobs`, `hardware_snapshots`, the hook-state columns on `games`, **and since P4 PR-1 (2026-09-14) the *detected* columns on `games`** — `engine`, `engine_version`, `platform` under the per-field provenance rule (`05_DETECTION` §Caching: a `user` field is never touched), `capability_flags` whole, and the cache key `detection_rules_version` / `detection_exe_size_bytes` / `detection_exe_mtime_ms`, and since schema 0011 (2026-09-25) the executable's own facts `exe_machine` / `exe_file_version` / `exe_product_version` / `library_versions`, written whole like the flags — through `IGameRepository.ApplyDetectionAsync` only. The UI and the Agent were both already writers of `games`; this adds columns to the Agent's half, not a third writer (HANDOFF §P4). **And since P4 PR-4 the UI's library import writes `platform`, `store_id` and `game_version` through `ApplyStoreMetadataAsync`** — the same per-field provenance rule, badged `detected` (a store's record is not the user's typing), on columns the UI already owned. **And since 2026-09-23 the Agent's relocator merges two entries for one executable under two drive letters** (`IGameMerge`, HANDOFF D26, `19_SAFETY` §A moved drive is the same executable): in one transaction it re-parents the dropped entry's `sessions` to the survivor (before the delete — `sessions.game_id` cascades), carries a block or a crash auto-disable still in force to the survivor (`hook_enabled` only ever to 0; `hook_blocked_reason` is copied, never originated or cleared), adds the crash counts, deletes the dropped `games` row, and then moves the survivor to the file's path (after the delete — `exe_path` is UNIQUE). It is the one Agent write that deletes a `games` row; it never touches a consent column. **And since 2026-09-23 the UI writes `record_sessions`** (schema 0009, FR-1.6): the entry's recording switch, which the Agent only reads — off, the watcher does not watch for the program. The script's one data change switches it off for entries an old import made for Steam's own tools (`SteamLibrarySource.KnownTools`, the ids as of the script); a twin merge keeps it off when either twin had it off. **And since 2026-09-25 the Agent's pre-scan of the library (`19_SAFETY` §What a finding does to the game) writes the hook-state columns of every entry, not only of those the user asked to hook** — `hook_prescan_state`, and on a finding `hook_enabled = 0` and `hook_blocked_reason` — and its own key, `hook_prescan_rules_version` / `hook_prescan_exe_size_bytes` / `hook_prescan_exe_mtime_ms` (schema 0010), through `IGameConsentStore.RecordPreScanAsync` only: columns that were already the Agent's, never over a block, never a new row. **And since 2026-09-26 (schema 0014, D33) the Agent writes the user-mode exception's columns** — `ac_exception_*` on `games` through `IGameConsentStore` only (eligibility from the sweep, a grant from the `SetAntiCheatException` command, every end), and `sessions.ac_exception_family` with the session — the grant only after the user accepted its disclosure in the UI, which asks and never writes. **Maintenance (P4 PR-7) adds no writer:** the retention sweep on demand is the Agent's, asked over the pipe; the UI's `VACUUM` rewrites pages with the same contents and changes no row (§Retention built note). UI writes `games` (user-editable fields — since P3 PR-3 that is the FR-1.3 metadata, the `*_default` tri-states, and `removed_at`; never a `hook_*` column), `session_annotations` (tags, notes, and since schema 0002 the FR-8.3 overrides — which is WHY they are on this table and not on `sessions`), `settings`, `legal_acceptance`. Both read everything. The ports say the same in their names: `IGameRepository.UpdateMetadataAsync` / `SetTriStateDefaultAsync` / `RemoveAsync`, `ISessionAnnotationRepository`, `RegisteredSettings`, `ILegalAcceptanceStore.RecordAsync` (all P3 PR-3).
## Schema (v2 — hook architecture)
@@ -63,6 +63,22 @@ CREATE TABLE games (
hook_prescan_exe_size_bytes INTEGER, -- library last scanned the row under — the rules version and the
hook_prescan_exe_mtime_ms INTEGER, -- executable's size and mtime; NULL = never scanned by the sweep.
-- Change executable clears them with hook_prescan_state
-- schema 0014 (2026-09-26, D33): the user-mode anti-cheat exception, a layer OVER hook_blocked_reason, never its clearing
ac_exception_eligible INTEGER NOT NULL DEFAULT 0, -- the Agent's sweep: the exception may be granted now
ac_exception_verdict TEXT, -- its tolerant pre-scan, Reason|Family|Signal; NULL = nothing asked
ac_exception_sessions INTEGER NOT NULL DEFAULT 0, -- successful Tier-1 sessions counted
ac_exception_checked_rules_version TEXT, -- the key the verdict was reached under: rules, executable size and
ac_exception_checked_exe_size_bytes INTEGER, -- mtime, and the block text itself
ac_exception_checked_exe_mtime_ms INTEGER,
ac_exception_checked_block TEXT,
ac_exception_at INTEGER, -- the user's grant; NULL = no exception in force
ac_exception_family TEXT, -- the family it covers (kept as history once it ends)
ac_exception_disclosure_version TEXT, -- AntiCheatExceptionDisclosure.Version the user accepted
ac_exception_exe_size_bytes INTEGER, -- the executable the grant was made on; other bytes end it
ac_exception_exe_mtime_ms INTEGER,
ac_exception_lapsed_at INTEGER, -- when and why the last grant ended (UserModeExceptionLapse:
ac_exception_lapsed_reason TEXT, -- Withdrawn|ExecutableChanged|NoLongerEligible|NewFinding|
-- SafetyUnhook|OverlayStopped|SessionCrashed)
hook_autodisabled_reason TEXT, -- set after repeated crashes
hook_crash_count INTEGER NOT NULL DEFAULT 0,
capability_flags TEXT, -- JSON: what the game SHIPS — never a measurement. Since P4 PR-1 (2026-09-14) a JSON
@@ -76,6 +92,14 @@ CREATE TABLE games (
rr_default TEXT NOT NULL DEFAULT 'na',
detection_rules_version TEXT,
exe_machine TEXT, -- schema 0011 (2026-09-25): what the executable runs as, from its PE
-- headers (x64|x86|arm64|arm|anycpu|anycpu32|other|unknown); NULL =
-- not read by this build yet, which the detection sweep reads as stale
exe_file_version TEXT, -- schema 0011: the executable's PE FileVersion (the file's word; game_version
exe_product_version TEXT, -- is the store's or the user's) and its ProductVersion
library_versions TEXT, -- schema 0011: JSON array, the capability files the game SHIPS —
-- {"capability","path","fileVersion","productVersion"}; what a session
-- LOADED is sessions.runtime_modules
field_provenance TEXT, -- JSON: {"engine":"detected","publisher":"user",...}
-- absent or unrecognised reads as "user"
added_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
@@ -285,7 +309,10 @@ CREATE TABLE frame_blobs (
dispatch_rays BLOB, -- uint32[] : ray volume per frame, tier 1 only
pso_created BLOB, -- uint16[] : compile COUNT per frame, not a flag
vram_proc BLOB, -- uint32[] MB per frame; held 1 Hz sample, see 03_METRICS
latency_us BLOB -- uint32[], tier 1 + Reflex only
latency_us BLOB, -- uint32[], tier 1 + Reflex only
first_present_ms REAL -- schema 0013 (beta.8): the dominant stream's first present, ms from qpc_epoch —
-- the sensors' zero (t_ms) against the frames'. NULL before; the charts then
-- keep the sensor overlay off rather than draw it out of step
);
CREATE TABLE sensor_blobs (
@@ -342,8 +369,10 @@ switch's rule); integers are invariant-culture within an inclusive range; choice
| `ui.start_with_windows` | bool | `0` | | UI (P4) |
| `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 |
| `capture.background` | bool | `1` | | Agent |
| `hooking.kill_switch` | bool | `0` | | Agent (FR-2.4, since P2 PR-F) |
| `hooking.usermode_ac_exceptions` | bool | `0` | | Agent, at every session start and command (FR-2.8, D33, 2026-09-26): off suspends every user-mode exception without deleting any; on, the user still grants each eligible game |
| `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) |
@@ -367,6 +396,9 @@ Because Tier-1 and Tier-2 sessions carry different fields, every query that comp
> record ON THE SAME SWAPCHAIN; the first record of a stream, and any record after a torn slot or an
> overwrite skip, carries 0 with the `frame_flags` gap bit set, so the statistics exclude it and the export
> still reconstructs `qpc_ms`. `swapchain_ids` is present only when the session held more than one stream.
> **Schema 0013 (beta.8)** adds `frame_blobs.first_present_ms`: the charts draw the dominant stream from its first present
> and the sensors from `qpc_epoch`, and nothing said how far apart the two zeros were. Gaps stay closed up on the frame
> axis (a gap's interval is stored as 0), so a series still drifts ahead of its sensors past each gap.
> Sensor series are aligned to `t_ms` (milliseconds from `qpc_epoch`) and a tick with no reading is stored as
> **−1** — never 0, which would be a reading — because temperatures, loads, power and memory are never negative.s (NaN forbidden — assert).
@@ -479,6 +511,34 @@ Sequential embedded SQL (`Migrations/0001_init.sql`, `0002_*.sql`, …), applied
> rows read NULL, which the sweep reads as "never scanned" and scans on its first pass. `LatestVersion` is 10;
> `LedgerDatabaseTests.ScriptTenAddsThePreScanKeyEmptyForExistingRows` applies it from 9 to a ledger holding a row.
> **`0011_executable_facts.sql` (2026-09-25) — `games.exe_machine` / `exe_file_version` / `exe_product_version` /
> `library_versions`.** The owner asked for the game's version, its DLSS / FSR versions and 32- or 64-bit; the detection
> sweep read the PE version resource and walked the tree for the capability files, and kept neither. Four columns,
> written whole by that sweep (`05_DETECTION` §What the files say about themselves) — facts about files, so no
> provenance and no user override. Existing rows read NULL, and a NULL `exe_machine` makes the sweep read the row once
> more on its first pass. `LatestVersion` is 11; `LedgerDatabaseTests.ScriptElevenAddsTheExecutableFactsEmptyForExistingRows`.
> **`0012_driver_profile.sql` (2026-09-25) — `sessions.driver_profile`.** The NVIDIA driver profile the session's
> executable ran under, read by the Agent's recorder beside every session (both tiers) through the NVAPI bridge's
> read-only DRS entry point (`18_GPU_VENDOR_APIS` §L3, ABI 2): JSON (`Application.Recording.DriverProfileRecord`) —
> `Outcome` (`Application` | `Global` | `Degraded`), `Profile`, and one entry per setting of
> `Application.Capture.NvidiaDriverSettings` with its `Value` (null = set in no profile), `Location` and `Predefined`.
> A driver configuration, never a measurement (`03_METRICS` §Upscaling). NULL for every row before, and where no
> NVIDIA bridge was there to ask. The same day `ngx_driver_words` gained `Ratio`, `Mode`, `Preset`, `FgCount`,
> `FgPreset`, `FgMode` beside its masks (additive JSON fields; older rows lack them). `LatestVersion` is 12;
> `LedgerDatabaseTests.ScriptTwelveAddsTheDriverProfileColumn`.
> **`0014_usermode_ac_exception.sql` (beta.9, 2026-09-26, owner decision D33) — the user-mode anti-cheat exception.**
> Fourteen `games.ac_exception_*` columns in three groups — the Agent's eligibility answer about a blocked row and its
> key, the user's grant, and how the last grant ended — and `sessions.ac_exception_family`, the family a HOOKED session
> ran under the exception with. `ADD COLUMN` only; no row changes, so a blocked row stays blocked, not eligible, with
> no grant, until the Agent and the user say otherwise (`19_SAFETY` §The user-mode exception). Written through
> `IGameConsentStore` only — `RecordExceptionEligibilityAsync` (the sweep), `GrantAntiCheatExceptionAsync` (the
> `SetAntiCheatException` command; the store applies `UserModeExceptionRules.IsEligible` itself), `RevokeAntiCheatExceptionAsync`
> (every end) — plus one downgrade in `ChangeExecutableAsync`, which ends a grant (`ExecutableChanged`) and forgets
> the eligibility. The grant and the eligibility are each bound in SQL to the block they were reached about. `LatestVersion`
> is 14; `LedgerDatabaseTests.ScriptFourteenAddsTheExceptionColumnsAndChangesNoRow`.
> **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
+25 -2
View File
@@ -260,6 +260,28 @@ same class of bug as record drift.
Agent is inert from the beginning rather than enjoying a grace window.
- If `unhookRequested` is set, the Overlay disables hooks within one frame and sets `status = unhooked`. This path must be the fastest, most-tested code in the DLL: it is the safety stop.
## D — the tolerance mapping (`Local\FrameLedger.Tolerate.<pid>`), D33 (2026-09-26)
Agent → Overlay, once, BEFORE the injection it concerns: the anti-cheat family NAMES a game's user-mode exception
covers (`19_SAFETY` §The user-mode exception). It cannot live in A + B: the Overlay creates that mapping on init and the
Agent opens it afterwards, while the Overlay's loader detour must know the tolerance from the moment it exists.
```cpp
struct FlTolerance { // fl_tolerance.h; 16 + 8 x 64 = 528 B, no padding
uint32_t magic; // @0 FL_TOLERANCE_MAGIC ("FLTL")
uint32_t version; // @4 FL_TOLERANCE_VERSION (1)
uint32_t count; // @8 names used, <= 8
uint32_t reserved; // @12 zero
char families[8][64]; // @16 NUL-terminated ASCII family names
};
```
Created by the Agent for the game's pid, current user only, held for the session; read once by the Overlay's
`InitThread` before `InstallLoaderHook`, which resolves every name against its own compiled floor and honours only a
user-mode family. Absent, malformed or naming anything else: nothing is tolerated. Mirrored as `FlTolerance` /
`ToleranceLayout` in `FrameLedger.Shared` and held to the native layout by `ShmLayoutMirrorTests` through
`fl-layout-dump`. *(Built in beta.9: PR-1, the Overlay reads it; PR-2, the Agent writes it — `Infrastructure.Capture.OverlayToleranceChannel`, security descriptor `O:<user>D:P(A;;GR;;;<user>)` stated rather than defaulted (an elevated Agent's default DACL omits the user, and the Overlay in an unelevated game could not open it), a name that already exists refused as not ours, and a channel that cannot be published is no exception: the session then names no family and the blocked game is refused as before.)*
## C — command pipe (`\\.\pipe\FrameLedger.v2`)
Unchanged in spirit from v1, bumped to `v2` for the new message set.
@@ -323,11 +345,12 @@ Unchanged in spirit from v1, bumped to `v2` for the new message set.
| Type | Dir | Payload / notes |
|---|---|---|
| `Hello` | UI→A | `{ appVersion, protocol: 2 }` → `HelloAck { agentVersion, protocol, pid, elevated, overlayBuildId, vulkanLayerRegistered, telemetrySource /* composite, e.g. l1+lhm+nvapi */, cpuTempAvailable, disclosureVersion /* P3 PR-4, D14: the FR-2.1 text this Agent stamps against */, ~~etwAvailable~~ }` — `etwAvailable` struck 2026-09-13 with the tier it described (2026-08-28); `pid` added. `vulkanLayerRegistered` is **false by construction** today (the layer is per-launch, never registered) and `cpuTempAvailable` false unelevated; `telemetrySource` is the composite stood up once on the first `Hello` |
| `Hello` | UI→A | `{ appVersion, protocol: 2 }` → `HelloAck { agentVersion, protocol, pid, elevated, overlayBuildId, vulkanLayerRegistered, telemetrySource /* composite, e.g. l1+lhm+nvapi */, cpuTempAvailable, disclosureVersion /* P3 PR-4, D14: the FR-2.1 text this Agent stamps against */, exceptionDisclosureVersion /* D33, 2026-09-26: the user-mode exception's disclosure this Agent grants against */, ~~etwAvailable~~ }` — `etwAvailable` struck 2026-09-13 with the tier it described (2026-08-28); `pid` added. `vulkanLayerRegistered` is **false by construction** today (the layer is per-launch, never registered) and `cpuTempAvailable` false unelevated; `telemetrySource` is the composite stood up once on the first `Hello` |
| `GetStatus` | UI→A | → `StatusAck { state, activeSession?, tier? }` — and `activeSessions[]`, one `{ sessionGuid, gameId, gameName?, pid, tier, startedAt, hold? }` per running session. **`hold` added 2026-09-23, optional:** present on a session held unhooked (Tier 2), with the same words `SessionStarted.hold` carries; a session listed at tier 2 WITHOUT a `hold` has not attached yet — it is starting, not held. The App reads this list on every (re)connect (§Client behavior) |
| `SetWatchlist` | UI→A | `{ entries: [{ gameId?, exePath }] }` — ~~full replace~~ **ensure, never remove** (built 2026-09-13, PR-1b): each entry's path is normalised by the Agent, its row ensured with hooking OFF when new, and the ack is `WatchlistAck { games: [{ gameId, exePath, name }], unreadable: [exePath] }`; `gameId` in a request is a hint and never trusted over the path. UI re-sends on connect. **Carries no hooking state** (see §The pipe is not a trust boundary). *Since the App writes `games` rows itself under `06_DATA_MODEL` §Writer ownership (HANDOFF §P3 D15), this is the pipe's way of adding a row, not the only one; the watcher reads the table at 1 Hz either way.* |
| `LaunchGame` | UI→A | `{ gameId, arguments? }` → ~~suspended-launch~~ launch mode as built ("inject late", `04_CAPTURE` §Launch mode) → `LaunchAck { gameId, accepted, outcome, sessionGuid? }` — `outcome` is `Accepted` · `UnknownGame` · `SessionRunning` (one per game at a time) · `Unavailable` · `RecordingOff` (2026-09-23: the entry's recording switch is off, FR-1.6 — FrameLedger does not start what it will not record). *(Built 2026-09-13, PR-1b: `CaptureOrchestrator.LaunchAsync` over an `ILaunchRecorderFactory` the Agent composes with the Vulkan layer's environment — or none when FR-2.4's switch is on — and the launcher election runs after, as the console's `launch` does; the elected session is not addressable by the launch's guid.)* |
| `SetHookEnabled` | UI→A | `{ gameId, enabled, disclosureVersion? }` — Agent re-runs the static AC pre-scan and may reply `Refused`. **The Agent stamps the consent timestamp itself.** *(Built 2026-09-13, PR-1b, as far as it can be: `enabled: false` → `RevokeAsync` → `HookEnabledAck { gameId, enabled: false, outcome }`; `enabled: true` → the pre-scan of the executable's directory, a refusal or a "could not verify" recorded through `RecordGuardBlockAsync` and answered `Refused { gameId, reason, family?, signal? }`; a clean scan → ~~**`Error DisclosureUnavailable`, nothing stamped** — the reviewed FR-2.1 text does not exist, and a client's `disclosureVersion` is a claim, not a disclosure shown. PR-4 replaces that last branch with the stamp~~ **since PR-4 (2026-09-13): the client's `disclosureVersion` compared with the Agent's own `SafetyDisclosure.Version`; equal → the stamp from the Agent's clock with `ConsentProvenance.ConsentDialog`, answered `HookEnabledAck { enabled, outcome, prescan: "clean" }`; anything else → `Error DisclosureVersionMismatch`, nothing written (D14). `DisclosureUnavailable` remains for a composition that wired no version, which `--serve` never is.)* |
| `SetHookEnabled` | UI→A | `{ gameId, enabled, disclosureVersion? }` — Agent re-runs the static AC pre-scan and may reply `Refused`. **The Agent stamps the consent timestamp itself.** *(Built 2026-09-13, PR-1b, as far as it can be: `enabled: false` → `RevokeAsync` → `HookEnabledAck { gameId, enabled: false, outcome }`; `enabled: true` → the pre-scan of the executable's directory, a refusal or a "could not verify" recorded through `RecordGuardBlockAsync` and answered `Refused { gameId, reason, family?, signal? }`; a clean scan → ~~**`Error DisclosureUnavailable`, nothing stamped** — the reviewed FR-2.1 text does not exist, and a client's `disclosureVersion` is a claim, not a disclosure shown. PR-4 replaces that last branch with the stamp~~ **since PR-4 (2026-09-13): the client's `disclosureVersion` compared with the Agent's own `SafetyDisclosure.Version`; equal → the stamp from the Agent's clock with `ConsentProvenance.ConsentDialog`, answered `HookEnabledAck { enabled, outcome, prescan: "clean" }`; anything else → `Error DisclosureVersionMismatch`, nothing written (D14). `DisclosureUnavailable` remains for a composition that wired no version, which `--serve` never is.)* **Since beta.8 (2026-09-25):** the pre-scan is of the executable (the guard resolves the install root, PR-2 of that train), and BEFORE it an executable known not to run as x64 is answered `Refused { gameId, reason: "ExecutableNotX64", signal: "x86" | "anycpu32" | "arm64" | "arm" }` with nothing scanned and nothing written — not a guard reason and not a block (`05_DETECTION` §What the files say about themselves). **Since D33 (2026-09-26):** for a blocked game whose user-mode exception is in force for the executable on disk (the option on, a grant made on these bytes, the block naming that family) the pre-scan NAMES the family, and a pass under it is stamped as ever and answered `prescan: "exception"`; a finding about the game under it also ends the exception. |
| `SetAntiCheatException` | UI→A | **Added 2026-09-26 (D33).** `{ gameId, enabled, disclosureVersion? }` — grant or withdraw a game's user-mode anti-cheat exception (`19_SAFETY` §The user-mode exception). `enabled: false` → the exception ends (`Withdrawn`), hooking goes off while the block stands → `AntiCheatExceptionAck { gameId, granted: false, outcome, family? }`. `enabled: true` → `Error DisclosureVersionMismatch` unless `disclosureVersion` is the Agent's `AntiCheatExceptionDisclosure.Version`; `Error ExceptionsOff` while `hooking.usermode_ac_exceptions` is off; `Refused { reason: "BlockNotExceptionable" }` for a title list or an unreadable block; then the Agent's OWN facts — a tolerant pre-scan of the executable on disk naming the block's family (`Refused { reason, family, signal }` unless the guard let exactly that family through) and the successful Tier-1 sessions (`Refused { reason: "TooFewSessions", signal: <count> }` under two) — and the store writes the grant only over facts that make the game eligible → `AntiCheatExceptionAck { granted, outcome, family }`. **A grant turns nothing on**: hooking is FR-2.1's `SetHookEnabled`, afterwards. Not answered (`UnknownType`) by an Agent composed without the exception. |
| `PauseCapture` / `ResumeCapture` | UI→A | global → `PauseAck { paused }`; `StatusAck.paused` reports it. *(Built 2026-09-13, PR-1b: one in-memory flag, `CapturePause`, read by every session loop at its tick and told to the ring once per transition; supervision — the guard scan, the kill switch, the safety stop — never pauses. Not persisted: an Agent that restarts resumes.)* |
| `StopSession` | UI→A | `{ sessionGuid }` — graceful ~~unhook~~ stop + finalize → `StopAck { sessionGuid, accepted, reason? }`. *(Built 2026-09-13, PR-1b: the orchestrator names every session it starts and cancels THAT session's stop token; the loop reads it at its next tick, drains once more, and ends as `SessionEndReason.StoppedByUser` — `exit_status = normal`, the row stored like any other, the target left running. A guid nobody runs is `accepted: false`. Distinct from the host's cancellation, which leaves a `.partial`.)* |
| `UpdateRules` | UI→A | **no payload** — a trigger, not a source. The Agent re-reads only its own `%LOCALAPPDATA%\FrameLedger\rules\` copy → `UpdateRulesAck { outcome }`. *(Built 2026-09-13, PR-1b: the seeder's `EnsureSeededAsync` outcome; a payload naming a path is ignored, and a test sends one to prove it.)* |
+127
View File
@@ -223,6 +223,37 @@ All screens are `Page`s registered with the navigation page provider and navigat
> and a row stored before that form is shown as it was. The crash auto-disable's re-enable bar is not offered on a
> blocked row: its one action could only be refused. Tests: `GameDetailViewModelTests` (hidden, shown, the card
> pill), `BlockedReasonTextTests`, `PagesLoadTests.AnAntiCheatGamesPageRendersTheFindingInPlaceOfTheHookingCard`.
>
> **The user-mode exception (2026-09-26, beta.9, owner decision D33).** While Settings' option is on, a blocked
> game's page shows a **User-mode exception** card with the Agent's answer about it (`Services.ExceptionView` over
> `GameRow.AcException` — the App reads those columns and writes none): *Eligible — no exception made* with **Make
> exception…**; *Checking…* until the Agent has looked at this block; *Not eligible: N successful hooked session(s), two
> are needed*; *Not eligible: the guard also found {family} ({signal})* — Aniimo's *Kernel driver in the game folder
> (NEPKernel.sys)*; *Not eligible: {family} is not user-mode throughout*; and how the last exception ended. **Make
> exception…** opens the exception's disclosure (`AntiCheatExceptionPrompt`, text `Safety_Exception_*` versioned by
> `AntiCheatExceptionDisclosure.Version`, the primary button bound to the ticked *I accept the risk of a ban for this
> game*, Enter = *Keep it blocked*) and then `SetAntiCheatException`; the Agent gathers the facts and grants or
> refuses, and the page says which. An exception in force brings the Hooking card back — even while anti-cheat cards
> are hidden — with its switch usable through FR-2.1's dialog as ever, the finding still under it; **Withdraw
> exception** ends it and turns hooking off. With the option off a kept exception is shown *suspended* and the switch
> is disabled again. The library card says **Exception** for a game carrying one; a hooked session under it is
> *Hooked · exception* in the Sessions tab (the tooltip names the family) and its summary has one line saying so.
> Tests: `GameDetailViewModelTests.AnEligibleGameOffersTheExceptionAndOneInForceMakesTheSwitchUsable`,
> `…WhyAGameIsNotEligibleIsSaidOnItsPage`, `AntiCheatExceptionsTests`.
>
> **Details (2026-09-25, beta.8, schema 0011).** A `ui:CardExpander` **Details** under the two rows, expanded, says
> what the game's files and its store say (`05_DETECTION` §What the files say about themselves): *Runs as* (64-bit
> (x64) · 32-bit (x86) · ARM64 · .NET, any CPU (runs as 64-bit) · …), *File version* and *Product version* (the
> executable's PE resource — for an Unreal title often the engine's), *Store* ("Steam build 20374416", "GOG version
> 1.2.3" — or *Version* when the user typed it), *Engine*, and *Ships with*, one line per capability file: "DLSS:
> nvngx_dlss.dll 3.7.10.0", "XeSS: libxess.dll (no version)". A row the Agent has not read yet says so. The subtitle
> labels the store's version the same way and then drops the bare store name it would repeat. **An executable that
> cannot run as x64** (x86, 32-bit-preferring .NET, ARM) disables the hooking switch with `Hooking_NotX64_Format` under
> it and no re-enable bar — turning it on could only be refused (the Agent refuses `ExecutableNotX64` anyway); a switch
> already on can still be turned off. Tests: `GameDetailViewModelTests.TheDetailsCardSaysWhatTheFilesSayAndAnX86SwitchCannotBeTurnedOn`,
> `FormatsTests`, and the page renders in `PagesLoadTests`. **The Details card's *NVIDIA App override* row** (same day)
> is the newest session that read a driver profile, in the same words; no row where none did. Tests:
> `NvidiaOverridesTests`, `GameDetailViewModelTests.TheDetailsCardNamesTheNvidiaAppsOverridesFromTheNewestSessionThatReadThem`.
- Tabs (WPF `TabControl`, Fluent-styled):
1. **Sessions** — `DataGrid`: date, duration, **tier badge (T1/T2)**, Native, Displayed, FG×, 1% Low, 0.1% Low, resolution + upscaler, max GPU temp, API, chips, ⚠ crash badge, tags. Row → Session summary. Multi-select → "Compare". Tier-2 rows render `—` (not blank, not zero) in Tier-1-only columns, with a tooltip explaining why.
2. **Frametime** — ScottPlot timeline of selected session (decimated), stutter markers, sensor overlay toggle (temp on right axis).
@@ -243,6 +274,33 @@ 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. **Latency**: the `latency_us` blob with the stored avg / p95 lines, shown only
> when Reflex reported (`reflex_active`); otherwise the tab says so.
>
> **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
> — the tab was blank until something reloaded it. The page now draws what the view model holds when it is made
> (`PagesLoadTests.TheTrendIsDrawnWhenThePageIsMadeOnADateAxisThatKeepsItsLabel`). Also: the date axis is created
> BEFORE the theme and the label (`DateTimeTicksBottom` replaces the bottom axis, and made afterwards it dropped both);
> **Average is two metrics** — *Presented FPS* on sessions that counted no generated frame (never on one that did: its
> presented rate includes them, the single inflated number rule 6 forbids) and *Native FPS* where frame generation was
> measured — and the trend opens on Native when the newest measured session counted generated frames; the machine
> metrics count **Tier-2 sessions too** (a game never hooked had no trend); a point that describes part of its session —
> settings changed, or a steady state, for Native and Displayed as well as the factor — is drawn **hollow** and the
> note says so; hardware changes on one day are **one** marker; the metric list is built in the language the page opens
> in; the empty text names the metric.
>
> **FPS with two decimals (same day, owner item 7).** Settings ▸ Window: *Show FPS with two decimals*
> (`ui.fps_decimals`, off by default) — every FPS figure through `Formats.FpsNumber`: "62.40" when on, "62" when off,
> rounded half away from zero both ways (it rounded half to even). `Services.FpsDecimals` holds it for the process
> like `LoggingLevel`: read at start, moved at once by the toggle, shown by a page the next time it formats.
>
> **Rule 6, the places that dropped the share (same day).** A steady-state factor is never shown without its share:
> the readout line ("58 → 116 FPS (×2.0 FG · 75%)"), which the Average card and Compare use, and the Sessions grid's
> FG× column ("×2.0 · 75%"). The header's "Lifetime average" was the last measured session's readout and says so now.
>
> **Compare (same day).** The best cell is in the accent colour — a local `Foreground` on the cell outranked the
> trigger, so it was only ever bold — and "best" is the best as shown (62.4 and 62.3 both read 62, both best); the load
> rows rank nothing; the percentile axis is 0–100 again (`AutoScale` ran after `SetLimitsX` and undid it); exported
> PNGs have an opaque background (`ChartTheme.SavePng`: the window's colour under the transparent figure).
### 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), TriState chips, API/PresentMode/upscaler line, crash `InfoBar` (Severity=Error) when `crashed`, frametime chart, sensor strip, tags/notes editor, Export buttons.
@@ -262,6 +320,41 @@ Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutte
> has no per-frame source yet), the segment ribbon as alternating spans when there is more than one segment,
> and GPU temperature / load on the right axis behind the sensor toggle; `DistributionChart` draws the FPS
> histogram and the percentile curve (`Domain.Metrics.Percentile`, so the two lows are two points on it).
>
> **Honest charts, 2026-09-25 (beta.8, owner item 8: "fix the charts that are not reasonable").** Measured first on the
> owner's own Onimusha demo capture (DLSS FG ×3, read from a copy of the ledger): the title submits each generated frame
> half a millisecond after its application frame, so the "native" series — each application frame's interval to the
> present before it — was a generated frame's half millisecond, and the stored median read 2,073 FPS on a 60 FPS game.
> What changed, each with a test (`SessionSeriesLoaderTests`, `ChartMathTests`, `PagesLoadTests`):
> - **One stream.** `SessionSeriesLoader` charts the swapchain the statistics are over (`SegmentBuilder.DominantStream`,
> identified first, then the most presents) — the stored intervals are per swapchain, and two streams interleaved on
> one axis drew neither — with that stream's segments; the CSV export is the same stream (its header says so).
> - **Application frame to application frame.** The default series is each application frame's time from the previous
> application frame, the generated presents between them adding their intervals to it; a gap breaks the chain. It is
> labelled *Application frames* where frame generation was counted and *Presents* where it was not — never "Native"
> alone. A session whose presents were all generated (the `no_evaluations` refusal) charts every present and says so.
> - **The every-present line** (FR-5.4's toggle) leaves out the presents after a gap, which were drawn as 0 ms frames,
> and a note says what it is not: presents are timed at submission, and a burst of generated frames is not the
> display's cadence.
> - **Segments are labelled** with their settings (upscaler, render → output, frame generation) where the segment is
> wide enough; the label was computed for every segment and drawn for none.
> - **The sensor overlay is in step.** Schema 0013's `frame_blobs.first_present_ms` says where the first present sits on
> the sensors' clock; the overlay was drawn tens of seconds early (the launch and the loading screen). A session
> recorded before keeps the overlay off rather than drawn out of step; gaps are still closed up on the frame axis, and
> the note says how many when the overlay is on.
> - **Distribution.** The histogram is binned over the 0.5th–99.5th percentile, not min–max (one 0.3 ms non-frame set the
> axis to thousands of FPS), with the frames outside counted in a note, and its bars sit on their bins' centres (they
> sat half a bin left: ScottPlot's bins are lower edges). The percentile curve is drawn only where ten frames lie
> beyond a percentile on each side — FR-4.8's rule, generalised — so its 1% and 0.1% lows are marked exactly where
> the stat cards publish them, and the single shortest interval no longer sets the axis; the 0–100 axis holds.
> - **Sensors** (the tab and a new section of the summary window): power on a watt axis at the right, the second
> plot is *Memory* (the game's VRAM, the adapter's, the system's RAM), a per-present VRAM of 0 is a present the sample
> did not reach and is left out, the time axis says where its zero is, and every line has its own colour in both
> themes (the light theme drew power and CPU temperature in one gold). **A session that was not hooked charts its
> sensors** — kept since 2026-09-22, shown nowhere until now.
> - **The game page follows the Agent while it is shown**: a `SessionCompleted` for this game reloads it
> (`GameDetailViewModel.Attach` / `Detach` on the page's Loaded / Unloaded; the link is a singleton and must not hold the
> page). Its sessions, trend and header were the ones it opened with.
> **FR-5.3:** `Charts/Decimator` — every bucket's min and max in order, ≤ 4000 points per series per draw, a
> 500k-point series keeps its spike and its dip (`DecimatorTests`). Zoom and pan are ScottPlot's.
> **FR-9:** `SessionExporter` — the CSV with `03_METRICS` §Export schema's column line verbatim and the `#`
@@ -270,6 +363,32 @@ Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutte
> aggregates with N/A omitted, segments, the annotation); PNG through `Plot.SavePng`. Tags (comma-separated,
> de-duplicated) and notes save to the annotation row. **FR-3.8** is an in-app notice on `SessionCompleted`
> (saved / discarded); the tray toast with "View" arrives with the tray (PR-8).
>
> **The loaded libraries (2026-09-25, beta.8).** Under the hardware line, a Tier-1 session says what it had loaded —
> `sessions.runtime_modules`, written since P2 and shown nowhere until then — sorted, one line: *"Loaded:
> nvngx_dlss.dll 310.2.1.0 (the game ships 3.7.10.0: another copy was loaded, for example by the driver or the NVIDIA
> App) · sl.interposer.dll 2,8,0,0"*. The comparison is with the game's own copy (`games.library_versions`) as the
> same four numbers (`Formats.SameVersion`: Streamline's `2,8,0,0` string equals `2.8.0.0`); it names a difference and
> never who made it. Older rows show their list the day this ships; a Tier-2 row has none and no line.
>
> **The NVIDIA driver's side (2026-09-25, beta.8).** Two more lines where they have something to say
> (`Services.NvidiaOverrides`): the driver profile the game ran under and what it overrides — *"NVIDIA profile “Clair
> Obscur: Expedition 33”: DLSS override (preset K, Quality) · Frame Generation override (×4, latest preset)"*, or "no
> DLSS or frame generation override", or the global profile's when none names the game — and what the driver
> reported applying in the game's process from its override bits (*"NVIDIA driver, for this game's process: DLSS DLL
> chosen by the driver · preset K · Quality"*). Smooth Motion is labelled a setting community tools document, not
> NVIDIA. Neither line is a measurement (`03_METRICS` §Upscaling); a machine without an NVIDIA driver shows neither.
>
> **How it ended, and why (2026-09-25, beta.8, owner item 5).** Under the header line, *"How it ended: …"*
> (`Formats.ExitText`): a crash names its exception ("crashed (0xC0000005 access violation)", "0xC0000006 in-page I/O
> error: a disk or drive failed while the game read its files"), End task's exit code is an ordinary end said as
> what it is, and the event log's witness is named as such. The Tier-2 sentence has words for **every**
> `SessionEndReason` (`Formats.EndReasonText`, an enum-walk test keeps it so) and for every refusal no anti-cheat
> family names (`Formats.GuardSentence`: "The anti-cheat guard did not hook this game: the game is 32-bit…") — the
> safety notice and the enable-time refusal use the same words instead of "<signal> was detected in this game"; a
> launch that could not start says Windows' reason. The game page's missing-executable bar says whether the **drive**
> is not connected (FrameLedger finds the game again when it is) or the file is gone from its path, and so does the
> notice when enabling hooking meets an unreadable executable. Tests: `ReasonTextTests`, `Tier2ReasonTests`.
### Compare
Session picker (2–5, cross-game allowed) → overlaid percentile curves + stat table with best-value highlighting; FG columns always show Native and Displayed separately. Export PNG.
@@ -347,6 +466,14 @@ Agent section: elevation state with a plain explanation of what elevation *optio
> **2026-09-25 (beta.8):** Capture gained *Hide hooking on anti-cheat games* (`ui.hide_anticheat_hooking`, on by
> default) between the kill switch and the Vulkan layer row — §Games says what it hides; the game's page reads it at
> each load. It hides a control that could only be refused, never the finding.
>
> **2026-09-26 (beta.9, D33):** Capture gained *Allow hooking in games with user-mode anti-cheat that were measured
> before* (`hooking.usermode_ac_exceptions`, off by default), below the hide switch, and under it the **User-mode
> exceptions** list — the games the Agent found eligible (**Make exception…**), held back only by the session count,
> or carrying an exception (**Withdraw**), each with its finding, its successful hooked sessions and its state; with
> the option off only kept exceptions are listed, *suspended*. *Checking…* shows until the Agent has answered about
> every blocked game, and **Refresh** re-reads the list (the Agent's sweep runs every 15 s). The option is an
> Agent-read key and takes effect at the next session start and command.
### First-run flow
1. Legal Gate (FR-11): four documents, scrollable, links to GitHub-hosted versions, single Accept.
+3
View File
@@ -62,6 +62,9 @@ Consent, refusal, and safety-unhook text (FR-2.1, `19_SAFETY`) is **reviewed lik
- No machine-drafted `ja` in this category — a mistranslated ban warning is a real harm. These keys are marked `<comment>safety: human review required</comment>` and ~~the `ja` build fails the resx audit until a human reviewer signs off; until then the `en` string is shown as fallback rather than an unreviewed translation~~ **as built (2026-09-13): the audit is red on a `Safety_*` key in `ja` that carries neither `safety: human review required` nor `safety: reviewed by <name>`, and red on one marked review-required whose value is anything but the `en` string verbatim** — the key-set rule forbids leaving it out, so "shown as `en` until signed" is true by construction (the value IS the English), not by a runtime fallback. Signing = replacing the comment with `safety: reviewed by <name>` beside the reviewed text.
- Never soften the wording per locale. "May result in a permanent ban of your account" must survive translation with the same force in all three languages.
- Key prefix `Safety_*` so they are easy to audit as a group.
- **`Safety_Exception_*` (2026-09-26, D33)** is the user-mode exception's disclosure: the same rules — `ja` ships the
English verbatim marked for review — and its own version, `AntiCheatExceptionDisclosure.Version`, bumped when any of
those strings changes meaning, exactly as `SafetyDisclosure.Version` is for `Safety_Consent_*`.
> **What is in scope, stated 2026-08-06 because a binary now exists that is not.** These rules
> govern the **shipped** application's user-visible strings — what `12_BUILD` §Publish & package
+10
View File
@@ -57,6 +57,16 @@ The injected DLL. Its whole job: install hooks, write 64-byte records into a rin
> them and the loader does not list them. Body under `FL_HOOK_GUARD`, no allocation, no lock, no
> logging (rule 5). Exercised by `hook-harness --load-after-ms N PATH` (up to four), against the real
> Overlay in a real target, both jobs.
>
> **D33 (2026-09-26): one family may be tolerated.** Before `InstallLoaderHook`, `InitThread` reads
> `Local\FrameLedger.Tolerate.<pid>` once (`fl_tolerance.h`; absent = nothing tolerated, the ordinary case),
> resolves each name against its OWN compiled floor, honours only a family whose whole footprint there is
> user-mode (`fl::guard::FamilyIsUserModeOnly`) and keeps a 64-bit mask over the floor's module families. The
> detour's only change is one bit test before (b): a tolerated family's module loading late is not an early stop.
> **Overhead:** one relaxed-acquire `uint64` load, a shift and a compare, on the floor-match branch alone — a branch
> that fires approximately never — and nothing on the present path; the tolerance is read on the init thread, not in
> a hook body (and logged there as `TOLERANCE`). ctest `fl_guard` `[D33]` loads a decoy `NEP2.dll` 2.5 s in: the
> Overlay keeps recording when the mapping names NetEase Yidun, and stops when it names Easy Anti-Cheat.
4. Install present hooks for what exists (below).
5. Install feature hooks (upscaler / RT / PSO) lazily — the first time their module appears.
6. Publish `status = ready` in the handshake block.
+24 -1
View File
@@ -161,6 +161,29 @@ Still resolve **entry points defensively at runtime**: `nvapi64.dll` may be abse
> **Not in this build, stated so nobody infers it from the table below:** VRAM (`FlNvSample.vram` is
> reserved and its bit is never set — see the Memory row), power, hotspot temperature, per-domain
> utilisation beyond the GPU domain, and anything Reflex (§M8: a hook fact, not a poller field).
>
> **ABI 2 (2026-09-25, beta.8): the driver profile, read-only.** The owner asked whether the NVIDIA App overrides a
> game's DLSS (frame generation, ray reconstruction, the model preset). The NVIDIA App writes those overrides into the
> driver's own settings store (DRS), so `FlNvDriverProfile(exePath, ids, count, out)` reads them there: a DRS session
> is created, the settings loaded, the profile the driver applies to that path found (`NvAPI_DRS_FindApplicationByName`
> — a fully qualified path returns the profile the driver will apply on launch; none named → the current global
> profile), each id read with `NvAPI_DRS_GetSetting` (value, where it comes from, whether someone set it), and the
> session destroyed. **No DRS setter exists in the bridge** — not `SetSetting`, not `SaveSettings`, not
> `RestoreProfileDefault`, not `NvAPI_NGX_SetNGXOverrideState`: the overrides are the user's, and this only reports
> them. A path longer than NVAPI's string is refused, never truncated (a truncated path names another program).
> The ids and their values' meanings are NVIDIA's `NvApiDriverSettings.h` (github.com/NVIDIA/nvapi, MIT), written into
> `Application.Capture.NvidiaDriverSettings` as eighteen constants rather than vendored as a header; Smooth Motion
> (`0xB0D384C0`) is not in NVIDIA's header and is documented by community profile tools only, which every surface
> that shows it says. Managed: `NvapiDriverProfileSource` (`IDriverProfileSource`) — the Agent's recorder reads the
> profile beside every session, both tiers, and stores it in `sessions.driver_profile` (schema 0012). Verified by
> ctest `fl_nvapi_bridge` (argument refusals, DEGRADED before init, the global profile of the test's own executable on
> a GPU machine) and `NvapiBridgeMirrorTests` (`FlNvDriverProfileSize`, ABI 2).
>
> **The ctest could not fail on a GPU machine until the same day.** `fl_nvapi_bridge` was registered with
> `PASS_REGULAR_EXPRESSION` alone, which makes ctest ignore the exit code: the AVAILABLE branch's reference-counting
> check (two references, two releases, then a read expected to work) failed on every machine with an NVIDIA GPU while
> ctest reported Passed, and CI — no driver — never takes that branch. The check is corrected and the registration now
> carries a `FAIL_REGULAR_EXPRESSION` on Catch2's failure lines.
| Purpose | Function |
|---|---|
@@ -282,7 +305,7 @@ on the NVIDIA dev box even though nothing in it may be hooked or declared.
- Poll at 1 Hz on a dedicated Agent thread. Never from the game process, never from the Overlay.
- Any layer that throws or hangs twice is disabled for the session and its fields report `N/A`, rather than being retried in a loop.
- **Read-only, always.** These libraries can also set clocks, fan curves and power limits. FrameLedger never calls a setter — not in v1, not in the backlog. A measurement tool that can modify hardware state is a different product with a different risk profile.
- **Read-only, always.** These libraries can also set clocks, fan curves and power limits. FrameLedger never calls a setter — not in v1, not in the backlog. A measurement tool that can modify hardware state is a different product with a different risk profile. *(Since beta.8 the same holds for the driver's settings store: the bridge reads DRS profiles and has no entry point that writes, saves or restores one — §L3, ABI 2.)*
## Capability matrix (fill during P0 on real hardware)
+69 -4
View File
@@ -18,7 +18,7 @@ These are permanently out of scope. A PR implementing any of them is rejected re
- Hiding, renaming, or randomizing the DLL, its exports, or its shared-memory object names
- Thread hiding (`NtSetInformationThread`/`ThreadHideFromDebugger`) or debugger-evasion tricks
- Signature-breaking obfuscation/packing of our own binaries
- Any "bypass" setting, "stealth mode", or documentation explaining how to defeat the guard below. *(The first two words left this line on 2026-09-21 and returned on 2026-09-22 — §What a finding does to the game.)*
- Any "bypass" setting, "stealth mode", or documentation explaining how to defeat the guard below. *(The first two words left this line on 2026-09-21 and returned on 2026-09-22 — §What a finding does to the game. The one exception the owner has granted since, D33 on 2026-09-26, is not a bypass: the guard still runs every check and decides itself which family is user-mode — §The user-mode exception.)*
- Reading or writing game memory outside the arguments of APIs we hooked
- Kernel drivers of our own
@@ -394,7 +394,7 @@ the injection primitive, not a fifth question about the title.
- **Absent** is still `kInjectionFailed`, not `kPayloadNotOurs`. A damaged install
and a misuse of the ABI are different problems and must not share a reason.
> **There is no override.** ~~There is one, since 2026-09-21, and it is none of the things this paragraph named~~ *(one day; withdrawn 2026-09-22)*: still no hidden setting, no config-file flag, no CLI switch, no "advanced users" escape hatch, no global form. If a user disagrees with a specific entry, the path is still a GitHub issue against the rules file, reviewed in public. What exists is below.
> **There is no override.** ~~There is one, since 2026-09-21, and it is none of the things this paragraph named~~ *(one day; withdrawn 2026-09-22)*: still no hidden setting, no config-file flag, no CLI switch, no "advanced users" escape hatch, no global form. If a user disagrees with a specific entry, the path is still a GitHub issue against the rules file, reviewed in public. What exists is below — and since 2026-09-26 (D33), one narrow, evidence-bound exception for anti-cheat that is user-mode throughout, which lets a named family through while every check still runs (§The user-mode exception).
### What a finding does to the game — owner decision 2026-09-22
@@ -455,7 +455,8 @@ card is back with the finding under its disabled switch. The finding itself is o
**What clears it.** Nothing, as before: the block outlives *Change executable* and a re-import (§A game already enabled
can become blocked later). The owner asked for hooking to be turned off when anti-cheat is detected, not for a second
switch.
switch. *(Still true under D33: an exception is a separate layer over the block, never a clearing of it — §The user-mode
exception.)*
**D21 stands as a fact.** A process an anti-cheat driver protects is `SessionEndReason.TargetUnreadable` (2026-09-21:
every candidate of that name exists and none can be opened; ELDEN RING under Easy Anti-Cheat on the owner's machine).
@@ -467,6 +468,70 @@ still finds the injection primitives in exactly that file and the evasion primit
to four methods (`NoSecondMatcherTests`). `FloorFamilies` is untouched.
### The user-mode exception — owner decision 2026-09-26 (D33)
**Why it exists.** The beta.8 library sweep turned hooking off for *GIRLS' FRONTLINE 2: EXILIUM* on a documented,
unmeasured rule — NetEase Yidun, `AntiCheatFile NEP2.dll` — after FrameLedger had measured that game hooked (three
normal Tier-1 sessions in the owner's ledger, 474,143 frames). The owner asked for a way to keep measuring a game like
that, and chose, against the rule this document had kept since 2026-09-22 and with that rule quoted back to them, **an
exception the user grants per game, bound to evidence, and only for anti-cheat that is user-mode throughout.** The
reasons D22 withdrew the override are answered one by one: it "did nothing where it was wanted" — an exception is only
offered where FrameLedger has already measured the game hooked; it "only exposed the user to the risk its own disclosure
described" — that risk stands, and the disclosure says so, including that a ban can arrive days later and that FrameLedger
cannot know.
**What may be excepted — all of it must hold:**
- every finding about the game is `BlockedModule`, `AntiCheatFile` or `AntiCheatDirectory` of **one** family;
- that family's whole footprint is user-mode — no `drivers` entry, no `services` entry and no `*.sys` among its `files`, in
the compiled floor or the rules file (`fl::guard::FamilyIsUserModeOnly`). The floor cannot be shrunk, so data can make a
family kernel-level and never the reverse. On today's data that leaves NetEase Yidun, AhnLab HackShield, Anybrain and
FredaikisAntiCheat; Easy Anti-Cheat, BattlEye, ACE, NetEase Anti-Cheat, mihoyo protect, Vanguard, Ricochet and every
other family carry a driver or a service and are never excepted;
- no `*.sys` anywhere in the install tree — the kernel-driver rule (D30) is never excepted, whichever family a driver
belongs to (so *Aniimo*, which unpacks `NEPKernel.sys` beside `NEP2.dll` on its first run, stays blocked);
- the game is on no title list (`BlockedExecutable`, `BlockedStoreId` — the notorious titles are there by design);
- the ledger holds **at least two successful Tier-1 sessions** of the game: hooked, frames recorded, `exit_status = normal`
(which since beta.8 includes End task's exit code 1 and a user's stop), never crashed, never unhooked for safety.
**Never excepted, whatever the user ticked:** a machine-wide `BlockedDriver` or `BlockedService`, the fuzzy tier
(`SuspiciousUnsigned`), a scan that could not look or finish, unusable rules, `TargetUnreadable` (D21), a 32-bit target,
the kill switch, and a Vulkan target (the implicit layer's own self-scan stays strict).
**How the guard takes it.** The four evaluating ABI entries carry `toleratedFamilies` — a NAME, never evidence
(`fl_guard_abi.h`). The guard resolves it against its own rules (`ResolveTolerance`), keeps only a user-mode family,
runs every check, lets that family's modules, files and folders through **and keeps scanning past them**, so a second
family, a suspicious module or a `.sys` further in still refuses. A pass that let something through is
`kAllowedUserModeException` (reason 28, the slot the withdrawn bypass left) with the family and the signal; the session it
starts is marked with them.
**How the Overlay takes it.** The Overlay stops observing when a floor module loads after injection, so the Agent
publishes the exception's family names in `Local\FrameLedger.Tolerate.<pid>` (`fl_tolerance.h`) before it asks the guard
to inject, and the Overlay's init thread reads them once, before its loader detour exists — resolving each against its
own compiled floor and honouring only a user-mode family. A mapping that names anything else tolerates nothing, and the
Agent's 30 s re-scan keeps judging every other signal.
**What ends it.** A new finding outside the excepted family at any of the four moments above writes the block as before
and revokes the exception; a session under it that crashes, is unhooked for safety or is stopped by the Overlay's
in-process floor stop revokes it; an executable change ends it with the consent it shared a fingerprint with; turning
the option off suspends every exception. **The block itself is never cleared** — the exception is a separate layer over
it, and the finding stays on the game's page (FR-2.2).
**What it is not.** Not a bypass of a live refusal, not a global switch (a Settings option off by default enables the list,
and the user ticks each game), not reachable from the command line, and not evasion: the DLL stays `LoadLibraryW`-loaded,
named and visible (rule 3). `InjectViaLoadLibrary` still has internal linkage in `fl_guard.cpp`; `tools/chokepoint-check.ps1`
is unchanged.
*Built in beta.9. PR-1: the guard's tolerance and the Overlay's channel. PR-2: the Agent — the option
(`hooking.usermode_ac_exceptions`, off), the sweep's eligibility pass (a tolerant pre-scan keyed on the rules, the
executable and the block; the session count every pass), the `SetAntiCheatException` command (the Agent gathers the
facts itself; the store applies the rule), the gate's one branch with the channel published before the request, the
re-scans naming the family, the session's mark, and every end (`UserModeExceptionLapse`) — schema 0014. PR-3: the
option and the list in Settings, the versioned disclosure (`Safety_Exception_*`, `AntiCheatExceptionDisclosure`), the
game page's exception card and its usable switch under an exception in force, the marks, and the legal text
(Disclaimer §2A 2.7, EULA 1.3, the accuracy block, SECURITY.md) — `08_UI` §Games.*
### The floor data cannot remove
**There was a local bypass, and this paragraph is the reason it no longer works
@@ -937,7 +1002,7 @@ rules feed can switch injection on for a game without anyone looking.
## 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`.
- 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).*
- 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.
+10
View File
@@ -40,6 +40,16 @@ Rules for this document:
> where it could inject it only exposed the user. The owner asked for the opposite: a finding turns the game's hooking
> off, wherever the guard makes it. `19_SAFETY` §What a finding does to the game is the specification; CLAUDE.md rule 2 is
> unstruck. The two open items above (kernel-level families, the ja text) are moot.
>
> **2026-09-26 — one narrow exception, by owner decision D33, with the 2026-09-22 withdrawal quoted back.** Beta.8's
> library sweep blocked a game FrameLedger had measured hooked (GIRLS' FRONTLINE 2: EXILIUM, NetEase Yidun `NEP2.dll`),
> and the owner chose an evidence-bound, per-game exception for anti-cheat that is user-mode throughout (`19_SAFETY`
> §The user-mode exception; CLAUDE.md rule 2's amendment). The two reasons D22 gave are answered: it is offered only
> where FrameLedger has already measured the game hooked, and its risk is stated in its own disclosure. **What stays
> open, and is the owner's:** the `ja` text of `Safety_Exception_*`, which ships as English until a reviewer signs;
> whether a family the rules file makes kernel-level later should end existing exceptions at once (today it does, at
> the sweep's next pass and at every session start); and a real-hardware check that NEP2.dll's load time relative to
> the injection is covered on the owner's machine (the ctest decoy covers the late load).
| # | Decision | Consequence |
|---|---|---|
+91 -1
View File
@@ -1558,7 +1558,7 @@ và legal"), so the Legal Gate shows both once.
## 2026-09-25 — the beta.8 train
*Status is `CHANGELOG.md` `[Unreleased]` (then `[0.1.0-beta.8]`); this is what no other file carries. The owner's list
*Status is `CHANGELOG.md` `[0.1.0-beta.8]`; this is what no other file carries. The owner's list
(eight items: the anti-cheat set as large and strict as possible, hiding the hook part for anti-cheat games, more
metadata, NVIDIA App overrides, clearer reasons, a working Trend, FPS decimals, chart fixes) is planned as nine PRs in
one approved plan; each PR cites it.*
@@ -1601,6 +1601,91 @@ only be refused, never the finding (FR-2.2).
- **Analyzers on tests:** CA2000 flags a disposable passed into a record's constructor (construct it inside a class
that disposes it), MA0023 a regex with numbered groups (name them), CA1062 a `[Theory]` string parameter
dereferenced without a check.
- **`exe_machine` NULL is stale (schema 0011).** The detection sweep re-reads any row whose executable facts this build
has not written — so a test double of `IGameRepository.ApplyDetectionAsync` that drops the new fields makes every
sweep test re-scan forever. `unknown` is the stored "looked, could not tell".
- **`FileVersionInfo` on a System32 file reads its `.mui`.** `version.dll` read in place said 6.2.x, its copy in a temp
folder 10.0.x: compare a version against the file that was read, never against its source.
- **`PASS_REGULAR_EXPRESSION` alone makes ctest ignore the exit code.** `fl_nvapi_bridge` passed for weeks with a failing
assertion on every GPU machine (CI has no driver, so never took the branch). Any test that must print a line AND
pass needs a `FAIL_REGULAR_EXPRESSION` beside it; running the test binary directly is the check.
- **A C ABI cannot give a function and a struct one name** (`FlNvDriverProfile` the export, `FlNvDriverProfileRead` the
struct): C puts typedefs and functions in one namespace, and MSVC's error names neither clearly.
- **The driver profile is a configuration.** `sessions.driver_profile` says what the NVIDIA App set; it never feeds
the upscaler ladder or the factor. The bridge has no DRS writer, and a PR that adds one is a different product.
- **Present-to-present is not a frame time on a frame-generation title.** DLSS FG submits its generated frames in a
burst (measured: half a millisecond apart on the owner's Onimusha capture); anything over `ft_app` — lows, median,
σ, stutter, the charts' default line — is application frame to application frame (`FrameTimeSeries.ApplicationFrames`,
`SessionSeriesLoader.ApplicationFrames`).
- **A gap is neither a frame time nor time** (beta.8): `FrameTimeSeries.MeasuredSeconds` and `FgWindow.Seconds` leave
out every interval a gap sat in. A pause is a gap (`CaptureSession.MarkResume`); do not mark one any other way.
- **Reading the owner's ledger for evidence: copy it (`ledger.db` + `-wal`) to the scratchpad and read the copy** with
plain SQLite — never a FrameLedger binary against the data folder. `capture_tier` is an integer (1 = hooked); the
frame flags are Generated = 1, Gap = 4.
- **A view model that loads in its constructor raises its events to nobody** until the page subscribes; a page must
draw what the view model already holds when it is made (the Trend tab was blank on every first open).
- **`Axes.DateTimeTicksBottom()` replaces the bottom axis**: call it before the theme and the label, or both are lost.
- **A local property value outranks a style trigger** (Compare's best cell was never accent-coloured): defaults a
trigger may change go in the Style as Setters.
- **`ui.fps_decimals` is process-wide state** (`FpsDecimals`): a test that moves it belongs to `StringsCultureCollection`
with every test that reads FPS text, and restores it.
- **A status is not a policy input.** Splitting End task (exit 1) out of `crashed` would have loosened the crash
auto-disable had the policy kept reading the status alone; it takes the exit code too. Check every reader of a value
whose meaning you narrow.
- **The gate's own refusals carry a label in the family slot** (`not enabled`, `no consent`, `kill switch`, `previously
blocked`, `HookedCaptureGate`), so "has a family" does not mean "is a finding" — `IsFindingAboutTheGame` is the test.
- **`add_strings.py` replaced an existing key in place** (`Exit_Normal`, the Sessions grid's word) — it now refuses
without `--replace`; diff the resx for `-.*<value>` before committing new strings.
- **A 32-bit refusal is not a block.** `ExecutableNotX64` writes nothing — no `hook_blocked_reason`, no stamp — so a
64-bit build of the same game under *Change executable* can be hooked; the sweep's turn-off uses
`hook_autodisabled_reason`, which the page does not offer to undo while the file is still 32-bit.
## 2026-09-26 — the beta.9 train: the user-mode exception (D33)
*Status is `CHANGELOG.md` `[0.1.0-beta.9]`; this is what no other file carries. The approved plan
is four PRs: PR-1 the guard's tolerance and the Overlay's channel, PR-2 the Agent (eligibility, gate, records, schema
0014, IPC), PR-3 the App, strings, docs and legal text, PR-4 the release.*
**Decision (D33, owner, 2026-09-26, asked with rule 2 and D22 quoted back).** The beta.8 sweep turned hooking off for
GIRLS' FRONTLINE 2: EXILIUM (NetEase Yidun, `AntiCheatFile NEP2.dll`, a documented and unmeasured rule) after it had
been measured hooked; the owner asked for an exception list for user-mode anti-cheat games measured at Tier 1 before.
Chosen, all four options as recommended: **evidence-bound, per game** (a Settings option off by default, then the user
ticks each eligible game); **≥ 2 successful Tier-1 sessions**; **Aniimo stays blocked** (it unpacks `NEPKernel.sys` beside
`NEP2.dll` — the D30 `.sys` rule is never excepted); **the legal text changes** (Disclaimer §2A 2.7, EULA 1.3, the
accuracy block, SECURITY.md, FR-2.3; Privacy stays 2.4). Eligibility, what is never excepted and every lapse are in
`19_SAFETY` §The user-mode exception; the rule-2 amendment is in CLAUDE.md.
**Evidence it rests on (read from a COPY of the owner's ledger and their logs, 2026-09-26).** GF2: three normal Tier-1
sessions under the current entry (474,143 frames; three more from 2026-09-21 went with a removed entry), no `.sys` in
its tree. Aniimo: one Tier-1 session stored `crashed` (End task before beta.8, no exit code kept). A randomly named
kernel driver (`lyoxztfx.sys`) was installed on 2026-09-21 at 15:38 and is gone now, service and file, by something
the logs cannot name — the residual the disclosure states: a driver outside the game folder that no rule names is
invisible to every check.
**Traps met on the way:**
- **The ring cannot carry anything the Overlay needs before its detour is armed** — the Overlay creates it. Hence the
separate `Local\FrameLedger.Tolerate.<pid>` mapping the Agent creates BEFORE the injection (`fl_tolerance.h`).
- **A tolerant scan must keep scanning.** Every sink that used to stop at the first hit returns `true` on a tolerated
one, or a second family / a `.sys` further in would pass: the same load-order fail-open §S22(b) closed for the
exemption.
- **A prefix value of a user-mode family can match a `.sys`**; the tolerant file sink refuses any `.sys` itself.
- **CA2101 rejects `[MarshalAs(LPUTF8Str)] string`** on a P/Invoke; the tolerance crosses as NUL-terminated UTF-8
`byte[]`, the shape `FlGuardCheckRules` already used.
- **The Vulkan branch evaluates strictly**: the layer's self-scan goes inert on any anti-cheat module, so an exception
there could only buy a session that measures nothing.
- **An elevated Agent's default DACL omits the user** (`PipeAccessControl`'s remarks): a tolerance mapping created with
it could not be opened by the Overlay in an unelevated game, and the exception would fail as the Overlay's own stop.
`OverlayToleranceChannel` states `O:<user>D:P(A;;GR;;;<user>)`; a test proves the user can read it and nobody can
open it to write.
- **`hook_enabled` can be 1 on a blocked row now** — only because an exception once applied. `CaptureSession.RunAsync`
therefore treats a blocked row whose exception does not apply right now as hooking-off BEFORE the resolver opens
anything, or the option off would reopen the Borderless-Gaming problem of 2026-09-22.
- **The store applies the eligibility rule itself** (`GrantAntiCheatExceptionAsync` answers `NotEligible`), and the
grant and the eligibility are bound in SQL to the block text they were reached about: a block rewritten between the
read and the write leaves the row alone. SQLite evaluates every `SET` from the old row, which is what lets
`ChangeExecutableAsync`'s `CASE WHEN ac_exception_at IS NOT NULL` record the end of the grant it clears.
- **CA1711 rejects a type whose name ends in `Exception`**: the rules class is `UserModeExceptionRules`, the reasons
`UserModeExceptionLapse`.
## Owner-only — no PR can close these
@@ -1627,6 +1712,11 @@ only be refused, never the finding (FR-2.2).
5. **Re-ratify §S18 blocker 3 and §S27's basis** once P2's PR-C/PR-F make the Agent the shipped
injecting entry point (§P2, decision D4). The PRs restate both entries; whether the
restatement stands is the owner's.
6. **D33's first real use (beta.9).** Turn the option on; GIRLS' FRONTLINE 2 should be listed eligible (NetEase
Yidun, `NEP2.dll`, three sessions); make the exception, turn hooking on and play one session: hooked, marked
*Hooked · exception*, not stopped by the 30 s re-scan or by the Overlay when `NEP2.dll` loads. Aniimo should read
*not eligible* with its `NEPKernel.sys`; the option off makes the next session Tier 2 with the exception kept. And
the `ja` text of `Safety_Exception_*`, which ships as English until a reviewer signs.
**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
+14 -7
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-09-23.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.7`** (2026-09-23), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), 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
@@ -30,7 +30,9 @@
> named FSR 3 from the older DLLs, and FSR without a version from the newer ones, which host both
> FSR 3.1 and FSR 4. FSR 2, and FSR shipped any other way, is not identified. For DLSS titles that
> bypass Streamline, the NVIDIA driver's own per-process record is stored with the session and shown
> as *DLSS (driver-reported)*. Intel XeSS is **not** read (its SDK licence
> as *DLSS (driver-reported)*. The NVIDIA driver's profile for the game — the DLSS and frame-generation
> overrides the NVIDIA App sets — is read, never changed, and shown as the driver's settings beside what
> was measured. Intel XeSS is **not** read (its SDK licence
> forbids it), and neither is an upscaler compiled into the game: those read `N/A`, or "Unknown
> upscaler" when another vendor's hook ran in the game. Vulkan and OpenGL titles read `N/A`.
> - **Quality preset:** not reported on any title measured. The one route this software may use — the
@@ -51,7 +53,8 @@
> FG are named from the calls the game makes; any other generator (XeSS-FG, one compiled into the game)
> is shown only as active with the technology not identified, and is never named. Where a technology is
> named but its frames could not be counted, or frame generation is not measured, the software shows
> **Presented FPS** with a note on what it may include — never a Native figure.
> **Presented FPS** with a note on what it may include — never a Native figure. Where generated frames
> were counted, the lows, median and stutter are taken over application frames only.
> - **Ray tracing:** Yes/No measured on Direct3D 12 from ray-dispatch and acceleration-structure-build
> calls; the technique and path tracing are `N/A`, and so is ray tracing on other APIs.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
@@ -68,9 +71,13 @@
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
> back on for that executable.
> named in its process or in its folder (any kernel driver there counts), or the game on a title list by its
> store id or executable name — turns hooking off for that game, whether found by the Agent's own check of every
> game in the library, before injection, at a session's start or by the 30 s re-check; the game's page says so,
> and nothing turns it back on for that executable — except a user-mode exception you make yourself, per game,
> in Settings (off by default): only where the only finding is one anti-cheat that runs entirely in user mode, with
> no driver file in the game's folder, on a game already measured successfully at least twice. The guard still
> runs every check under it and ends it on anything new; a ban remains possible.
>
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
+34 -12
View File
@@ -1,6 +1,6 @@
# FrameLedger — Disclaimer
**Version:** 2.6 · **Effective:** {{RELEASE_DATE}}
**Version:** 2.7 · **Effective:** {{RELEASE_DATE}}
> **How this document is kept true.** The statement of what FrameLedger measures (§4) is `legal/ACCURACY.md`,
> embedded here and in `README.md` and bound to its source by `tools/accuracy-check.ps1`, which fails the build when a
@@ -53,7 +53,7 @@ Install it somewhere only you can write to, and verify the published SHA-256 che
FrameLedger is designed to reduce that risk substantially:
- Injection is **off by default** and must be enabled by you **per game**.
- Before injecting, and every 30 seconds afterwards, FrameLedger scans for known anti-cheat and anti-tamper components. **If it finds one, it refuses to inject; if a session is already running, it stops at the next scan.** No setting turns this off, globally or per game (§2A). Because the scan runs every 30 seconds rather than continuously, anti-cheat that loads mid-session may be present for **up to 30 seconds** before FrameLedger detects it and stops.
- Before injecting, and every 30 seconds afterwards, FrameLedger scans for known anti-cheat and anti-tamper components. **If it finds one, it refuses to inject; if a session is already running, it stops at the next scan.** No setting turns this off, globally or per game; the one exception you can make yourself, per game, still runs every check and is described in §2A. Because the scan runs every 30 seconds rather than continuously, anti-cheat that loads mid-session may be present for **up to 30 seconds** before FrameLedger detects it and stops.
**And there is a second, longer window you should know about.** The part of FrameLedger running inside the game also stops on its own if it loses contact with the part doing the scanning — because a scanner that has stopped cannot protect you. It waits **65 seconds** before concluding that contact is lost, so that one delayed scan on a busy machine does not end your session. In the worst case those windows combine: if the scanner stops at the moment anti-cheat appears, the component inside the game may keep running for up to **65 seconds** afterwards. That number is 65 and not 30, and this document says so rather than leaving the 30 above to imply it.
@@ -79,13 +79,28 @@ FrameLedger is designed to reduce that risk substantially:
**FrameLedger is intended for offline and single-player play. If you enable injection for a game with any online or competitive component, you do so entirely at your own risk and are solely responsible for the consequences, including compliance with that game's terms of service.**
## 2A. There is no way past the guard
## 2A. There is no way past the guard — and one narrow exception you can make yourself
Versions 0.1.0-beta.3 and 0.1.0-beta.4 offered a per-game switch to overrule the guard. **It has been removed.** If
FrameLedger finds anti-cheat or anti-tamper software in a game — before it injects, when a session starts, or during a
session — it refuses, turns hooking off for that game, and says so on the game's page. There is no setting, per game or
global, that turns that back on for that executable. Sessions recorded under the earlier switch stay in your database,
marked as such in their notes.
global, that overrules that. Sessions recorded under the earlier switch stay in your database, marked as such in their
notes.
**Since 0.1.0-beta.9 there is one exception, and it is not a way past the guard.** A Settings option, off unless you
turn it on, lets you make an exception — one game at a time, after a disclosure you must accept — for a game whose only
finding is a single anti-cheat that works entirely in user mode (no kernel driver, no service, and no driver file
anywhere in the game's folder), that is on no list of titles FrameLedger refuses, and that FrameLedger has already
measured successfully at least twice. Under it the guard still runs every check, before injecting and every 30
seconds, and still refuses anything else it finds; the exception ends by itself when something new is found, when a
session under it crashes or is stopped for safety, or when the game is updated, and turning the option off suspends
it. Sessions recorded under it are marked with the anti-cheat they ran beside.
**It exists because users asked for it, and it carries exactly the risk this document describes.** That anti-cheat
may still detect FrameLedger in the game and warn, block or permanently ban your account — possibly days later — and
FrameLedger cannot know whether it did. Earlier sessions that went well are no promise about the next one. **Do not
use it with a game you play online or competitively unless you accept losing that account;** the developer cannot
reverse a ban.
## 3. Stability
@@ -97,8 +112,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-09-23.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.7`** (2026-09-23), an unsigned installer built from that tag with its
> ⚠ **What FrameLedger actually measures today — 2026-09-26.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.9`** (2026-09-26), 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
@@ -116,7 +131,9 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> named FSR 3 from the older DLLs, and FSR without a version from the newer ones, which host both
> FSR 3.1 and FSR 4. FSR 2, and FSR shipped any other way, is not identified. For DLSS titles that
> bypass Streamline, the NVIDIA driver's own per-process record is stored with the session and shown
> as *DLSS (driver-reported)*. Intel XeSS is **not** read (its SDK licence
> as *DLSS (driver-reported)*. The NVIDIA driver's profile for the game — the DLSS and frame-generation
> overrides the NVIDIA App sets — is read, never changed, and shown as the driver's settings beside what
> was measured. Intel XeSS is **not** read (its SDK licence
> forbids it), and neither is an upscaler compiled into the game: those read `N/A`, or "Unknown
> upscaler" when another vendor's hook ran in the game. Vulkan and OpenGL titles read `N/A`.
> - **Quality preset:** not reported on any title measured. The one route this software may use — the
@@ -137,7 +154,8 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> FG are named from the calls the game makes; any other generator (XeSS-FG, one compiled into the game)
> is shown only as active with the technology not identified, and is never named. Where a technology is
> named but its frames could not be counted, or frame generation is not measured, the software shows
> **Presented FPS** with a note on what it may include — never a Native figure.
> **Presented FPS** with a note on what it may include — never a Native figure. Where generated frames
> were counted, the lows, median and stutter are taken over application frames only.
> - **Ray tracing:** Yes/No measured on Direct3D 12 from ray-dispatch and acceleration-structure-build
> calls; the technique and path tracing are `N/A`, and so is ray tracing on other APIs.
> - **Video memory:** in use on the whole graphics card, recorded from Windows and GPU-driver telemetry
@@ -154,9 +172,13 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
> back on for that executable.
> named in its process or in its folder (any kernel driver there counts), or the game on a title list by its
> store id or executable name — turns hooking off for that game, whether found by the Agent's own check of every
> game in the library, before injection, at a session's start or by the 30 s re-check; the game's page says so,
> and nothing turns it back on for that executable — except a user-mode exception you make yourself, per game,
> in Settings (off by default): only where the only finding is one anti-cheat that runs entirely in user mode, with
> no driver file in the game's folder, on a game already measured successfully at least twice. The guard still
> runs every check under it and ends it on anything new; a ban remains possible.
>
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
+2 -2
View File
@@ -1,6 +1,6 @@
# FrameLedger — End User License Agreement (EULA)
**Version:** 1.2 · **Effective:** {{RELEASE_DATE}}
**Version:** 1.3 · **Effective:** {{RELEASE_DATE}}
This End User License Agreement ("Agreement") applies to **FrameLedger** ("the Software"), developed and published by **poli0981** ("the Developer"), contactable at <contact@poli0981.dev> — see <https://poli0981.dev/> for other contact channels.
@@ -14,7 +14,7 @@ The Software records game performance data, hardware telemetry (temperatures, lo
## 2A. Code injection — your responsibility
To measure rendering settings accurately, the Software can load a component into a game process, **but only for games you have individually enabled**, after a consent prompt that explains the risk. The Software refuses to do so when it detects anti-cheat or anti-tamper software, turns hooking off for that game, and provides no means to override that refusal (Disclaimer §2A).
To measure rendering settings accurately, the Software can load a component into a game process, **but only for games you have individually enabled**, after a consent prompt that explains the risk. The Software refuses to do so when it detects anti-cheat or anti-tamper software, turns hooking off for that game, and provides no means to override that refusal — except a narrow, per-game exception for anti-cheat that works entirely in user mode, which you may make yourself, after a separate disclosure, for a game the Software has already measured successfully, and under which the Software still runs every check (Disclaimer §2A). By making such an exception you accept, for that game, the risk described in (b) below.
By enabling this feature for a game, you confirm that:
+5 -3
View File
@@ -1,6 +1,6 @@
# FrameLedger — Privacy Policy
**Version:** 2.3 · **Effective:** {{RELEASE_DATE}}
**Version:** 2.4 · **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), session duration, crash flags, tags and notes you write.
- Performance sessions: frame timing series, computed statistics, hardware sensor series (temperatures, load, memory usage), session duration, crash flags, the graphics driver's settings the game ran under (NVIDIA only), 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.
@@ -37,11 +37,13 @@ The "Report a bug" feature builds a zip file **on your device**, shows you exact
## 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); video-memory usage reported by the graphics runtime; loaded module names of a game being captured (for detection and for the anti-cheat safety check); and hardware sensor values from your graphics driver's own libraries.
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); video-memory usage reported by the graphics runtime; 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, and the store files that name it (Steam's and GOG's, on your disk) — to detect its engine and features and to check it for anti-cheat before any injection is possible; the NVIDIA driver's settings for your tracked executables (read only: the DLSS and frame-generation overrides the NVIDIA App set); and hardware sensor values from your graphics driver's own libraries.
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.
> **History.** Version 2.3 (2026-09-23) adds the per-entry recording switch. Before it, every program in your library was recorded whenever it ran, which recorded a utility that starts with Windows at every boot.
>
> Version 2.4 (2026-09-25, 0.1.0-beta.8) names what the software reads to check every game in your library for anti-cheat — until then it checked only a game you asked to hook — and to name the versions of its files, and the NVIDIA driver's settings for your games. The files of a library game's folder were already read to detect its engine and features; this version is the first to say so.
All of this stays on your device. None of it is transmitted anywhere.
+3 -3
View File
@@ -40,7 +40,7 @@
"level, which made it a check that could not fire."
],
"schemaVersion": 2,
"rulesVersion": "2026.09.4",
"rulesVersion": "2026.09.5",
"engines": [
{
@@ -182,8 +182,8 @@
{ "id": "dlss_g", "name": "DLSS Frame Gen", "signals": [ "nvngx_dlssg.dll", "sl.dlss_g.dll" ] },
{ "id": "dlss_rr", "name": "Ray Reconstruction","signals": [ "nvngx_dlssd.dll" ] },
{ "id": "streamline", "name": "Streamline", "signals": [ "sl.interposer.dll", "sl.reflex.dll" ] },
{ "id": "fsr", "name": "FSR", "signals": [ "ffx_fsr2_*.dll", "ffx_frameinterpolation_*.dll", "amd_fidelityfx_*.dll", "ffx_api*.dll" ] },
{ "id": "xess", "name": "XeSS", "signals": [ "libxess.dll" ] },
{ "id": "fsr", "name": "FSR", "signals": [ "ffx_fsr2_*.dll", "ffx_fsr3*.dll", "ffx_frameinterpolation_*.dll", "amd_fidelityfx_*.dll", "ffx_api*.dll" ] },
{ "id": "xess", "name": "XeSS", "signals": [ "libxess.dll", "libxess_dx11.dll" ] },
{ "id": "xefg", "name": "XeSS Frame Gen", "signals": [ "libxess_fg.dll" ] }
],
@@ -25,7 +25,9 @@ internal static class AgentIdentityFactory
// PawnIO installed. It was a constant false while nothing read a CPU sensor at all.
CpuTempAvailable: Infrastructure.Telemetry.LhmEnvironment.IsElevated && Infrastructure.Telemetry.LhmEnvironment.IsPawnIoInstalled == true,
// D14: the FR-2.1 text this build stamps against; the App compares it with its own before showing the dialog.
DisclosureVersion: SafetyDisclosure.Version);
DisclosureVersion: SafetyDisclosure.Version,
// D33: the user-mode exception's disclosure, under the same rule.
ExceptionDisclosureVersion: AntiCheatExceptionDisclosure.Version);
}
private static string Version()
@@ -34,6 +34,10 @@ internal sealed class AgentRecording
private readonly ISessionObserver _observer;
private readonly CapturePause _pause;
private readonly IRecorderPolicy _policy;
private readonly IDriverProfileSource _profiles;
private readonly IUserModeExceptionSwitch _exceptions;
private readonly IOverlayToleranceChannel _tolerance;
private readonly UserModeExceptionLapsePolicy _exceptionLapse;
public AgentRecording(
IGameConsentStore store,
@@ -53,8 +57,16 @@ internal sealed class AgentRecording
ICrashEventSource crashes,
ISessionObserver observer,
CapturePause pause,
IRecorderPolicy policy)
IRecorderPolicy policy,
IDriverProfileSource profiles,
IUserModeExceptionSwitch exceptions,
IOverlayToleranceChannel tolerance,
UserModeExceptionLapsePolicy exceptionLapse)
{
_profiles = profiles;
_exceptions = exceptions;
_tolerance = tolerance;
_exceptionLapse = exceptionLapse;
_store = store;
_gate = gate;
_guard = guard;
@@ -104,7 +116,9 @@ internal sealed class AgentRecording
TimeProvider.System,
new RecorderOptions { MinimumSessionLength = minimum, PartialFlushInterval = flush },
_observer,
_policy);
_policy,
_profiles,
_exceptionLapse);
}
/// <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>
@@ -170,7 +184,9 @@ internal sealed class AgentRecording
launcher,
observer,
_killSwitch,
_pause);
_pause,
_exceptions,
_tolerance);
/// <summary>The session and its collaborators, wired the only way the Agent allows; the recorder supplies the observer.</summary>
private sealed class Factory(AgentRecording owner, int seconds, IProcessLauncher? launcher) : ICaptureSessionFactory
@@ -70,6 +70,7 @@ internal static class AgentServices
services.AddSingleton<IRecorderPolicy, SettingsRecorderPolicy>();
services.AddSingleton<SettingsKillSwitch>();
services.AddSingleton<IKillSwitch>(static sp => sp.GetRequiredService<SettingsKillSwitch>());
AddUserModeException(services);
// The gate and the guard: one native facade, one managed gate in front of it.
services.AddSingleton<IAntiCheatGuard, NativeAntiCheatGuard>();
@@ -88,8 +89,7 @@ internal static class AgentServices
services.AddSingleton<ITargetLivenessSource, HeldProcessLivenessSource>();
services.AddSingleton<IRingAttacher>(static _ => new ShmRingAttacher(NativeAntiCheatGuard.BuildId()));
services.AddSingleton<IRuntimeModuleSnapshot>(static _ => new RuntimeModuleSnapshot(CensusNames.ModuleFileNames));
services.AddSingleton<NvapiNgxStateProbe>();
services.AddSingleton<INgxDriverProbe>(static sp => sp.GetRequiredService<NvapiNgxStateProbe>());
AddNvidia(services);
// The recorder's adapters (PR-D).
services.AddSingleton<IPartialSessionStore>(_ => new PartialSessionStore(paths.Tmp));
@@ -112,6 +112,31 @@ internal static class AgentServices
return services;
}
/// <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
/// it when a session under it ends badly.
/// </summary>
private static void AddUserModeException(IServiceCollection services)
{
services.AddSingleton<IUserModeExceptionSwitch, SettingsUserModeExceptionSwitch>();
services.AddSingleton<IOverlayToleranceChannel>(static _ => new OverlayToleranceChannel(static line => Serilog.Log.Information("{Line}", line)));
services.AddSingleton(static sp => new UserModeExceptionLapsePolicy(sp.GetRequiredService<IGameConsentStore>()));
}
/// <summary>
/// What the NVIDIA driver says about a session, through the bridge (never into a game): the per-process NGX words (P2
/// PR-E2), and since beta.8 the driver profile each session's executable runs under — the NVIDIA App's DLSS and
/// frame-generation overrides — read from the driver's settings store through the bridge's read-only DRS entry point.
/// </summary>
private static void AddNvidia(IServiceCollection services)
{
services.AddSingleton<NvapiNgxStateProbe>();
services.AddSingleton<INgxDriverProbe>(static sp => sp.GetRequiredService<NvapiNgxStateProbe>());
services.AddSingleton<NvapiDriverProfileSource>();
services.AddSingleton<IDriverProfileSource>(static sp => sp.GetRequiredService<NvapiDriverProfileSource>());
}
/// <summary>The static detection sweep (P4 PR-1, <c>05_DETECTION</c> §Caching): hosted under <c>--serve</c> only, composed and inert under <c>--console</c>.</summary>
private static void AddDetection(IServiceCollection services, AgentPaths paths)
{
@@ -153,7 +178,10 @@ internal static class AgentServices
sp.GetRequiredService<IExecutableIdentitySource>(),
static line => Serilog.Log.Information("{Line}", line),
sp.GetRequiredService<IIpcEventPublisher>(),
id => sp.GetRequiredService<CaptureOrchestrator>().IsRecording(id)));
id => sp.GetRequiredService<CaptureOrchestrator>().IsRecording(id),
// D33: the evidence and the option the user-mode exception's eligibility needs.
sp.GetRequiredService<ISessionRepository>(),
sp.GetRequiredService<IUserModeExceptionSwitch>()));
// The layer's registration follows the ledger (P4 PR-2, 12_BUILD §The Vulkan layer is not registered at
// install time): the same manifest and key --register-vklayer writes, reconciled after every consent change
@@ -185,31 +213,7 @@ internal static class AgentServices
// host's under --serve and a logged no-op under --console (TryAdd: --serve registers its own first).
services.AddSingleton<CapturePause>();
services.TryAddSingleton<IAgentLifetime, NoAgentLifetime>();
services.AddSingleton(static sp => new AgentCommandHandler(
sp.GetRequiredService<IGameRepository>(),
sp.GetRequiredService<IGameConsentStore>(),
sp.GetRequiredService<IAntiCheatGuard>(),
sp.GetRequiredService<IExecutableIdentitySource>(),
sp.GetRequiredService<CaptureOrchestrator>(),
sp.GetRequiredService<CapturePause>(),
sp.GetRequiredService<IAgentLifetime>(),
// UpdateRules: re-seed the rules file, then wake the detection sweep (P4 PR-1) — a rules change is the
// re-run trigger 05_DETECTION §Caching names, so the games table follows within the same second.
async ct =>
{
RulesSeedOutcome outcome = await new RulesSeeder(new FileSystemRulesStore()).EnsureSeededAsync(ct).ConfigureAwait(false);
sp.GetRequiredService<DetectionSweep>().RequestNow();
// And the anti-cheat pre-scan: new rules may name a game the library already holds (2026-09-25).
sp.GetRequiredService<AntiCheatPreScanSweep>().RequestNow();
return outcome.ToString();
},
// P3 PR-4 (D14): the reviewed disclosure this Agent stamps against, and its own clock for the stamp.
SafetyDisclosure.Version,
TimeProvider.System,
sp.GetRequiredService<VkLayerReconciler>(),
// P4 PR-7: the on-demand retention sweep, over the Agent's own settings read and its own blob tables.
ct => new RetentionSweep(sp.GetRequiredService<ISessionRepository>(), sp.GetRequiredService<RegisteredSettings>()).RunAsync(ct),
sp.GetRequiredService<ExecutableRelocator>()));
services.AddSingleton(static sp => CommandHandler(sp));
services.AddSingleton<IIpcRequestHandler>(static sp => new AgentRequestHandler(
AgentIdentityFactory.OfThisProcess(sp.GetRequiredService<AgentPaths>().VkLayerDirectory),
TelemetryDescriptor(),
@@ -236,6 +240,41 @@ internal static class AgentServices
}
/// <summary>The command half of the pipe (P3 PR-1b) over the Agent's own adapters — every command it answers, D33's included.</summary>
private static AgentCommandHandler CommandHandler(IServiceProvider sp) =>
new AgentCommandHandler(
sp.GetRequiredService<IGameRepository>(),
sp.GetRequiredService<IGameConsentStore>(),
sp.GetRequiredService<IAntiCheatGuard>(),
sp.GetRequiredService<IExecutableIdentitySource>(),
sp.GetRequiredService<CaptureOrchestrator>(),
sp.GetRequiredService<CapturePause>(),
sp.GetRequiredService<IAgentLifetime>(),
// UpdateRules: re-seed the rules file, then wake the detection sweep (P4 PR-1) — a rules change is the
// re-run trigger 05_DETECTION §Caching names, so the games table follows within the same second.
async ct =>
{
RulesSeedOutcome outcome = await new RulesSeeder(new FileSystemRulesStore()).EnsureSeededAsync(ct).ConfigureAwait(false);
sp.GetRequiredService<DetectionSweep>().RequestNow();
// And the anti-cheat pre-scan: new rules may name a game the library already holds (2026-09-25).
sp.GetRequiredService<AntiCheatPreScanSweep>().RequestNow();
return outcome.ToString();
},
// P3 PR-4 (D14): the reviewed disclosure this Agent stamps against, and its own clock for the stamp.
SafetyDisclosure.Version,
TimeProvider.System,
sp.GetRequiredService<VkLayerReconciler>(),
// P4 PR-7: the on-demand retention sweep, over the Agent's own settings read and its own blob tables.
ct => new RetentionSweep(sp.GetRequiredService<ISessionRepository>(), sp.GetRequiredService<RegisteredSettings>()).RunAsync(ct),
sp.GetRequiredService<ExecutableRelocator>(),
// beta.8: an executable that cannot run as x64 is refused before anything is scanned or stamped.
new PeArchitectureSource(),
// D33: the user-mode exception's option, evidence and disclosure version.
new AntiCheatExceptionCommands(
sp.GetRequiredService<IUserModeExceptionSwitch>(),
sp.GetRequiredService<ISessionRepository>(),
AntiCheatExceptionDisclosure.Version));
/// <summary>
/// <c>HelloAck.telemetrySource</c>: the layers this machine composes, read once on the first <c>Hello</c> by
/// standing the composite up and taking it down again — a library start, which is why it is not done at
+5
View File
@@ -98,6 +98,7 @@ public partial class App : System.Windows.Application
ApplyCulture(appearance.Language);
var registered = new RegisteredSettings(store);
LoggingLevel.SetDebug(await registered.GetBooleanAsync(SettingsRegistry.LogDebug).ConfigureAwait(true));
FpsDecimals.Two = await registered.GetBooleanAsync(SettingsRegistry.UiFpsDecimals).ConfigureAwait(true);
var closePolicy = new WindowClosePolicy { MinimizeToTray = await registered.GetBooleanAsync(SettingsRegistry.UiMinimizeToTray).ConfigureAwait(true) };
_host = BuildHost(_db, appearance, registered, closePolicy);
@@ -273,6 +274,10 @@ public partial class App : System.Windows.Application
// FR-2.1 (P3 PR-4): the consent dialog and the request it ends in; the toggle that opens it is the game page's (PR-5).
builder.Services.AddSingleton<IConsentPrompt, ConsentPrompt>();
builder.Services.AddSingleton<HookingConsent>();
// D33 (owner decision 2026-09-26): the user-mode exception's disclosure and the request it ends in; the list is
// Settings', the button on a blocked game's page.
builder.Services.AddSingleton<IAntiCheatExceptionPrompt, AntiCheatExceptionPrompt>();
builder.Services.AddSingleton<AntiCheatExceptions>();
AddLibrary(builder.Services);
@@ -57,6 +57,25 @@ public sealed record ChartPalette(
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]);
}
/// <summary>The colour a key names — how a chart that assigns palette entries to series by name reads them (<c>SensorsChart</c>).</summary>
public Color ByKey(string key) => key switch
{
"Chart_Figure" => Figure,
"Chart_Data" => Data,
"Chart_Axis" => Axis,
"Chart_Grid" => Grid,
"Chart_Native" => Native,
"Chart_Displayed" => Displayed,
"Chart_Stutter" => Stutter,
"Chart_StutterPso" => StutterPso,
"Chart_Sensor" => Sensor,
"Chart_SensorSecondary" => SensorSecondary,
"Chart_Segment" => Segment,
"Chart_Histogram" => Histogram,
"Chart_Percentile" => Percentile,
_ => throw new ArgumentOutOfRangeException(nameof(key), key, "not a chart palette key"),
};
private static ChartPalette Load(ApplicationTheme theme)
{
string file = theme == ApplicationTheme.Light ? "ChartPalette.Light.xaml" : "ChartPalette.Dark.xaml";
+35
View File
@@ -32,6 +32,41 @@ public static class ChartTheme
plot.Legend.FontColor = p.Axis;
}
/// <summary>
/// Save the plot as a PNG with an OPAQUE background (beta.8): on screen the figure is transparent over its card, but an
/// exported image has no card behind it, and a viewer painted its own colour under the theme's text — white axis labels
/// on a white page. The window's colour is painted for the file and the plot restored.
/// </summary>
public static void SavePng(Plot plot, string path, int width, int height)
{
ArgumentNullException.ThrowIfNull(plot);
ArgumentException.ThrowIfNullOrWhiteSpace(path);
Color figure = plot.FigureBackground.Color;
Color data = plot.DataBackground.Color;
Color window = ApplicationThemeManager.GetAppTheme() == ApplicationTheme.Light ? Color.FromHex("#F3F3F3") : Color.FromHex("#202020");
try
{
plot.FigureBackground.Color = Over(figure, window);
plot.DataBackground.Color = Over(data, Over(figure, window));
plot.SavePng(path, width, height);
}
finally
{
plot.FigureBackground.Color = figure;
plot.DataBackground.Color = data;
}
}
/// <summary>Source-over: <paramref name="top"/> composited on an opaque <paramref name="under"/>.</summary>
internal static Color Over(Color top, Color under)
{
double a = top.A / 255.0;
return new Color(
(byte)Math.Round((top.R * a) + (under.R * (1 - a))),
(byte)Math.Round((top.G * a) + (under.G * (1 - a))),
(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>
public static void Attach(WpfPlot control)
{
@@ -44,8 +44,10 @@ public partial class CompareChart : UserControl
if (DrawnCurves > 0)
{
plot.Axes.SetLimitsX(0, 100);
// The percentile axis is 0–100 whatever the data: AutoScale first, then the X limits (beta.8 — the other way
// round, AutoScale undid them).
plot.Axes.AutoScale();
plot.Axes.SetLimitsX(0, 100);
plot.ShowLegend(Alignment.UpperRight);
}
@@ -1,10 +1,15 @@
<UserControl x:Class="FrameLedger.App.Charts.DistributionChart"
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:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF"
MinHeight="240">
<!-- FR-5.1: the FPS histogram and the percentile curve, side by side. -->
<!-- FR-5.1: the FPS histogram and the percentile curve, side by side; the note says what the histogram's range left out (beta.8). -->
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="12" />
@@ -12,5 +17,6 @@
</Grid.ColumnDefinitions>
<sp:WpfPlot x:Name="Histogram" Grid.Column="0" />
<sp:WpfPlot x:Name="Percentiles" Grid.Column="2" />
<ui:TextBlock x:Name="Note" Grid.Row="1" Grid.ColumnSpan="3" Margin="0,4,0,0" Appearance="Tertiary" TextWrapping="Wrap" Visibility="Collapsed" />
</Grid>
</UserControl>
@@ -1,3 +1,5 @@
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using ScottPlot;
using ScottPlot.Plottables;
@@ -7,8 +9,10 @@ namespace FrameLedger.App.Charts;
/// <summary>
/// FR-5.1's distribution: a histogram of instantaneous FPS over application frames, and the percentile curve —
/// FPS at each percentile of frametime under <c>03_METRICS</c>' linear method (<c>Domain.Metrics.Percentile</c>),
/// so the 1% and 0.1% lows on the stat cards are two points on this curve.
/// so the 1% and 0.1% lows on the stat cards are two points on this curve, marked where the session has the frames for
/// them (<see cref="PercentileCurve"/>).
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public partial class DistributionChart : UserControl
{
private const int _bins = 60;
@@ -22,38 +26,46 @@ public partial class DistributionChart : UserControl
public ScottPlot.Plot HistogramPlot => Histogram.Plot;
/// <summary>The percentile plot, for a test's look at its axis.</summary>
public ScottPlot.Plot PercentilePlot => Percentiles.Plot;
public void Show(SessionSeries? series)
{
DrawHistogram(series);
int outside = DrawHistogram(series);
DrawPercentiles(series);
Note.Text = outside > 0 ? string.Format(CultureInfo.CurrentCulture, Strings.Chart_Note_OutsideRange_Format, outside) : string.Empty;
Note.Visibility = outside > 0 ? Visibility.Visible : Visibility.Collapsed;
}
private void DrawHistogram(SessionSeries? series)
/// <summary>Draws the histogram; the frames its range left out.</summary>
private int DrawHistogram(SessionSeries? series)
{
ScottPlot.Plot plot = Histogram.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_Fps);
plot.YLabel(Strings.Chart_Axis_Count);
int outside = 0;
if (series is { AppFrameTimesMs.Length: > 1 })
{
double[] fps = [.. series.AppFrameTimesMs.Where(static f => f > 0).Select(static f => 1000.0 / f)];
if (fps.Length > 1)
FpsHistogram histogram = FpsHistogram.Of(series.AppFrameTimesMs, _bins);
if (histogram.Centers.Length > 0)
{
var histogram = ScottPlot.Statistics.Histogram.WithBinCount(_bins, fps);
BarPlot bars = plot.Add.Bars(histogram.Bins, histogram.Counts.Select(static c => (double)c));
BarPlot bars = plot.Add.Bars(histogram.Centers, histogram.Counts);
bars.Color = ChartTheme.Current.Histogram;
foreach (Bar bar in bars.Bars)
{
bar.Size = histogram.FirstBinSize;
bar.Size = histogram.BinWidth;
bar.LineWidth = 0;
}
outside = histogram.Outside;
plot.Axes.AutoScale();
}
}
Histogram.Refresh();
return outside;
}
private void DrawPercentiles(SessionSeries? series)
@@ -66,11 +78,24 @@ public partial class DistributionChart : UserControl
if (series is { AppFrameTimesMs.Length: > 1 })
{
(double[] xs, double[] ys) = PercentileCurve.Of(series.AppFrameTimesMs);
Scatter line = plot.Add.ScatterLine(xs, ys, ChartTheme.Current.Percentile);
line.LineWidth = 2;
line.LegendText = Strings.Chart_Series_Percentile;
plot.Axes.SetLimitsX(0, 100);
if (xs.Length > 0)
{
Scatter line = plot.Add.ScatterLine(xs, ys, ChartTheme.Current.Percentile);
line.LineWidth = 2;
line.LegendText = Strings.Chart_Series_Percentile;
}
foreach ((double x, double fps, bool pointOne) in PercentileCurve.Lows(series.AppFrameTimesMs))
{
Scatter low = plot.Add.ScatterPoints(new[] { x }, new[] { fps }, ChartTheme.Current.Stutter);
low.MarkerSize = 7;
low.LegendText = pointOne ? Strings.Summary_Stat_P01Low : Strings.Summary_Stat_P1Low;
}
// The axis is 0–100 whatever the curve covers: AutoScale first, then the X limits (AutoScale afterwards undid them).
plot.Axes.AutoScale();
plot.Axes.SetLimitsX(0, 100);
plot.ShowLegend(Alignment.LowerLeft);
}
Percentiles.Refresh();
@@ -0,0 +1,54 @@
using FrameLedger.Domain.Metrics;
namespace FrameLedger.App.Charts;
/// <summary>
/// The distribution tab's histogram of instantaneous FPS over application frames (FR-5.1), binned over the 0.5th to the
/// 99.5th percentile and drawn at each bin's CENTRE (beta.8). Binned over min to max, one frame of a fraction of a
/// millisecond — a present that followed another by nothing — stretched the axis to thousands of FPS and squeezed every
/// real frame into two bars; and a bar is drawn centred on its position, where ScottPlot's bins are lower edges, so every
/// bar sat half a bin to the left of what it counted.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "a data carrier for ScottPlot, which draws double[]")]
public sealed record FpsHistogram(double[] Centers, double[] Counts, double BinWidth, int Outside)
{
/// <summary>The share cut from each end before binning.</summary>
public const double TailFraction = 0.005;
public static FpsHistogram Of(IReadOnlyList<double> appFrameTimesMs, int bins = 60)
{
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
ArgumentOutOfRangeException.ThrowIfNegativeOrZero(bins);
double[] fps = [.. appFrameTimesMs.Where(static f => f > 0).Select(static f => 1000.0 / f)];
if (fps.Length == 0)
{
return new FpsHistogram([], [], 0, 0);
}
IReadOnlyList<double> sorted = Percentile.Sorted(fps);
double lo = Percentile.Linear(sorted, TailFraction) ?? sorted[0];
double hi = Percentile.Linear(sorted, 1 - TailFraction) ?? sorted[^1];
if (hi - lo < 1e-9)
{
// Every frame at one rate: one bar, a frame per second wide, centred on it.
return new FpsHistogram([lo], [fps.Length], 1, 0);
}
double width = (hi - lo) / bins;
var counts = new double[bins];
int outside = 0;
foreach (double v in fps)
{
if (v < lo || v > hi)
{
outside++;
continue;
}
counts[Math.Min(bins - 1, (int)((v - lo) / width))]++;
}
double[] centers = [.. Enumerable.Range(0, bins).Select(b => lo + ((b + 0.5) * width))];
return new FpsHistogram(centers, counts, width, outside);
}
}
+11 -2
View File
@@ -1,8 +1,17 @@
<UserControl x:Class="FrameLedger.App.Charts.FrametimeChart"
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: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. -->
<sp:WpfPlot x:Name="Plot" />
<!-- 08_UI §Session summary / FR-5.1: the frametime timeline, min/max decimated (FR-5.3); zoom and pan are ScottPlot's.
The note above it says what the lines are not, when that is not obvious (beta.8). -->
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<ui:TextBlock x:Name="Note" Grid.Row="0" Margin="0,0,0,4" Appearance="Tertiary" TextWrapping="Wrap" Visibility="Collapsed" />
<sp:WpfPlot x:Name="Plot" Grid.Row="1" />
</Grid>
</UserControl>
+107 -11
View File
@@ -1,3 +1,5 @@
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using ScottPlot;
using ScottPlot.Plottables;
@@ -5,13 +7,17 @@ using ScottPlot.Plottables;
namespace FrameLedger.App.Charts;
/// <summary>
/// The frametime timeline (FR-5.1, FR-5.3, FR-5.4, FR-5.5): the application-frame series by default, the
/// displayed (every present) series on request, stutter markers coloured by cause where the PSO count says so,
/// the segment ribbon as translucent spans, and the sensor overlay on the right axis. Series are min/max
/// decimated per draw; the raw arrays stay in the <see cref="SessionSeries"/>.
/// The frametime timeline (FR-5.1, FR-5.3, FR-5.4, FR-5.5): the application-frame series by default, every present on
/// request, stutter markers coloured by cause where the PSO count says so, the segment ribbon as translucent spans with
/// their settings named, and the sensor overlay on the right axis. Series are min/max decimated per draw; the raw arrays
/// stay in the <see cref="SessionSeries"/>.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public partial class FrametimeChart : UserControl
{
/// <summary>A segment narrower than this share of the axis keeps its shading and loses its label (the labels would overlap).</summary>
private const double _labelledSegmentShare = 0.12;
private SessionSeries? _series;
private bool _displayed;
private bool _sensors;
@@ -28,6 +34,9 @@ public partial class FrametimeChart : UserControl
/// <summary>How many points the last draw put on the axes (a test's window into the decimation).</summary>
public int DrawnPoints { get; private set; }
/// <summary>The note the last draw showed above the plot; empty when it had nothing to say.</summary>
public string NoteText => Note.Text;
public void Show(SessionSeries? series, bool displayed, bool sensors)
{
_series = series;
@@ -48,6 +57,37 @@ public partial class FrametimeChart : UserControl
Redraw();
}
/// <summary>
/// What the lines are not, when that is not obvious (beta.8): a session whose presents were all generated is charted as
/// presents; every present is timed at submission, which is not the display's cadence; and the overlay's sensors run ahead
/// of the frames past every gap the time axis closes up.
/// </summary>
internal static string NoteFor(SessionSeries? series, bool displayed, bool sensors)
{
if (series is null || series.Presents == 0)
{
return string.Empty;
}
var lines = new List<string>(2);
if (series.NoApplicationFrames)
{
lines.Add(Strings.Chart_Note_NoApplicationFrames);
}
else if (displayed && series.HasGenerated)
{
lines.Add(Strings.Chart_Note_PresentsTiming);
}
int gaps = series.Gap.Skip(1).Count(static g => g);
if (sensors && series.SensorsAligned && gaps > 0)
{
lines.Add(string.Format(CultureInfo.CurrentCulture, Strings.Chart_Note_GapsClosed_Format, gaps));
}
return string.Join(Environment.NewLine, lines);
}
private void Redraw()
{
ScottPlot.Plot plot = Plot.Plot;
@@ -56,6 +96,8 @@ public partial class FrametimeChart : UserControl
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_Time);
plot.YLabel(Strings.Chart_Axis_Frametime);
Note.Text = NoteFor(_series, _displayed, _sensors);
Note.Visibility = Note.Text.Length > 0 ? Visibility.Visible : Visibility.Collapsed;
if (_series is null || _series.Presents == 0)
{
Plot.Refresh();
@@ -63,26 +105,33 @@ public partial class FrametimeChart : UserControl
}
ChartPalette p = ChartTheme.Current;
bool generating = _series.HasGenerated && !_series.NoApplicationFrames;
DrawSegments(plot, p);
if (_displayed && _series.HasGenerated)
if (_displayed && generating)
{
DrawSeries(plot, _series.TimesS, [.. _series.FrameTimesMs.Select(static f => (double)f)], p.Displayed, Strings.Chart_Series_Displayed);
DrawPresents(plot, p);
}
DrawSeries(plot, _series.AppTimesS, _series.AppFrameTimesMs, p.Native, Strings.Chart_Series_Native);
DrawSeries(plot, _series.AppTimesS, _series.AppFrameTimesMs, p.Native, generating ? Strings.Chart_Series_AppFrames : Strings.Chart_Series_Presents);
DrawStutter(plot, p);
if (_sensors)
if (_sensors && _series.SensorsAligned)
{
DrawSensors(plot, p);
}
plot.Axes.AutoScale();
LabelSegments(plot, p);
plot.ShowLegend(Alignment.UpperRight);
Plot.Refresh();
}
private void DrawSeries(ScottPlot.Plot plot, double[] xs, double[] ys, Color color, string label)
private void DrawSeries(ScottPlot.Plot plot, IReadOnlyList<double> xs, IReadOnlyList<double> ys, Color color, string label)
{
if (xs.Count == 0)
{
return;
}
(double[] dx, double[] dy) = Decimator.MinMax(xs, ys);
DrawnPoints += dx.Length;
SignalXY line = plot.Add.SignalXY(dx, dy, color);
@@ -90,6 +139,23 @@ public partial class FrametimeChart : UserControl
line.LegendText = label;
}
/// <summary>Every present but those after a gap, whose stored interval is 0 — not a frame, and it was drawn as a 0 ms one.</summary>
private void DrawPresents(ScottPlot.Plot plot, ChartPalette p)
{
var xs = new List<double>(_series!.Presents);
var ys = new List<double>(_series.Presents);
for (int i = 0; i < _series.Presents; i++)
{
if (!_series.Gap[i])
{
xs.Add(_series.TimesS[i]);
ys.Add(_series.FrameTimesMs[i]);
}
}
DrawSeries(plot, xs, ys, p.Displayed, Strings.Chart_Series_Displayed);
}
private void DrawStutter(ScottPlot.Plot plot, ChartPalette p)
{
if (_series?.Stutter is null)
@@ -152,6 +218,34 @@ public partial class FrametimeChart : UserControl
}
}
/// <summary>
/// Each segment's settings at its top-left corner (beta.8: the label was computed for every segment and drawn for none),
/// where the segment is wide enough to hold it. Placed after the axes are scaled, at their top.
/// </summary>
private void LabelSegments(ScottPlot.Plot plot, ChartPalette p)
{
if (_series is null || _series.Segments.Count < 2)
{
return;
}
AxisLimits limits = plot.Axes.GetLimits();
double width = limits.Right - limits.Left;
foreach (SegmentSpan segment in _series.Segments.Where(s => s.Label.Length > 0 && s.EndS - s.StartS >= width * _labelledSegmentShare))
{
Text label = plot.Add.Text(segment.Label, segment.StartS, limits.Top);
label.LabelFontSize = 11;
label.LabelFontColor = p.Axis;
label.LabelAlignment = Alignment.UpperLeft;
label.LabelOffsetX = 4;
label.LabelOffsetY = 4;
}
}
/// <summary>
/// GPU temperature and load on the right axis, over the frames' span only: the sensors sit on the frames' axis when the
/// blob said where the first present is (schema 0013), and ticks before it are the launch and the loading screen.
/// </summary>
private void DrawSensors(ScottPlot.Plot plot, ChartPalette p)
{
if (_series is null)
@@ -162,14 +256,16 @@ public partial class FrametimeChart : UserControl
IYAxis right = plot.Axes.Right;
right.Label.Text = Strings.Chart_Axis_Sensor;
int n = 0;
double end = _series.DurationS;
foreach (SensorSeries sensor in _series.Sensors.Where(static s => s.Name is "gpu_temp" or "gpu_load"))
{
if (sensor.TimesS.Length == 0)
int[] inside = [.. Enumerable.Range(0, sensor.TimesS.Length).Where(i => sensor.TimesS[i] >= 0 && sensor.TimesS[i] <= end)];
if (inside.Length == 0)
{
continue;
}
(double[] dx, double[] dy) = Decimator.MinMax(sensor.TimesS, sensor.Values, 1000);
(double[] dx, double[] dy) = Decimator.MinMax([.. inside.Select(i => sensor.TimesS[i])], [.. inside.Select(i => sensor.Values[i])], 1000);
DrawnPoints += dx.Length;
Scatter line = plot.Add.ScatterLine(dx, dy, n++ == 0 ? p.Sensor : p.SensorSecondary);
line.LineWidth = 1;
+63 -8
View File
@@ -2,9 +2,22 @@ using FrameLedger.Domain.Metrics;
namespace FrameLedger.App.Charts;
/// <summary>FPS at each percentile (0…100) of frametime, under <c>03_METRICS</c>' linear method — the distribution tab's curve and Compare's overlay.</summary>
/// <summary>
/// FPS at each percentile of frametime, under <c>03_METRICS</c>' linear method — the distribution tab's curve and Compare's
/// overlay — drawn only where the session has the frames to say it (beta.8).
/// </summary>
/// <remarks>
/// <b>A percentile is drawn when at least <see cref="FramesBeyond"/> frames lie beyond it on each side</b> — FR-4.8's rule
/// generalised: the 1% low (the 99th percentile) needs 1,000 frames and the 0.1% low (the 99.9th) 10,000, which is exactly
/// ten frames beyond each. The curve drew 0 to 100 whatever the count: its 100th point was the single worst frame, its 0th
/// the single shortest interval — thousands of FPS that set the axis for every other point — and its 99th was a 1% low the
/// stat card beside it refused to publish.
/// </remarks>
public static class PercentileCurve
{
/// <summary>Frames that must lie beyond a percentile, on each side, for it to be drawn.</summary>
public const int FramesBeyond = 10;
public static (double[] Xs, double[] Ys) Of(IReadOnlyList<double> appFrameTimesMs)
{
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
@@ -14,15 +27,57 @@ public static class PercentileCurve
}
IReadOnlyList<double> sorted = Percentile.Sorted(appFrameTimesMs);
var xs = new double[101];
var ys = new double[101];
for (int i = 0; i <= 100; i++)
var xs = new List<double>(103);
var ys = new List<double>(103);
foreach (double p in Percents())
{
xs[i] = i;
double? ft = Percentile.Linear(sorted, i / 100.0);
ys[i] = ft is > 0 ? 1000.0 / ft.Value : 0;
if (Supported(sorted.Count, p) && Fps(sorted, p) is double fps)
{
xs.Add(p);
ys.Add(fps);
}
}
return (xs, ys);
return ([.. xs], [.. ys]);
}
/// <summary>The 1% and 0.1% lows as points on the curve (x 99 and 99.9), each only where the session has the frames for it.</summary>
public static IReadOnlyList<(double X, double Fps, bool PointOne)> Lows(IReadOnlyList<double> appFrameTimesMs)
{
ArgumentNullException.ThrowIfNull(appFrameTimesMs);
IReadOnlyList<double> sorted = Percentile.Sorted(appFrameTimesMs);
var lows = new List<(double, double, bool)>(2);
if (Supported(sorted.Count, 99) && Fps(sorted, 99) is double p1)
{
lows.Add((99, p1, false));
}
if (Supported(sorted.Count, 99.9) && Fps(sorted, 99.9) is double p01)
{
lows.Add((99.9, p01, true));
}
return lows;
}
/// <summary>At least <see cref="FramesBeyond"/> of <paramref name="frames"/> lie beyond <paramref name="percent"/> on each side.</summary>
public static bool Supported(int frames, double percent) =>
frames * Math.Min(percent, 100 - percent) / 100.0 >= FramesBeyond - 1e-9;
/// <summary>0, 0.1, 1 … 99, 99.9, 100 — in order, because the curve is drawn as a line through them.</summary>
private static IEnumerable<double> Percents()
{
yield return 0;
yield return 0.1;
for (int i = 1; i <= 99; i++)
{
yield return i;
}
yield return 99.9;
yield return 100;
}
private static double? Fps(IReadOnlyList<double> sorted, double percent) =>
Percentile.Linear(sorted, percent / 100.0) is > 0 and double ft ? 1000.0 / ft : null;
}
+85 -27
View File
@@ -5,12 +5,32 @@ using ScottPlot.Plottables;
namespace FrameLedger.App.Charts;
/// <summary>
/// The Sensors tab: GPU core / hotspot temperature and load / power on one plot (°C and % left, W right),
/// and VRAM on another — the game's own usage (the per-present <c>vram_proc</c> blob, a held 1 Hz sample)
/// and the adapter-wide figure (the <c>vram_adapter</c> sensor) as two differently-labelled series.
/// The Sensors tab: GPU core / hotspot temperature, load, CPU temperature and load on one plot (°C and % left) with the GPU's
/// power on a watt axis at the right, and memory on another — the game's own VRAM (the per-present <c>vram_proc</c> blob, a
/// held 1 Hz sample), the adapter-wide VRAM (the <c>vram_adapter</c> sensor) and the system's RAM as differently-labelled
/// series. Since beta.8 it draws a session that was not hooked too: its sensors are all it has.
/// </summary>
public partial class SensorsChart : UserControl
{
/// <summary>The temperatures-and-load plot's series, each with the palette key it is drawn in and whether it is on the watt axis.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey, bool Watts)> TempsPlot =
[
("gpu_temp", "Chart_Sensor", false),
("gpu_hotspot", "Chart_Stutter", false),
("gpu_load", "Chart_Native", false),
("gpu_power", "Chart_SensorSecondary", true),
("cpu_temp", "Chart_Percentile", false),
("cpu_load", "Chart_Displayed", false),
];
/// <summary>The memory plot's series and their palette keys; <c>vram_proc</c> is the per-present blob, the others sensors.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey)> MemoryPlot =
[
("vram_proc", "Chart_Displayed"),
("vram_adapter", "Chart_SensorSecondary"),
("ram_mb", "Chart_Percentile"),
];
public SensorsChart()
{
InitializeComponent();
@@ -20,29 +40,38 @@ public partial class SensorsChart : UserControl
public int DrawnSeries { get; private set; }
/// <summary>The temperatures plot, for a test's look at its axes.</summary>
public ScottPlot.Plot TempsPlotView => Temps.Plot;
public void Show(SessionSeries? series)
{
DrawnSeries = 0;
DrawTemps(series);
DrawVram(series);
DrawMemory(series);
}
/// <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>
internal static string TimeAxisLabel(SessionSeries? series) =>
series is { SensorsAligned: true, Presents: > 0 } ? Strings.Chart_Axis_TimeFromFirstFrame : Strings.Chart_Axis_TimeFromStart;
private void DrawTemps(SessionSeries? series)
{
ScottPlot.Plot plot = Temps.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_Time);
plot.XLabel(TimeAxisLabel(series));
plot.YLabel(Strings.Chart_Axis_Sensor);
if (series is not null)
{
ChartPalette p = ChartTheme.Current;
Line(plot, series, "gpu_temp", Strings.Sensors_Series_GpuTemp, p.Sensor, null);
Line(plot, series, "gpu_hotspot", Strings.Sensors_Series_GpuHotspot, p.Stutter, null);
Line(plot, series, "gpu_load", Strings.Sensors_Series_GpuLoad, p.Native, null);
Line(plot, series, "gpu_power", Strings.Sensors_Series_GpuPower, p.SensorSecondary, plot.Axes.Right);
Line(plot, series, "cpu_temp", Strings.Sensors_Series_CpuTemp, p.Percentile, null);
Line(plot, series, "cpu_load", Strings.Sensors_Series_CpuLoad, p.Displayed, null);
foreach ((string name, string key, bool watts) in TempsPlot)
{
if (Line(plot, series, name, Label(name), p.ByKey(key), watts ? plot.Axes.Right : null) && watts)
{
plot.Axes.Right.Label.Text = Strings.Sensors_Axis_Watts;
}
}
plot.Axes.AutoScale();
plot.ShowLegend(Alignment.UpperRight);
}
@@ -50,28 +79,19 @@ public partial class SensorsChart : UserControl
Temps.Refresh();
}
private void DrawVram(SessionSeries? series)
private void DrawMemory(SessionSeries? series)
{
ScottPlot.Plot plot = Vram.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_Time);
plot.XLabel(TimeAxisLabel(series));
plot.YLabel(Strings.Sensors_Axis_Mb);
if (series is not null)
{
ChartPalette p = ChartTheme.Current;
if (series.VramProcMb is { Length: > 0 } proc)
{
int n = Math.Min(proc.Length, series.TimesS.Length);
(double[] xs, double[] ys) = Decimator.MinMax(series.TimesS[..n], [.. proc.Take(n).Select(static v => (double)v)], 1000);
Scatter line = plot.Add.ScatterLine(xs, ys, p.Displayed);
line.LineWidth = 1;
line.LegendText = Strings.Sensors_Series_VramProcess;
DrawnSeries++;
}
Line(plot, series, "vram_adapter", Strings.Sensors_Series_VramAdapter, p.SensorSecondary, null);
Line(plot, series, "ram_mb", Strings.Sensors_Series_Ram, p.Percentile, null);
DrawProcessVram(plot, series, p.ByKey(MemoryPlot[0].PaletteKey));
Line(plot, series, "vram_adapter", Strings.Sensors_Series_VramAdapter, p.ByKey(MemoryPlot[1].PaletteKey), null);
Line(plot, series, "ram_mb", Strings.Sensors_Series_Ram, p.ByKey(MemoryPlot[2].PaletteKey), null);
plot.Axes.AutoScale();
plot.ShowLegend(Alignment.UpperRight);
}
@@ -79,12 +99,49 @@ public partial class SensorsChart : UserControl
Vram.Refresh();
}
private void Line(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color, IYAxis? axis)
/// <summary>
/// The game's own VRAM, per present on the frames' axis — a 0 is a present the sample did not reach (the record's zero,
/// SessionFinalizer.Series), never a reading, and is left out (beta.8).
/// </summary>
private void DrawProcessVram(ScottPlot.Plot plot, SessionSeries series, Color color)
{
if (series.VramProcMb is not { Length: > 0 } proc)
{
return;
}
int n = Math.Min(proc.Length, series.TimesS.Length);
int[] read = [.. Enumerable.Range(0, n).Where(i => proc[i] > 0)];
if (read.Length == 0)
{
return;
}
(double[] xs, double[] ys) = Decimator.MinMax([.. read.Select(i => series.TimesS[i])], [.. read.Select(i => (double)proc[i])], 1000);
Scatter line = plot.Add.ScatterLine(xs, ys, color);
line.LineWidth = 1;
line.LegendText = Strings.Sensors_Series_VramProcess;
DrawnSeries++;
}
private static string Label(string series) => series switch
{
"gpu_temp" => Strings.Sensors_Series_GpuTemp,
"gpu_hotspot" => Strings.Sensors_Series_GpuHotspot,
"gpu_load" => Strings.Sensors_Series_GpuLoad,
"gpu_power" => Strings.Sensors_Series_GpuPower,
"cpu_temp" => Strings.Sensors_Series_CpuTemp,
"cpu_load" => Strings.Sensors_Series_CpuLoad,
_ => series,
};
/// <summary>Draws one sensor series if the session has it; whether it did.</summary>
private bool Line(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color, IYAxis? axis)
{
SensorSeries? sensor = series.Sensors.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.Ordinal));
if (sensor is null || sensor.TimesS.Length == 0)
{
return;
return false;
}
(double[] xs, double[] ys) = Decimator.MinMax(sensor.TimesS, sensor.Values, 1000);
@@ -97,5 +154,6 @@ public partial class SensorsChart : UserControl
}
DrawnSeries++;
return true;
}
}
+46 -5
View File
@@ -1,15 +1,20 @@
namespace FrameLedger.App.Charts;
/// <summary>
/// A session's per-present series decoded for the charts and the export: every present in drained order with its
/// time from the session start, its interval, whether it was generated, whether a gap sat before it; the
/// application-frame view (non-generated, non-gap) with the stutter flags over it; the segments on the time
/// axis; the sensor series. Decoded once per window, decimated per draw.
/// A session's per-present series decoded for the charts and the export: every present of the charted stream in drained
/// order with its time from the stream's first present, its interval, whether it was generated, whether a gap sat before
/// it; the application-frame view with the stutter flags over it; the segments on the time axis; the sensor series.
/// Decoded once per window, decimated per draw.
/// </summary>
/// <remarks>
/// <b>One stream (beta.8).</b> A session that presented to more than one swapchain is charted on the one its statistics are
/// over (<c>SegmentBuilder.DominantStream</c>: identified first, then the most presents) — the stored intervals are per
/// swapchain, and interleaving two streams' intervals on one time axis drew neither.
/// </remarks>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1819:Properties should not return arrays", Justification = "a data carrier for the charts: ScottPlot draws double[] and a 500k-frame session is decimated per draw, not copied per read")]
public sealed record SessionSeries
{
/// <summary>Seconds from the first present, per present (a cumulative sum of the intervals).</summary>
/// <summary>Seconds from the stream's first present, per present (a cumulative sum of the intervals; a gap adds none).</summary>
public required double[] TimesS { get; init; }
/// <summary>The stored interval per present, ms; 0 on the first present and after a gap.</summary>
@@ -37,23 +42,59 @@ public sealed record SessionSeries
public ushort[]? RenderRes { get; init; }
// the application-frame view
/// <summary>The time of each application frame's present, seconds.</summary>
public required double[] AppTimesS { get; init; }
/// <summary>
/// Each application frame's time, ms: from the previous application frame's present to its own (beta.8) — the generated
/// presents between them add no interval, and a gap breaks the chain. Every present's interval where nothing was generated.
/// </summary>
public required double[] AppFrameTimesMs { get; init; }
/// <summary>Index into the per-present arrays for each application frame.</summary>
public required int[] AppPresentIndex { get; init; }
/// <summary>
/// Every present was generated — frame generation counted and no application frame's token arrived (the <c>no_evaluations</c>
/// refusal) — so the application-frame view is every present instead, and the chart says so.
/// </summary>
public bool NoApplicationFrames { get; init; }
/// <summary>Per application frame, from <c>Domain.Metrics.StutterDetector</c>; null when the session is too short for the window.</summary>
public bool[]? Stutter { get; init; }
public required IReadOnlyList<SegmentSpan> Segments { get; init; }
/// <summary>
/// The sensor series. On the frames' axis — seconds from the first present, negative before it — when
/// <see cref="SensorsAligned"/>; from the session's start otherwise.
/// </summary>
public required IReadOnlyList<SensorSeries> Sensors { get; init; }
/// <summary>
/// The sensors are placed on the frames' time axis: the blob said where the first present sits on the sensors' clock
/// (schema 0013). A session recorded before cannot draw them over its frames.
/// </summary>
public bool SensorsAligned { get; init; }
public int Presents => TimesS.Length;
public bool HasGenerated => Generated.Any(static g => g);
public double DurationS => TimesS.Length == 0 ? 0 : TimesS[^1];
/// <summary>A series with no frames: a session that was not hooked still has its sensors (beta.8).</summary>
public static SessionSeries SensorsOnly(IReadOnlyList<SensorSeries> sensors) => new()
{
TimesS = [],
FrameTimesMs = [],
Generated = [],
Gap = [],
AppTimesS = [],
AppFrameTimesMs = [],
AppPresentIndex = [],
Segments = [],
Sensors = sensors,
};
}
+139 -30
View File
@@ -6,10 +6,11 @@ using FrameLedger.Infrastructure.Blobs;
namespace FrameLedger.App.Charts;
/// <summary>
/// Decodes one session's blobs into a <see cref="SessionSeries"/>: the frametime series with the gap and
/// generated bits, the application-frame view with <c>StutterDetector</c> over it (the same rule the stored
/// <c>stutter_count</c> came from), the segments mapped from frame index to seconds, and the sensors aligned to
/// their <c>t_ms</c>. Null when the session has no frame blob (Tier 2, or swept by retention).
/// Decodes one session's blobs into a <see cref="SessionSeries"/>: the charted stream's frametime series with the gap
/// and generated bits, the application-frame view with <c>StutterDetector</c> over it (the rule the stored
/// <c>stutter_count</c> came from), the segments mapped from frame index to seconds, and the sensors. Null when the
/// session has no frame blob (Tier 2, or swept by retention); <see cref="LoadSensorsAsync"/> reads a Tier-2 session's
/// sensors on their own.
/// </summary>
public sealed class SessionSeriesLoader
{
@@ -30,61 +31,165 @@ public sealed class SessionSeriesLoader
return Decode(frames, segments, sensors);
}
/// <summary>
/// The sensor series alone, timed from the session's start — what a session that was not hooked has to chart (beta.8: the
/// Tier-2 row has kept its sensors since 2026-09-22, and no chart read them). Empty when none were recorded.
/// </summary>
public async Task<IReadOnlyList<SensorSeries>> LoadSensorsAsync(long sessionId, CancellationToken ct = default) =>
DecodeSensors(await _sessions.FindSensorsAsync(sessionId, ct).ConfigureAwait(false), offsetS: 0);
public static SessionSeries Decode(FrameBlobs frames, IReadOnlyList<SegmentRow> segments, IReadOnlyList<SensorBlob> sensors)
{
ArgumentNullException.ThrowIfNull(frames);
ArgumentNullException.ThrowIfNull(segments);
ArgumentNullException.ThrowIfNull(sensors);
float[] frametimes = SeriesCodec.DecodeFloat32(frames.FrameTimes.ToArray());
byte[] flags = SeriesCodec.DecodeBytes(frames.FrameFlags.ToArray());
int n = Math.Min(frametimes.Length, flags.Length);
float[] allFrametimes = SeriesCodec.DecodeFloat32(frames.FrameTimes.ToArray());
byte[] allFlags = SeriesCodec.DecodeBytes(frames.FrameFlags.ToArray());
int total = Math.Min(allFrametimes.Length, allFlags.Length);
uint[]? swapchains = frames.SwapchainIds is { } ids ? SeriesCodec.DecodeUInt32(ids.ToArray()) : null;
(int[] keep, uint? swapchain) = ChartedStream(total, swapchains);
float[] frametimes = Pick(allFrametimes, keep);
byte[] flags = Pick(allFlags, keep);
int n = keep.Length;
var times = new double[n];
var generated = new bool[n];
var gap = new bool[n];
double t = 0;
var appTimes = new List<double>(n);
var appFrametimes = new List<double>(n);
var appIndex = new List<int>(n);
for (int i = 0; i < n; i++)
{
t += frametimes[i] / 1000.0;
times[i] = t;
generated[i] = (flags[i] & (byte)FrameFlagBits.Generated) != 0;
gap[i] = (flags[i] & (byte)FrameFlagBits.Gap) != 0;
if (i > 0 && !generated[i] && !gap[i] && frametimes[i] > 0)
{
appTimes.Add(t);
appFrametimes.Add(frametimes[i]);
appIndex.Add(i);
}
}
(List<int> appIndex, List<double> appFrametimes, bool noApplicationFrames) = ApplicationFrames(frametimes, generated, gap);
StutterResult? stutter = StutterDetector.Detect(appFrametimes);
uint[]? frameIndex = frames.FrameIndex is { } fi ? SeriesCodec.DecodeUInt32(fi.ToArray()) : null;
uint[]? frameIndex = frames.FrameIndex is { } fi ? PickOptional(SeriesCodec.DecodeUInt32(fi.ToArray()), keep) : null;
double? offsetS = frames.FirstPresentMs / 1000.0;
return new SessionSeries
{
TimesS = times,
FrameTimesMs = frametimes.Length == n ? frametimes : frametimes[..n],
FrameTimesMs = frametimes,
Generated = generated,
Gap = gap,
FrameIndex = frameIndex,
RtFlags = frames.RtFlags is { } rt ? SeriesCodec.DecodeBytes(rt.ToArray()) : null,
DispatchRays = frames.DispatchRays is { } dr ? SeriesCodec.DecodeUInt32(dr.ToArray()) : null,
PsoCreated = frames.PsoCreated is { } pso ? SeriesCodec.DecodeUInt16(pso.ToArray()) : null,
VramProcMb = frames.VramProc is { } vram ? SeriesCodec.DecodeUInt32(vram.ToArray()) : null,
LatencyUs = frames.LatencyUs is { } lat ? SeriesCodec.DecodeUInt32(lat.ToArray()) : null,
RenderRes = frames.RenderRes is { } rr ? SeriesCodec.DecodeUInt16(rr.ToArray()) : null,
AppTimesS = [.. appTimes],
RtFlags = frames.RtFlags is { } rt ? PickOptional(SeriesCodec.DecodeBytes(rt.ToArray()), keep) : null,
DispatchRays = frames.DispatchRays is { } dr ? PickOptional(SeriesCodec.DecodeUInt32(dr.ToArray()), keep) : null,
PsoCreated = frames.PsoCreated is { } pso ? PickOptional(SeriesCodec.DecodeUInt16(pso.ToArray()), keep) : null,
VramProcMb = frames.VramProc is { } vram ? PickOptional(SeriesCodec.DecodeUInt32(vram.ToArray()), keep) : null,
LatencyUs = frames.LatencyUs is { } lat ? PickOptional(SeriesCodec.DecodeUInt32(lat.ToArray()), keep) : null,
RenderRes = frames.RenderRes is { } rr ? PickQuads(SeriesCodec.DecodeUInt16(rr.ToArray()), keep) : null,
AppTimesS = [.. appIndex.Select(i => times[i])],
AppFrameTimesMs = [.. appFrametimes],
AppPresentIndex = [.. appIndex],
NoApplicationFrames = noApplicationFrames,
Stutter = stutter is null ? null : [.. stutter.IsStutter],
Segments = MapSegments(segments, times, frameIndex),
Sensors = DecodeSensors(sensors),
Segments = MapSegments([.. segments.Where(s => swapchain is null || s.SwapchainId == swapchain.Value)], times, frameIndex),
Sensors = DecodeSensors(sensors, offsetS ?? 0),
SensorsAligned = offsetS is not null,
};
}
/// <summary>
/// The presents of the stream the charts draw — the one the session's statistics are over (<c>SegmentBuilder.DominantStream</c>:
/// identified first, then the most presents) — as indices into the blob, and that stream's id; every present, and no id,
/// when the blob held one stream.
/// </summary>
internal static (int[] Keep, uint? Swapchain) ChartedStream(int count, uint[]? swapchains)
{
if (swapchains is null || swapchains.Length < count)
{
return ([.. Enumerable.Range(0, count)], null);
}
IReadOnlyList<int> keep = SegmentBuilder.DominantStream([.. Enumerable.Range(0, count)], i => swapchains[i]);
return ([.. keep], keep.Count > 0 ? swapchains[keep[0]] : null);
}
/// <summary>
/// The application-frame view: each application frame's time is from the previous application frame's present to its own —
/// the generated presents between them add their intervals to it, never an interval of their own — and a gap breaks the
/// chain. Where every present was generated, every present's interval, and the flag that says so.
/// </summary>
internal static (List<int> Index, List<double> FrametimesMs, bool NoApplicationFrames) ApplicationFrames(float[] frametimes, bool[] generated, bool[] gap)
{
ArgumentNullException.ThrowIfNull(frametimes);
ArgumentNullException.ThrowIfNull(generated);
ArgumentNullException.ThrowIfNull(gap);
bool noApplicationFrames = generated.Length > 0 && generated.All(static g => g);
var index = new List<int>(frametimes.Length);
var ms = new List<double>(frametimes.Length);
bool chain = false;
double sinceApplicationFrame = 0;
for (int i = 0; i < frametimes.Length; i++)
{
if (gap[i])
{
chain = false;
sinceApplicationFrame = 0;
}
else
{
sinceApplicationFrame += frametimes[i];
}
if (generated[i] && !noApplicationFrames)
{
continue;
}
if (chain && sinceApplicationFrame > 0)
{
index.Add(i);
ms.Add(sinceApplicationFrame);
}
chain = true;
sinceApplicationFrame = 0;
}
return (index, ms, noApplicationFrames);
}
private static T[] Pick<T>(T[] values, int[] keep)
{
if (keep.Length == values.Length)
{
return values;
}
var picked = new T[keep.Length];
for (int i = 0; i < keep.Length; i++)
{
picked[i] = values[keep[i]];
}
return picked;
}
/// <summary>A per-present series the blob may have written shorter than the frames: only the kept presents it covers.</summary>
private static T[] PickOptional<T>(T[] values, int[] keep) => keep.Length == values.Length ? values : [.. keep.Where(i => i < values.Length).Select(i => values[i])];
private static ushort[] PickQuads(ushort[] values, int[] keep)
{
if (keep.Length * 4 == values.Length)
{
return values;
}
var picked = new List<ushort>(keep.Length * 4);
foreach (int i in keep.Where(i => (i * 4) + 3 < values.Length))
{
picked.AddRange(values.AsSpan(i * 4, 4).ToArray());
}
return [.. picked];
}
/// <summary>A segment's <c>start_frame</c>/<c>end_frame</c> are frame indices; the present at that index (or the nearest) gives the seconds.</summary>
private static IReadOnlyList<SegmentSpan> MapSegments(IReadOnlyList<SegmentRow> segments, double[] times, uint[]? frameIndex)
private static List<SegmentSpan> MapSegments(IReadOnlyList<SegmentRow> segments, double[] times, uint[]? frameIndex)
{
if (times.Length == 0)
{
@@ -125,7 +230,11 @@ public sealed class SessionSeriesLoader
return string.Join(" · ", new[] { upscaler, resolution, fg }.Where(static x => x.Length > 0));
}
private static List<SensorSeries> DecodeSensors(IReadOnlyList<SensorBlob> sensors)
/// <summary>
/// Every sensor series against <c>t_ms</c> less <paramref name="offsetS"/> — the first present's place on the sensors'
/// clock, so they share the frames' axis (schema 0013) — and −1 dropped: a tick with no reading, never a zero.
/// </summary>
private static List<SensorSeries> DecodeSensors(IReadOnlyList<SensorBlob> sensors, double offsetS)
{
SensorBlob? clock = sensors.FirstOrDefault(static s => string.Equals(s.Series, "t_ms", StringComparison.Ordinal));
float[]? tMs = clock is null ? null : SeriesCodec.DecodeFloat32(clock.Data.ToArray());
@@ -147,7 +256,7 @@ public sealed class SessionSeriesLoader
continue; // SessionFinalizer.SensorMissing: a tick with no reading, never a zero
}
xs.Add(tMs is not null && i < tMs.Length ? tMs[i] / 1000.0 : i / Math.Max(blob.Hz, 0.001));
xs.Add((tMs is not null && i < tMs.Length ? tMs[i] / 1000.0 : i / Math.Max(blob.Hz, 0.001)) - offsetS);
ys.Add(values[i]);
}
+21 -2
View File
@@ -17,17 +17,23 @@ public partial class TrendChart : UserControl
public int DrawnPoints { get; private set; }
/// <summary>How many of <see cref="DrawnPoints"/> were drawn hollow (a part of their session).</summary>
public int HollowPoints { get; private set; }
public void Show(IReadOnlyList<TrendPoint> points, IReadOnlyList<HardwareChange> changes, string metricLabel)
{
ArgumentNullException.ThrowIfNull(points);
ArgumentNullException.ThrowIfNull(changes);
ScottPlot.Plot plot = Plot.Plot;
plot.Clear();
// The date axis REPLACES the bottom axis, so it goes first (beta.8): made after the theme and the label, it dropped
// both — an unlabelled axis in the default colours, unreadable in the dark theme.
plot.Axes.DateTimeTicksBottom();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Trend_Axis_Date);
plot.YLabel(metricLabel);
plot.Axes.DateTimeTicksBottom();
DrawnPoints = points.Count;
HollowPoints = points.Count(static t => t.SettingsChangedMidSession);
if (points.Count > 0)
{
ChartPalette p = ChartTheme.Current;
@@ -37,7 +43,20 @@ public partial class TrendChart : UserControl
line.LineWidth = 2;
line.MarkerSize = 7;
line.LegendText = metricLabel;
foreach (HardwareChange change in changes)
// A point that describes part of its session (settings changed, or a steady state) is drawn hollow over its
// filled one: the line still passes through it, and it cannot be read as the session's own number.
TrendPoint[] partial = [.. points.Where(static t => t.SettingsChangedMidSession)];
if (partial.Length > 0)
{
double[] hx = [.. partial.Select(static t => t.At.LocalDateTime.ToOADate())];
double[] hy = [.. partial.Select(static t => t.Value)];
Scatter hollow = plot.Add.ScatterPoints(hx, hy, p.Data);
hollow.MarkerSize = 6;
hollow.MarkerShape = MarkerShape.FilledCircle;
}
foreach (HardwareChange change in TrendSeriesBuilder.MergedByDay(changes))
{
VerticalLine marker = plot.Add.VerticalLine(change.At.LocalDateTime.ToOADate(), 1, p.StutterPso, LinePattern.Dashed);
marker.LabelText = change.Text;
+9 -2
View File
@@ -3,8 +3,15 @@ namespace FrameLedger.App.Charts;
/// <summary>The Trend tab's selector (<c>08_UI</c> §Games › Trend).</summary>
public enum TrendMetric
{
/// <summary>Native FPS where frame generation was measured; Presented FPS where it was not (the row's headline, per <c>03_METRICS</c> Avg FPS).</summary>
Average,
/// <summary>
/// Presented FPS — every frame presented — on the sessions where no generated frame was counted (beta.8: "Average" mixed
/// it with Native in one line). A session that counted generated frames has none here: its presented rate includes them,
/// the single inflated number CLAUDE.md rule 6 forbids; it is on <see cref="NativeFps"/> and <see cref="Displayed"/>.
/// </summary>
PresentedFps,
/// <summary>Native FPS — the game's own frames — only where frame generation was measured (counted, or measured none).</summary>
NativeFps,
/// <summary>Displayed FPS — only sessions that measured frame generation have one.</summary>
Displayed,
@@ -7,10 +7,15 @@ using FrameLedger.Domain.Sessions;
namespace FrameLedger.App.Charts;
/// <summary>
/// The Trend tab's data (FR-6.3, FR-6.4): one point per hooked session that has the metric, oldest first, with
/// the sessions that changed settings mid-session excluded unless asked for; and a marker wherever two
/// consecutive sessions' hardware snapshots differ in what a reader would want to know about.
/// The Trend tab's data (FR-6.3, FR-6.4): one point per session that has the metric, oldest first, with the points that
/// describe only part of their session excluded unless asked for; and a marker wherever two consecutive sessions'
/// hardware snapshots differ in what a reader would want to know about.
/// </summary>
/// <remarks>
/// <b>Which sessions (beta.8).</b> A frame-rate metric is the hooks' and comes from hooked sessions only; a machine metric
/// — temperatures, loads, power, memory — is the telemetry every session records, Tier 2 included, which the trend left
/// out until 2026-09-25 (a game never hooked had no trend at all).
/// </remarks>
[SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format string is a resource that follows the UI culture, which changes at runtime")]
public static class TrendSeriesBuilder
{
@@ -18,7 +23,7 @@ public static class TrendSeriesBuilder
{
ArgumentNullException.ThrowIfNull(rows);
var points = new List<TrendPoint>();
foreach (SessionRow row in rows.Where(static r => r.Tier == CaptureTier.Hooked).OrderBy(static r => r.StartedAt))
foreach (SessionRow row in rows.Where(r => Counts(r, metric)).OrderBy(static r => r.StartedAt))
{
bool partial = IsPartial(row, metric);
if (partial && !includeMidSessionChanges)
@@ -37,12 +42,23 @@ public static class TrendSeriesBuilder
}
/// <summary>How many sessions FR-6.4 leaves out at the default setting.</summary>
public static int ExcludedCount(IReadOnlyList<SessionRow> rows) => ExcludedCount(rows, TrendMetric.Average);
public static int ExcludedCount(IReadOnlyList<SessionRow> rows) => ExcludedCount(rows, TrendMetric.PresentedFps);
/// <summary>Whether a session can have a point for <paramref name="metric"/>: a frame rate needs the hooks; the machine is every session's.</summary>
public static bool Counts(SessionRow row, TrendMetric metric)
{
ArgumentNullException.ThrowIfNull(row);
return row.Tier == CaptureTier.Hooked || IsMachineMetric(metric);
}
/// <summary>The metrics that are telemetry, recorded by every session whatever its tier.</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;
public static int ExcludedCount(IReadOnlyList<SessionRow> rows, TrendMetric metric)
{
ArgumentNullException.ThrowIfNull(rows);
return rows.Count(r => r.Tier == CaptureTier.Hooked && IsPartial(r, metric));
return rows.Count(r => Counts(r, metric) && IsPartial(r, metric) && ValueOf(r, metric) is not null);
}
/// <summary>
@@ -52,8 +68,11 @@ public static class TrendSeriesBuilder
public static bool IsPartial(SessionRow row, TrendMetric metric)
{
ArgumentNullException.ThrowIfNull(row);
// A steady state (CLAUDE.md rule 6, 2026-09-17) is the factor's AND the Native / Displayed rates beside it: all three
// describe the state the session spent most of its generating time in, never the whole session (beta.8).
return row.SettingsChangedMidSession
|| (metric == TrendMetric.FgFactor && string.Equals(row.FgFactorScope, "steady", StringComparison.Ordinal));
|| (metric is TrendMetric.FgFactor or TrendMetric.NativeFps or TrendMetric.Displayed
&& string.Equals(row.FgFactorScope, "steady", StringComparison.Ordinal));
}
/// <summary>The metric's value on a row, or null when that row cannot have it (FR-4.9: never an estimate).</summary>
@@ -63,9 +82,11 @@ public static class TrendSeriesBuilder
FpsReadoutModel readout = FpsPresentation.FromRow(row);
return metric switch
{
TrendMetric.Average => readout.Kind switch
TrendMetric.NativeFps => readout.Kind is FpsReadoutKind.Generated or FpsReadoutKind.None ? readout.Native : null,
TrendMetric.PresentedFps => readout.Kind switch
{
FpsReadoutKind.Generated or FpsReadoutKind.None => readout.Native,
// A measured none: the presents are the application's frames, so the rate is both.
FpsReadoutKind.None => readout.Native,
FpsReadoutKind.Presented or FpsReadoutKind.IdentifiedUncounted => readout.Presented,
_ => null,
},
@@ -84,6 +105,17 @@ public static class TrendSeriesBuilder
};
}
/// <summary>
/// One marker per day that changed (beta.8): every difference found on that day in one label, line after line — two
/// labels at one position were drawn over each other.
/// </summary>
public static IReadOnlyList<HardwareChange> MergedByDay(IReadOnlyList<HardwareChange> changes)
{
ArgumentNullException.ThrowIfNull(changes);
return [.. changes.GroupBy(static c => c.At.LocalDateTime.Date)
.Select(static g => new HardwareChange(g.First().At, string.Join(Environment.NewLine, g.Select(static c => c.Text).Distinct(StringComparer.Ordinal))))];
}
/// <summary>Markers between consecutive sessions (oldest first) whose snapshots differ; <paramref name="snapshotOf"/> resolves a row's snapshot id.</summary>
public static IReadOnlyList<HardwareChange> Changes(IReadOnlyList<SessionRow> rows, Func<long, HardwareSnapshot?> snapshotOf)
{
@@ -0,0 +1,37 @@
<UserControl x:Class="FrameLedger.App.Dialogs.AntiCheatExceptionDialogContent"
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:vm="clr-namespace:FrameLedger.App.ViewModels"
d:DataContext="{d:DesignInstance Type=vm:AntiCheatExceptionDialogViewModel}"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
MaxWidth="640">
<!--
D33's disclosure (19_SAFETY §The user-mode exception), text from FrameLedger.Shared's Safety_Exception_* only,
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">
<StackPanel>
<ui:TextBlock Text="{Binding Intro}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,14,0,0" Text="{Binding Why}" TextWrapping="Wrap" />
<Border Margin="0,14,0,0" Padding="12" CornerRadius="6" Background="{DynamicResource CardBackgroundFillColorDefaultBrush}">
<ui:TextBlock FontWeight="SemiBold" Text="{Binding Risk}" TextWrapping="Wrap" />
</Border>
<ui:TextBlock Margin="0,14,0,0" Text="{Binding Still}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,8,0,0" Text="{x:Static vm:AntiCheatExceptionDialogViewModel.Ends}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,8,0,0" Text="{x:Static vm:AntiCheatExceptionDialogViewModel.Next}" TextWrapping="Wrap" />
<ui:TextBlock Margin="0,8,0,0" FontWeight="SemiBold" Text="{x:Static vm:AntiCheatExceptionDialogViewModel.Online}" TextWrapping="Wrap" />
<CheckBox x:Name="Acceptance"
Margin="0,18,0,0"
AutomationProperties.Name="{x:Static vm:AntiCheatExceptionDialogViewModel.AcceptText}"
Content="{x:Static vm:AntiCheatExceptionDialogViewModel.AcceptText}"
IsChecked="{Binding Accepted, Mode=TwoWay}" />
</StackPanel>
</ScrollViewer>
</UserControl>
@@ -0,0 +1,18 @@
using System.Windows.Controls;
using FrameLedger.App.ViewModels;
namespace FrameLedger.App.Dialogs;
/// <summary>The body of D33's <c>ContentDialog</c>; the buttons are the dialog's own (<see cref="Services.AntiCheatExceptionPrompt"/>).</summary>
public partial class AntiCheatExceptionDialogContent : UserControl
{
public AntiCheatExceptionDialogContent(AntiCheatExceptionDialogViewModel viewModel)
{
ViewModel = viewModel ?? throw new ArgumentNullException(nameof(viewModel));
DataContext = viewModel;
InitializeComponent();
Loaded += (_, _) => Acceptance.Focus();
}
public AntiCheatExceptionDialogViewModel ViewModel { get; }
}
+4 -1
View File
@@ -88,9 +88,12 @@
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate DataType="{x:Type vm:CompareCell}">
<TextBlock Margin="4,0" Text="{Binding Text}" Foreground="{DynamicResource TextFillColorPrimaryBrush}">
<!-- The default foreground is the Style's, not a local value (beta.8): a local value outranks every
trigger, and the best cell was bold but never in the accent colour. -->
<TextBlock Margin="4,0" Text="{Binding Text}">
<TextBlock.Style>
<Style TargetType="TextBlock">
<Setter Property="Foreground" Value="{DynamicResource TextFillColorPrimaryBrush}" />
<Style.Triggers>
<DataTrigger Binding="{Binding IsBest}" Value="True">
<Setter Property="FontWeight" Value="Bold" />
+56 -6
View File
@@ -32,7 +32,7 @@
<ui:TextBlock Appearance="Tertiary" TextTrimming="CharacterEllipsis" Text="{Binding ViewModel.ExecutableText}" ToolTip="{Binding ViewModel.ExecutableText}" />
<ui:InfoBar Margin="0,6,0,0" IsClosable="False" Severity="Warning"
IsOpen="{Binding ViewModel.ExecutableMissing, Mode=OneWay}"
Message="{x:Static vm:GameDetailViewModel.ExecutableMissingText}" />
Message="{Binding ViewModel.ExecutableMissingMessage}" />
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.LastSessionText}" />
<StackPanel Orientation="Horizontal" Margin="0,10,0,0">
<ui:TextBlock Appearance="Secondary" VerticalAlignment="Center" Margin="0,0,12,0" Text="{x:Static vm:GameDetailViewModel.LifetimeLabel}" />
@@ -109,6 +109,25 @@
</ui:Card>
</Grid>
<!-- details (beta.8, schema 0011): what the game's files and its store say — what it runs as, its versions, what it ships -->
<ui:CardExpander Margin="0,12,0,0" IsExpanded="True" Icon="{ui:SymbolIcon Info24}"
Header="{x:Static vm:GameDetailViewModel.DetailsHeader}">
<ItemsControl ItemsSource="{Binding ViewModel.Details}">
<ItemsControl.ItemTemplate>
<DataTemplate DataType="{x:Type vm:GameDetailRow}">
<Grid Margin="0,0,0,6">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="180" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<ui:TextBlock Grid.Column="0" Appearance="Secondary" TextWrapping="Wrap" Text="{Binding Label}" />
<ui:TextBlock Grid.Column="1" TextWrapping="Wrap" Text="{Binding Value}" />
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</ui:CardExpander>
<!-- recording switch (schema 0009, 2026-09-23): off, FrameLedger does not watch for this program at all -->
<ui:CardControl Margin="0,12,0,0" Header="{x:Static vm:GameDetailViewModel.RecordingHeader}" Icon="{ui:SymbolIcon Record24}">
<StackPanel Orientation="Horizontal">
@@ -131,6 +150,33 @@
</ui:CardControl.Header>
</ui:CardControl>
<!-- D33 (owner decision 2026-09-26): the user-mode exception on a blocked game, its state the Agent's (19_SAFETY §The user-mode exception) -->
<ui:CardControl Margin="0,12,0,0" Icon="{ui:SymbolIcon ShieldTask24}"
Visibility="{Binding ViewModel.ExceptionCardVisible, Converter={StaticResource BoolToVis}}">
<ui:CardControl.Header>
<StackPanel>
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static vm:GameDetailViewModel.ExceptionHeader}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.ExceptionText}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.ExceptionInForceText}"
Visibility="{Binding ViewModel.ExceptionInForceText, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.ExceptionSuspendedText}"
Visibility="{Binding ViewModel.ExceptionSuspendedText, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.ExceptionLapseText}"
Visibility="{Binding ViewModel.ExceptionLapseText, Converter={StaticResource NullToCollapsed}}" />
</StackPanel>
</ui:CardControl.Header>
<StackPanel Orientation="Horizontal">
<ui:Button Appearance="Secondary"
Command="{Binding ViewModel.GrantExceptionCommand}"
Content="{x:Static vm:GameDetailViewModel.GrantExceptionText}"
Visibility="{Binding ViewModel.CanGrantException, Converter={StaticResource BoolToVis}}" />
<ui:Button Appearance="Secondary"
Command="{Binding ViewModel.WithdrawExceptionCommand}"
Content="{x:Static vm:GameDetailViewModel.WithdrawExceptionText}"
Visibility="{Binding ViewModel.CanWithdrawException, Converter={StaticResource BoolToVis}}" />
</StackPanel>
</ui:CardControl>
<!-- hooking control (FR-2.1 / FR-2.2 / FR-2.5) -->
<StackPanel Visibility="{Binding ViewModel.HookingSectionVisible, Converter={StaticResource BoolToVis}}">
<ui:CardControl Margin="0,12,0,0" Header="{x:Static vm:GameDetailViewModel.HookingHeader}" Icon="{ui:SymbolIcon ShieldTask24}">
@@ -145,6 +191,8 @@
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:GameDetailViewModel.HookingBody}" />
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.BlockedText}"
Visibility="{Binding ViewModel.BlockedText, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.NotX64Text}"
Visibility="{Binding ViewModel.NotX64Text, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.UnverifiedText}"
Visibility="{Binding ViewModel.UnverifiedText, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" Text="{x:Static vm:GameDetailViewModel.BusyText}"
@@ -262,7 +310,7 @@
<StackPanel Margin="0,12,0,0">
<StackPanel Orientation="Horizontal">
<ui:TextBlock Appearance="Secondary" VerticalAlignment="Center" Margin="0,0,8,0" Text="{x:Static vm:GameDetailViewModel.TrendMetricLabel}" />
<ComboBox MinWidth="180" AutomationProperties.Name="{x:Static vm:GameDetailViewModel.TrendMetricLabel}" DisplayMemberPath="Label" ItemsSource="{x:Static vm:GameDetailViewModel.TrendMetrics}"
<ComboBox MinWidth="180" AutomationProperties.Name="{x:Static vm:GameDetailViewModel.TrendMetricLabel}" DisplayMemberPath="Label" ItemsSource="{Binding ViewModel.TrendMetrics}"
SelectedValue="{Binding ViewModel.TrendMetric, Mode=TwoWay}" SelectedValuePath="Value" />
<CheckBox Margin="16,0,0,0" VerticalAlignment="Center" Content="{x:Static vm:GameDetailViewModel.IncludeMidSessionText}"
IsChecked="{Binding ViewModel.IncludeMidSession}" />
@@ -270,16 +318,18 @@
<ui:TextBlock Margin="0,6,0,0" Appearance="Tertiary" Text="{Binding ViewModel.TrendExcludedText}"
Visibility="{Binding ViewModel.TrendExcludedText, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Margin="0,6,0,0" Appearance="Tertiary" TextWrapping="Wrap" Text="{x:Static vm:GameDetailViewModel.TrendAverageNote}" />
<ui:TextBlock Margin="0,12,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:GameDetailViewModel.TrendEmptyText}"
<ui:TextBlock Margin="0,6,0,0" Appearance="Tertiary" TextWrapping="Wrap" Text="{x:Static vm:GameDetailViewModel.TrendPartialNote}" />
<ui:TextBlock Margin="0,12,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.TrendEmptyMessage}"
Visibility="{Binding ViewModel.TrendEmpty, Converter={StaticResource BoolToVis}}" />
<charts:TrendChart x:Name="Trend" Height="320" Visibility="{Binding ViewModel.TrendEmpty, Converter={StaticResource InverseBoolToVis}}" />
</StackPanel>
</TabItem>
<TabItem Header="{x:Static vm:GameDetailViewModel.TabSensors}">
<StackPanel Margin="0,12,0,0">
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SelectedNote}"
Visibility="{Binding ViewModel.SelectedNote, Converter={StaticResource NullToCollapsed}}" />
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSeries, Converter={StaticResource BoolToVis}}" />
<!-- A session that was not hooked has its sensors (beta.8): the tab's own note and visibility, not the frames'. -->
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SensorsNote}"
Visibility="{Binding ViewModel.SensorsNote, Converter={StaticResource NullToCollapsed}}" />
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSensors, Converter={StaticResource BoolToVis}}" />
</StackPanel>
</TabItem>
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}">
@@ -14,10 +14,16 @@ public partial class GameDetailPage : INavigableView<GameDetailViewModel>
InitializeComponent();
ViewModel.SelectionPresented += OnSelectionPresented;
ViewModel.TrendPresented += OnTrendPresented;
// The view model starts loading before this page exists, and a load that finished first raised its events to
// nobody: the Trend tab was blank on every first open (beta.8). Draw what it holds now; a later load redraws.
OnTrendPresented(this, EventArgs.Empty);
OnSelectionPresented(this, EventArgs.Empty);
Loaded += (_, _) => ViewModel.Attach();
Unloaded += (_, _) =>
{
ViewModel.SelectionPresented -= OnSelectionPresented;
ViewModel.TrendPresented -= OnTrendPresented;
ViewModel.Detach();
};
}
@@ -27,7 +33,7 @@ public partial class GameDetailPage : INavigableView<GameDetailViewModel>
{
Frametime.Show(ViewModel.SelectedSeries, displayed: false, sensors: false);
Distribution.Show(ViewModel.SelectedSeries);
Sensors.Show(ViewModel.SelectedSeries);
Sensors.Show(ViewModel.SelectedSensors);
Latency.Show(ViewModel.SelectedSeries, ViewModel.SelectedSession?.Row.LatencyAvgUs, ViewModel.SelectedSession?.Row.LatencyP95Us);
}
@@ -66,6 +66,68 @@
IsChecked="{Binding ViewModel.HideAntiCheatHooking, Mode=TwoWay}" />
</ui:CardControl>
<!-- D33 (owner decision 2026-09-26): the user-mode anti-cheat exception — the option, off by default, and the games it concerns. -->
<ui:CardExpander Margin="0,8,0,0" IsExpanded="{Binding ViewModel.UserModeExceptions, Mode=OneWay}" Icon="{ui:SymbolIcon ShieldTask24}">
<ui:CardExpander.Header>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static res:Strings.Settings_Exceptions_Label}" TextWrapping="Wrap" />
<ui:TextBlock MaxWidth="520" HorizontalAlignment="Left" Appearance="Secondary" TextWrapping="Wrap"
Text="{x:Static res:Strings.Settings_Exceptions_Body}" />
</StackPanel>
<ui:ToggleSwitch Grid.Column="1" Margin="12,0" AutomationProperties.Name="{x:Static res:Strings.Settings_Exceptions_Label}"
IsChecked="{Binding ViewModel.UserModeExceptions, Mode=TwoWay}" />
</Grid>
</ui:CardExpander.Header>
<StackPanel>
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static res:Strings.Settings_Exceptions_Header}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static res:Strings.Settings_Exceptions_Suspended}"
Visibility="{Binding ViewModel.ExceptionsSuspended, Converter={StaticResource BoolToVis}}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static res:Strings.Settings_Exceptions_Checking}"
Visibility="{Binding ViewModel.ExceptionsChecking, Converter={StaticResource BoolToVis}}" />
<ui:TextBlock Appearance="Secondary" Text="{x:Static res:Strings.Settings_Exceptions_Empty}"
Visibility="{Binding ViewModel.ExceptionGames.Count, Converter={StaticResource ZeroToVisible}}" />
<ItemsControl ItemsSource="{Binding ViewModel.ExceptionGames}">
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid Margin="0,6">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="Auto" />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0">
<ui:TextBlock FontTypography="BodyStrong" Text="{Binding Name}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding FindingText}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding SessionsText}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding StateText}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding LapseText}"
Visibility="{Binding LapseText, Converter={StaticResource NullToCollapsed}}" />
</StackPanel>
<StackPanel Grid.Column="1" Margin="12,0,0,0" VerticalAlignment="Center" Orientation="Horizontal">
<ui:Button Appearance="Secondary"
Command="{Binding GrantCommand}"
Content="{x:Static res:Strings.Settings_Exceptions_Grant}"
Visibility="{Binding CanGrant, Converter={StaticResource BoolToVis}}" />
<ui:Button Appearance="Secondary"
Command="{Binding WithdrawCommand}"
Content="{x:Static res:Strings.Settings_Exceptions_Withdraw}"
Visibility="{Binding CanWithdraw, Converter={StaticResource BoolToVis}}" />
</StackPanel>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
<ui:Button Margin="0,8,0,0"
Appearance="Secondary"
Command="{Binding ViewModel.RefreshExceptionsCommand}"
Content="{x:Static res:Strings.Settings_Exceptions_Refresh}" />
</StackPanel>
</ui:CardExpander>
<ui:CardExpander Margin="0,8,0,0" Icon="{ui:SymbolIcon Layer24}">
<ui:CardExpander.Header>
<Grid>
@@ -226,6 +288,17 @@
</ui:CardControl.Header>
<ui:ToggleSwitch AutomationProperties.Name="{x:Static res:Strings.Settings_MinimizeToTray_Label}" IsChecked="{Binding ViewModel.MinimizeToTray, Mode=TwoWay}" />
</ui:CardControl>
<!-- beta.8 (owner request 2026-09-25): two decimals on every FPS figure. -->
<ui:CardControl Margin="0,8,0,0" Icon="{ui:SymbolIcon NumberSymbol24}">
<ui:CardControl.Header>
<StackPanel>
<ui:TextBlock FontTypography="BodyStrong" Text="{x:Static res:Strings.Settings_FpsDecimals_Label}" />
<ui:TextBlock MaxWidth="520" HorizontalAlignment="Left" Appearance="Secondary" TextWrapping="Wrap"
Text="{x:Static res:Strings.Settings_FpsDecimals_Body}" />
</StackPanel>
</ui:CardControl.Header>
<ui:ToggleSwitch AutomationProperties.Name="{x:Static res:Strings.Settings_FpsDecimals_Label}" IsChecked="{Binding ViewModel.FpsTwoDecimals, Mode=TwoWay}" />
</ui:CardControl>
<!--
Updates, logging, legal. The Privacy card — the `privacy.online_metadata` toggle — is not shown
@@ -0,0 +1,4 @@
namespace FrameLedger.App.Services;
/// <summary>D33: what the exception's disclosure names — the game, the anti-cheat family and its signal, and the evidence.</summary>
public sealed record AntiCheatExceptionFacts(string GameName, string Family, string Signal, int Sessions);
@@ -0,0 +1,29 @@
namespace FrameLedger.App.Services;
/// <summary>D33: how a request to grant or withdraw one game's user-mode exception ended.</summary>
public enum AntiCheatExceptionOutcome
{
/// <summary>The Agent wrote the grant (<c>AntiCheatExceptionAck.granted = true</c>). Hooking is still off until FR-2.1.</summary>
Granted,
/// <summary>The exception is not in force any more (<c>granted = false</c> on a withdrawal).</summary>
Withdrawn,
/// <summary>The user closed the disclosure without accepting; nothing was sent.</summary>
Declined,
/// <summary>The Agent's own facts did not make the game eligible (<c>Refused</c>).</summary>
Refused,
/// <summary>The Agent grants against another version of the disclosure than this app shows; the dialog was not opened.</summary>
VersionMismatch,
/// <summary>The option is off in Settings (<c>Error ExceptionsOff</c>); nothing was granted.</summary>
OptionOff,
/// <summary>No connected Agent; nothing was sent.</summary>
AgentUnavailable,
/// <summary>The Agent answered and did not grant (a store outcome, an <c>Error</c>, a timeout); <c>Detail</c> says which.</summary>
Failed,
}
@@ -0,0 +1,41 @@
using System.Windows.Data;
using FrameLedger.App.Dialogs;
using FrameLedger.App.ViewModels;
using Wpf.Ui;
using Wpf.Ui.Controls;
namespace FrameLedger.App.Services;
/// <summary>
/// D33's disclosure in WPF UI, the same shape as FR-2.1's (<see cref="ConsentPrompt"/>): the primary button is bound to the
/// ticked acceptance and disabled until it is ticked; the close button keeps the game blocked and is the default, so Enter
/// never makes an exception.
/// </summary>
public sealed class AntiCheatExceptionPrompt : IAntiCheatExceptionPrompt
{
private readonly IContentDialogService _dialogs;
public AntiCheatExceptionPrompt(IContentDialogService dialogs) => _dialogs = dialogs ?? throw new ArgumentNullException(nameof(dialogs));
public async Task<bool> ShowAsync(AntiCheatExceptionFacts facts, CancellationToken ct = default)
{
var viewModel = new AntiCheatExceptionDialogViewModel(facts);
var dialog = new ContentDialog
{
Title = viewModel.Title,
Content = new AntiCheatExceptionDialogContent(viewModel),
PrimaryButtonText = AntiCheatExceptionDialogViewModel.GrantText,
CloseButtonText = AntiCheatExceptionDialogViewModel.CancelText,
// Enter keeps the game blocked; only a click on the (acceptance-gated) primary makes the exception.
DefaultButton = ContentDialogButton.Close,
IsPrimaryButtonEnabled = false,
DialogMaxWidth = 700,
};
_ = dialog.SetBinding(ContentDialog.IsPrimaryButtonEnabledProperty,
new Binding(nameof(AntiCheatExceptionDialogViewModel.Accepted)) { Source = viewModel, Mode = BindingMode.OneWay });
ContentDialogResult result = await _dialogs.ShowAsync(dialog, ct).ConfigureAwait(true);
// The binding is the gate on the button; this is the same rule read once more at the moment that matters.
return result == ContentDialogResult.Primary && viewModel.Accepted;
}
}
@@ -0,0 +1,46 @@
using System.Globalization;
using FrameLedger.Shared.Ipc;
namespace FrameLedger.App.Services;
/// <summary>D33: how an ask for a user-mode exception ended, and — for a refusal — what the Agent named.</summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public sealed record AntiCheatExceptionResult(AntiCheatExceptionOutcome Outcome, string? Detail = null, RefusedAck? Refusal = null)
{
public static AntiCheatExceptionResult Of(AntiCheatExceptionOutcome outcome) => new(outcome);
/// <summary>The outcome a user wanted: the exception made, or withdrawn.</summary>
public bool Succeeded => Outcome is AntiCheatExceptionOutcome.Granted or AntiCheatExceptionOutcome.Withdrawn;
/// <summary>What to tell the user about <paramref name="gameName"/>, or null when there is nothing to say (a declined disclosure).</summary>
public string? MessageFor(string gameName) => Outcome switch
{
AntiCheatExceptionOutcome.Granted => string.Format(CultureInfo.CurrentCulture, Strings.Exception_Result_Granted_Format, gameName),
AntiCheatExceptionOutcome.Withdrawn => string.Format(CultureInfo.CurrentCulture, Strings.Exception_Result_Withdrawn_Format, gameName),
AntiCheatExceptionOutcome.Refused => string.Format(CultureInfo.CurrentCulture, Strings.Exception_Result_Refused_Format, gameName,
RefusalText() ?? Detail ?? Strings.Common_NotAvailable),
AntiCheatExceptionOutcome.VersionMismatch => Shared.Strings.Safety_Exception_VersionMismatch,
AntiCheatExceptionOutcome.OptionOff => Shared.Strings.Safety_Exception_OptionOff,
AntiCheatExceptionOutcome.AgentUnavailable => Shared.Strings.Safety_Consent_AgentUnavailable,
AntiCheatExceptionOutcome.Failed => Detail ?? Strings.Common_NotAvailable,
_ => null,
};
/// <summary>Why no exception was made, in the user's language: the session count, the finding, or the block's kind.</summary>
public string? RefusalText()
{
if (Refusal is null)
{
return null;
}
return Refusal.Reason switch
{
"TooFewSessions" => string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_TooFew_Format, Refusal.Signal ?? "0"),
"BlockNotExceptionable" => Strings.Exception_State_NotAsked,
"PreScanFailed" or "RulesUnreadable" or "RulesMalformed" or "RulesIncomplete" => Strings.Exception_State_CouldNotVerify,
_ => string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_Refused_Format,
Refusal.Family ?? Formats.GuardReasonText(Refusal.Reason), Refusal.Signal ?? Strings.Common_NotAvailable),
};
}
}
@@ -0,0 +1,104 @@
using System.IO;
using FrameLedger.Infrastructure.Ipc;
using FrameLedger.Shared.Ipc;
using FrameLedger.Shared.Safety;
using Serilog;
namespace FrameLedger.App.Services;
/// <summary>
/// D33 (owner decision 2026-09-26) from the App's side: the version handshake (the dialog is not opened when the Agent
/// grants against other text), the disclosure, and the one message that may ask for a user-mode exception
/// (<c>SetAntiCheatException</c>). Like <see cref="HookingConsent"/> it asserts nothing: it sends the version it showed,
/// and the Agent re-checks the option, the block, a tolerant pre-scan of the file on disk and the session count, and
/// grants or refuses (<c>07_IPC</c> §The pipe is not a trust boundary).
/// </summary>
public sealed class AntiCheatExceptions
{
private readonly IAgentRequests _agent;
private readonly IAntiCheatExceptionPrompt _prompt;
public AntiCheatExceptions(IAgentRequests agent, IAntiCheatExceptionPrompt prompt)
{
_agent = agent ?? throw new ArgumentNullException(nameof(agent));
_prompt = prompt ?? throw new ArgumentNullException(nameof(prompt));
}
/// <summary>Show the disclosure for the game in <paramref name="facts"/> and, on its acceptance, ask the Agent for the exception.</summary>
public async Task<AntiCheatExceptionResult> GrantAsync(long gameId, AntiCheatExceptionFacts facts, CancellationToken ct = default)
{
ArgumentNullException.ThrowIfNull(facts);
HelloAck? hello = _agent.Hello;
if (hello is null || !_agent.IsConnected)
{
return AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable);
}
if (!string.Equals(hello.ExceptionDisclosureVersion, AntiCheatExceptionDisclosure.Version, StringComparison.Ordinal))
{
// Showing text the Agent would not grant against is a dialog whose button cannot mean what it says.
Log.Warning("exception: the Agent grants against {Theirs}, this app shows {Ours}; the dialog was not opened",
hello.ExceptionDisclosureVersion, AntiCheatExceptionDisclosure.Version);
return new AntiCheatExceptionResult(AntiCheatExceptionOutcome.VersionMismatch, hello.ExceptionDisclosureVersion);
}
if (!await _prompt.ShowAsync(facts, ct).ConfigureAwait(true))
{
return AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.Declined);
}
return await SendAsync(new SetAntiCheatExceptionRequest(gameId, Enabled: true, AntiCheatExceptionDisclosure.Version), ct).ConfigureAwait(true);
}
/// <summary>Withdraw the game's exception; no dialog — a withdrawal only takes hooking away.</summary>
public Task<AntiCheatExceptionResult> WithdrawAsync(long gameId, CancellationToken ct = default) =>
_agent.IsConnected
? SendAsync(new SetAntiCheatExceptionRequest(gameId, Enabled: false, null), ct)
: Task.FromResult(AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable));
private async Task<AntiCheatExceptionResult> SendAsync(SetAntiCheatExceptionRequest request, CancellationToken ct)
{
try
{
IpcEnvelope ack = await _agent.RequestAsync(IpcMessageType.SetAntiCheatException, request, ct).ConfigureAwait(true);
return Interpret(ack, request.Enabled);
}
catch (Exception ex) when (ex is IpcRequestException or TimeoutException or IOException or InvalidOperationException)
{
Log.Warning(ex, "exception: SetAntiCheatException(game {GameId}, {Enabled}) did not complete", request.GameId, request.Enabled);
string? code = (ex as IpcRequestException)?.Code;
AntiCheatExceptionOutcome outcome = code switch
{
IpcErrorCode.DisclosureVersionMismatch => AntiCheatExceptionOutcome.VersionMismatch,
IpcErrorCode.ExceptionsOff => AntiCheatExceptionOutcome.OptionOff,
_ => AntiCheatExceptionOutcome.Failed,
};
return new AntiCheatExceptionResult(outcome, code ?? ex.GetType().Name);
}
}
private static AntiCheatExceptionResult Interpret(IpcEnvelope ack, bool granting)
{
if (string.Equals(ack.Type, IpcMessageType.Refused, StringComparison.Ordinal))
{
RefusedAck? refused = IpcCodec.Payload<RefusedAck>(ack);
return new AntiCheatExceptionResult(AntiCheatExceptionOutcome.Refused, refused?.Reason, refused);
}
if (!string.Equals(ack.Type, IpcMessageType.AntiCheatExceptionAck, StringComparison.Ordinal))
{
return new AntiCheatExceptionResult(AntiCheatExceptionOutcome.Failed, "UnexpectedAck:" + ack.Type);
}
AntiCheatExceptionAck? answer = IpcCodec.Payload<AntiCheatExceptionAck>(ack);
if (answer is null)
{
return new AntiCheatExceptionResult(AntiCheatExceptionOutcome.Failed, "EmptyAck");
}
// A withdrawal of an exception that was not in force is still the state the user asked for.
return granting
? answer.Granted ? new(AntiCheatExceptionOutcome.Granted, answer.Outcome) : new(AntiCheatExceptionOutcome.Failed, answer.Outcome)
: answer.Granted ? new(AntiCheatExceptionOutcome.Failed, answer.Outcome) : new(AntiCheatExceptionOutcome.Withdrawn, answer.Outcome);
}
}
@@ -0,0 +1,102 @@
using System.Globalization;
using FrameLedger.Application.AntiCheat;
using FrameLedger.Application.Persistence;
using FrameLedger.Domain.AntiCheat;
namespace FrameLedger.App.Services;
/// <summary>
/// D33 (owner decision 2026-09-26): a blocked game's user-mode exception as the App shows it — in force, eligible, being
/// checked, or why not — read from the Agent's columns (<see cref="GameRow.AcException"/>). The App decides nothing here:
/// every state is a reading of what the Agent wrote, and the grant itself is the Agent's to make.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public sealed record ExceptionView(ExceptionViewKind Kind, string Text, string? Family, string? Signal, int Sessions, string? LapseText)
{
/// <summary>An exception may be asked for now.</summary>
public bool CanGrant => Kind == ExceptionViewKind.Eligible;
/// <summary>An exception is on the row and may be withdrawn.</summary>
public bool CanWithdraw => Kind == ExceptionViewKind.Granted;
/// <summary>
/// The row's exception, or null for a row it says nothing about (not blocked). Granted first — a grant stays until the
/// Agent or the user ends it — then the block's kind, then the sweep's answer about THIS block.
/// </summary>
public static ExceptionView? Of(GameRow row)
{
ArgumentNullException.ThrowIfNull(row);
if (!row.BlockedByGuard)
{
return null;
}
AntiCheatExceptionState x = row.AcException;
StoredBlock? block = StoredBlock.Parse(row.HookBlockedReason);
string? lapse = x.LapsedReason is { } reason && x.LapsedAt is { } at
? string.Format(CultureInfo.CurrentCulture, Strings.Exception_Lapsed_Format, Formats.Date(at), LapseWords(reason))
: null;
if (x.IsGranted)
{
return new(ExceptionViewKind.Granted, string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_Granted_Format, Formats.Date(x.GrantedAt!.Value)),
x.Family, block?.Signal, x.Sessions, lapse);
}
if (block is not { IsExceptionable: true } b)
{
return new(ExceptionViewKind.NotEligible, Strings.Exception_State_NotAsked, block?.Family, block?.Signal, x.Sessions, lapse);
}
if (!string.Equals(x.CheckedBlock, row.HookBlockedReason, StringComparison.Ordinal))
{
return new(ExceptionViewKind.Checking, Strings.Exception_State_Checking, b.Family, b.Signal, x.Sessions, lapse);
}
return x.Eligible
? new(ExceptionViewKind.Eligible, Strings.Exception_State_Eligible, b.Family, b.Signal, x.Sessions, lapse)
: new(NotEligibleKind(x), WhyNot(b, x), b.Family, b.Signal, x.Sessions, lapse);
}
/// <summary>Why the last grant ended, in words.</summary>
public static string LapseWords(string reason) => reason switch
{
UserModeExceptionLapse.Withdrawn => Strings.Exception_Lapse_Withdrawn,
UserModeExceptionLapse.ExecutableChanged => Strings.Exception_Lapse_ExecutableChanged,
UserModeExceptionLapse.NoLongerEligible => Strings.Exception_Lapse_NoLongerEligible,
UserModeExceptionLapse.NewFinding => Strings.Exception_Lapse_NewFinding,
UserModeExceptionLapse.SafetyUnhook => Strings.Exception_Lapse_SafetyUnhook,
UserModeExceptionLapse.OverlayStopped => Strings.Exception_Lapse_OverlayStopped,
UserModeExceptionLapse.SessionCrashed => Strings.Exception_Lapse_SessionCrashed,
_ => reason,
};
/// <summary>The guard let the family through and only the evidence is short — the one "not yet" the Settings list shows.</summary>
private static ExceptionViewKind NotEligibleKind(AntiCheatExceptionState x) =>
StoredBlock.Parse(x.Verdict) is { Reason: AntiCheatRefusalReason.AllowedUnderUserModeException }
? ExceptionViewKind.TooFewSessions
: ExceptionViewKind.NotEligible;
private static string WhyNot(StoredBlock block, AntiCheatExceptionState x)
{
StoredBlock? verdict = StoredBlock.Parse(x.Verdict);
if (verdict is null)
{
return Strings.Exception_State_NotAsked;
}
if (verdict.Value.Reason == AntiCheatRefusalReason.AllowedUnderUserModeException)
{
return string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_TooFew_Format, x.Sessions);
}
if (!verdict.Value.IsExceptionable && verdict.Value.Family.Length == 0)
{
return Strings.Exception_State_CouldNotVerify;
}
// The same finding back means the guard does not honour this family: it is not user-mode throughout.
return string.Equals(verdict.Value.Family, block.Family, StringComparison.Ordinal)
? string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_NotUserMode_Format, block.Family)
: string.Format(CultureInfo.CurrentCulture, Strings.Exception_State_Refused_Format, verdict.Value.Family, verdict.Value.Signal);
}
}
@@ -0,0 +1,20 @@
namespace FrameLedger.App.Services;
/// <summary>D33: the states a blocked game's user-mode exception is shown in (<see cref="ExceptionView"/>).</summary>
public enum ExceptionViewKind
{
/// <summary>An exception is on the row.</summary>
Granted,
/// <summary>The Agent found the game eligible; no exception has been made.</summary>
Eligible,
/// <summary>The guard would let the family through, and the game has fewer than two successful hooked sessions.</summary>
TooFewSessions,
/// <summary>The Agent has not answered about this block yet (the option was just turned on, or the block changed).</summary>
Checking,
/// <summary>Not eligible, for the reason in the text.</summary>
NotEligible,
}
+243 -3
View File
@@ -1,5 +1,9 @@
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using FrameLedger.Application.Capture;
using FrameLedger.Application.Recording;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Metrics;
using FrameLedger.Domain.Sessions;
@@ -13,9 +17,20 @@ namespace FrameLedger.App.Services;
[SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime; a cached CompositeFormat would pin the first culture")]
public static class Formats
{
public static string Fps(double? value) => value is double v ? Math.Round(v).ToString("0", CultureInfo.CurrentCulture) : Strings.Common_NotAvailable;
public static string Fps(double? value) => value is double v ? FpsNumber(v) : Strings.Common_NotAvailable;
public static string FpsOrDash(double? value) => value is double v ? Math.Round(v).ToString("0", CultureInfo.CurrentCulture) : Strings.Common_Dash;
public static string FpsOrDash(double? value) => value is double v ? FpsNumber(v) : Strings.Common_Dash;
/// <summary>
/// An FPS figure as <c>ui.fps_decimals</c> asks (beta.8): two decimals always ("62.40"), or a whole number. Rounded half
/// away from zero — 62.5 is 63, as a reader expects; <see cref="Math.Round(double)"/> alone rounds half to even (62).
/// </summary>
public static string FpsNumber(double value) => FpsNumber(value, FpsDecimals.Two);
/// <summary>The same with the choice given (tests, and anything that must not read the process-wide setting).</summary>
public static string FpsNumber(double value, bool twoDecimals) => twoDecimals
? Math.Round(value, 2, MidpointRounding.AwayFromZero).ToString("0.00", CultureInfo.CurrentCulture)
: Math.Round(value, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.CurrentCulture);
/// <summary><c>1h 23m</c> above an hour, <c>4m 05s</c> below.</summary>
public static string Duration(double seconds)
@@ -151,6 +166,93 @@ public static class Formats
_ => id,
};
/// <summary>What an executable runs as (<c>games.exe_machine</c>, beta.8), in the user's language.</summary>
public static string Architecture(string? id) => id switch
{
ExecutableArchitecture.X64 => Strings.Arch_X64,
ExecutableArchitecture.X86 => Strings.Arch_X86,
ExecutableArchitecture.Arm64 => Strings.Arch_Arm64,
ExecutableArchitecture.Arm => Strings.Arch_Arm,
ExecutableArchitecture.AnyCpu => Strings.Arch_AnyCpu,
ExecutableArchitecture.AnyCpu32 => Strings.Arch_AnyCpu32,
ExecutableArchitecture.Other => Strings.Arch_Other,
_ => Strings.Arch_Unknown,
};
/// <summary>
/// <c>games.game_version</c> said as what it is (beta.8): a store import writes a Steam build id or a GOG / Epic
/// version string, and a bare "20374416" in the subtitle said nothing. Labelled with the store when a store wrote it
/// (<paramref name="detected"/>); a version the user typed is shown as typed. Null when there is none.
/// </summary>
public static string? StoreVersion(string? platform, string? version, bool detected)
{
if (string.IsNullOrWhiteSpace(version))
{
return null;
}
string? format = !detected ? null : platform switch
{
"steam" => Strings.Store_Steam_Format,
"gog" => Strings.Store_Gog_Format,
"epic" => Strings.Store_Epic_Format,
_ => null,
};
return format is null ? version : string.Format(CultureInfo.CurrentCulture, format, version);
}
/// <summary>
/// Whether two file versions are the same four numbers — Streamline stamps its version STRING as <c>2,8,0,0</c> and
/// the fixed part reads <c>2.8.0.0</c>, which agree; a string with text after the numbers is read up to it. Null
/// when either has no number to compare (beta.8: the session summary's "another copy was loaded").
/// </summary>
public static bool? SameVersion(string? a, string? b)
{
int[]? x = VersionNumbers(a);
int[]? y = VersionNumbers(b);
if (x is null || y is null)
{
return null;
}
for (int i = 0; i < 4; i++)
{
if ((i < x.Length ? x[i] : 0) != (i < y.Length ? y[i] : 0))
{
return false;
}
}
return true;
}
private static int[]? VersionNumbers(string? text)
{
if (string.IsNullOrWhiteSpace(text))
{
return null;
}
List<int> parts = new(4);
foreach (string token in text.Split(['.', ','], StringSplitOptions.TrimEntries))
{
// "3.7.10.0 built by …": the numbers end at the first token that is not all digits.
string digits = new([.. token.TakeWhile(char.IsAsciiDigit)]);
if (digits.Length == 0 || !int.TryParse(digits, NumberStyles.None, CultureInfo.InvariantCulture, out int n))
{
break;
}
parts.Add(n);
if (parts.Count == 4 || digits.Length != token.Length)
{
break;
}
}
return parts.Count == 0 ? null : [.. parts];
}
/// <summary>The platform token as its store name.</summary>
public static string Platform(string? token) => token switch
{
@@ -186,13 +288,151 @@ public static class Formats
return Strings.Summary_Tier2_Why_HookOff;
case "RefusedByGuard" or "SafetyUnhook" when n.GuardFamily is { Length: > 0 } family:
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Guard_Format, family, n.GuardSignal ?? Strings.Common_NotAvailable);
case "RefusedByGuard" when n.GuardReason is { Length: > 0 } reason:
// A refusal no family names (beta.8): the guard could not look, the game is 32-bit… — said as what it is,
// never "… was detected in this game", which read as a finding.
return GuardSentence(reason);
case "TargetUnreadable":
return Strings.Summary_Tier2_Why_Unreadable;
case "RefusedConsentMissing":
// Common after a store update (2026-09-23): the consent is about the executable that was enabled, and this is a newer one.
return Strings.Summary_Tier2_Why_ConsentChanged;
case "LaunchCannotStart" when n.LaunchError is { } error:
return string.Format(CultureInfo.CurrentCulture, Strings.Launch_Failed_Format, Strings.End_LaunchCannotStart, LaunchErrorText(error));
default:
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Other_Format, n.End);
return EndReasonText(n.End) ?? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Other_Format, n.End);
}
}
/// <summary>
/// Why a session ended, in words, for every <see cref="SessionEndReason"/> (beta.8); null for a name this build does not
/// know. <c>Formats_EveryEndReasonHasItsOwnSentence</c> walks the enum so none falls through.
/// </summary>
public static string? EndReasonText(string? end) => end switch
{
nameof(SessionEndReason.Running) => Strings.End_Running,
nameof(SessionEndReason.TargetExited) => Strings.End_TargetExited,
nameof(SessionEndReason.SafetyUnhook) => Strings.End_SafetyUnhook,
nameof(SessionEndReason.SupervisionLost) => Strings.End_SupervisionLost,
nameof(SessionEndReason.WriterSelfDisabled) => Strings.End_WriterSelfDisabled,
nameof(SessionEndReason.WriterStoppedBlocklisted) => Strings.End_WriterStoppedBlocklisted,
nameof(SessionEndReason.WriterNeverInstalledHooks) => Strings.End_WriterNeverInstalledHooks,
nameof(SessionEndReason.RefusedHookNotEnabled) => Strings.End_RefusedHookNotEnabled,
nameof(SessionEndReason.RefusedConsentMissing) => Strings.End_RefusedConsentMissing,
nameof(SessionEndReason.RefusedPreviouslyBlocked) => Strings.End_RefusedPreviouslyBlocked,
nameof(SessionEndReason.RefusedByGuard) => Strings.End_RefusedByGuard,
nameof(SessionEndReason.PreScanCouldNotVerify) => Strings.End_PreScanCouldNotVerify,
nameof(SessionEndReason.TargetNotRunning) => Strings.End_TargetNotRunning,
nameof(SessionEndReason.TargetCannotBePinned) => Strings.End_TargetCannotBePinned,
nameof(SessionEndReason.ExecutableUnreadable) => Strings.End_ExecutableUnreadable,
nameof(SessionEndReason.SupervisionFaulted) => Strings.End_SupervisionFaulted,
nameof(SessionEndReason.TargetAmbiguous) => Strings.End_TargetAmbiguous,
nameof(SessionEndReason.AttachRefused) => Strings.End_AttachRefused,
nameof(SessionEndReason.LaunchCannotStart) => Strings.End_LaunchCannotStart,
nameof(SessionEndReason.LaunchTargetExited) => Strings.End_LaunchTargetExited,
nameof(SessionEndReason.LaunchNoPresentationRuntime) => Strings.End_LaunchNoPresentationRuntime,
nameof(SessionEndReason.RefusedKillSwitch) => Strings.End_RefusedKillSwitch,
nameof(SessionEndReason.KillSwitchEngaged) => Strings.End_KillSwitchEngaged,
nameof(SessionEndReason.StoppedByUser) => Strings.End_StoppedByUser,
nameof(SessionEndReason.TargetUnreadable) => Strings.End_TargetUnreadable,
_ => null,
};
/// <summary>
/// A guard refusal no anti-cheat family names, as a sentence (beta.8): "The anti-cheat guard did not hook this game: the
/// game is 32-bit…". Every refusal reason the native guard can give has its words; a name this build does not know is
/// named as it is.
/// </summary>
public static string GuardSentence(string reason) =>
string.Format(CultureInfo.CurrentCulture, Strings.Guard_Refused_Format, GuardReasonText(reason));
/// <summary>What a familyless guard reason means, as a clause.</summary>
public static string GuardReasonText(string reason) => reason switch
{
"ModuleScanFailed" => Strings.Guard_ModuleScanFailed,
"ProcessUnreadable" => Strings.Guard_ProcessUnreadable,
"ProcessTreeUnavailable" => Strings.Guard_ProcessTreeUnavailable,
"DriverScanFailed" => Strings.Guard_DriverScanFailed,
"ServiceQueryFailed" => Strings.Guard_ServiceQueryFailed,
"RulesUnreadable" => Strings.Guard_RulesUnreadable,
"RulesMalformed" => Strings.Guard_RulesMalformed,
"RulesIncomplete" => Strings.Guard_RulesIncomplete,
"PreScanFailed" => Strings.Guard_PreScanFailed,
"InjectionFailed" => Strings.Guard_InjectionFailed,
"TargetIsWow64" => Strings.Guard_TargetIsWow64,
"PayloadNotOurs" => Strings.Guard_PayloadNotOurs,
"HookNotEnabled" => Strings.Guard_HookNotEnabled,
"ConsentMissing" => Strings.Guard_ConsentMissing,
"PreviouslyBlocked" => Strings.Guard_PreviouslyBlocked,
"LaunchTargetExited" => Strings.Guard_LaunchTargetExited,
"LaunchNoPresentationRuntime" => Strings.Guard_LaunchNoPresentationRuntime,
"TargetIsVulkanLayered" => Strings.Guard_TargetIsVulkanLayered,
"SuspiciousUnsigned" => Strings.Guard_SuspiciousUnsigned,
_ => string.Format(CultureInfo.CurrentCulture, Strings.Guard_Other_Format, reason),
};
/// <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.
/// </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,
ExitStatus.Normal => notes.ExitCode switch
{
null or 0 => Strings.Exit_EndedNormally,
1 => Strings.Exit_Code1,
{ } other => string.Format(CultureInfo.CurrentCulture, Strings.Exit_Code_Format, CodeText(other)),
},
_ => ExitStatusText(status),
};
/// <summary>The exception an exit code names, or the code in hex.</summary>
public static string ExceptionName(int code) => unchecked((uint)code) switch
{
0xC0000005 => Strings.Exit_Ex_AccessViolation,
0xC0000006 => Strings.Exit_Ex_InPageError,
0xC00000FD => Strings.Exit_Ex_StackOverflow,
0xC0000374 => Strings.Exit_Ex_HeapCorruption,
0xC0000409 => Strings.Exit_Ex_FailFast,
0xC0000142 => Strings.Exit_Ex_DllInit,
0xC0000135 => Strings.Exit_Ex_DllNotFound,
0xC000007B => Strings.Exit_Ex_BadImage,
0xE06D7363 => Strings.Exit_Ex_Cpp,
0xE0434352 => Strings.Exit_Ex_Clr,
0x80000003 => Strings.Exit_Ex_Breakpoint,
_ => CodeText(code),
};
/// <summary>An exit code as a person reads it: small ones in decimal, NTSTATUS-shaped ones in hex.</summary>
private static string CodeText(int code) =>
code is >= -255 and <= 65535 ? code.ToString(CultureInfo.CurrentCulture) : "0x" + unchecked((uint)code).ToString("X8", CultureInfo.InvariantCulture);
/// <summary>A launch's Win32 error in words (beta.8): the few a game launch meets, and the number otherwise.</summary>
public static string LaunchErrorText(int error) => error switch
{
2 => Strings.Launch_Error_2,
3 => Strings.Launch_Error_3,
5 => Strings.Launch_Error_5,
193 => Strings.Launch_Error_193,
740 => Strings.Launch_Error_740,
_ => string.Format(CultureInfo.CurrentCulture, Strings.Launch_Error_Format, error),
};
/// <summary>
/// Why an executable is not where the row says (beta.8): a drive that is not connected — the owner's external drive
/// changes letter, 2026-09-22 — is said as that, and FrameLedger finds the game again when it is back; otherwise the
/// file itself is gone from its path.
/// </summary>
public static string ExecutableMissingText(string exePath)
{
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
string? root = Path.GetPathRoot(exePath);
return !string.IsNullOrEmpty(root) && !Directory.Exists(root)
? string.Format(CultureInfo.CurrentCulture, Strings.Exe_DriveMissing_Format, root)
: string.Format(CultureInfo.CurrentCulture, Strings.Exe_FileMissing_Format, exePath);
}
}
@@ -0,0 +1,18 @@
namespace FrameLedger.App.Services;
/// <summary>
/// <c>ui.fps_decimals</c> as the formatters read it (beta.8, owner request 2026-09-25): whether every FPS figure shows two
/// decimals ("62.40") or a whole number ("62"). One process-wide value like <see cref="LoggingLevel"/>: set from the settings
/// row at start and by the Settings page when it changes; a page shows it the next time it formats a number.
/// </summary>
public static class FpsDecimals
{
private static volatile bool _two;
/// <summary>True: two decimals, always ("62.40"); false: a whole number.</summary>
public static bool Two
{
get => _two;
set => _two = value;
}
}
@@ -70,6 +70,8 @@ public static class FpsPresentation
FpsReadoutModel m = FromRow(row);
return m.Kind switch
{
// A steady-state factor carries its share in the grid too (rule 6; beta.8 — the column was the one place it did not).
FpsReadoutKind.Generated when m.Factor is double f && m.SteadyShare is double share => string.Format(CultureInfo.CurrentCulture, "×{0:0.0} · {1:0}%", f, share * 100),
FpsReadoutKind.Generated when m.Factor is double f => string.Format(CultureInfo.CurrentCulture, "×{0:0.0}", f),
FpsReadoutKind.None => Strings.Common_Dash,
_ => Strings.Common_NotAvailable,
@@ -104,8 +106,15 @@ public static class FpsPresentation
};
}
public static string GeneratedLine(double? native, double? displayed, double factor) =>
string.Format(CultureInfo.CurrentCulture, Strings.Fps_Fg_Format, Formats.Fps(native), Formats.Fps(displayed), factor);
public static string GeneratedLine(double? native, double? displayed, double factor) => GeneratedLine(native, displayed, factor, steadyShare: null);
/// <summary>
/// <c>62 → 118 FPS (×1.9 FG)</c> — and a steady-state factor (CLAUDE.md rule 6, 2026-09-17) always with the share of the
/// session it covers, <c>(×1.9 FG · 75%)</c>, wherever the line appears (beta.8: the Average card and Compare dropped it).
/// </summary>
public static string GeneratedLine(double? native, double? displayed, double factor, double? steadyShare) => steadyShare is double share
? string.Format(CultureInfo.CurrentCulture, Strings.Fps_Fg_Steady_Format, Formats.Fps(native), Formats.Fps(displayed), factor, share * 100)
: string.Format(CultureInfo.CurrentCulture, Strings.Fps_Fg_Format, Formats.Fps(native), Formats.Fps(displayed), factor);
public static string PresentedLine(double? presented) => string.Format(CultureInfo.CurrentCulture, Strings.Fps_Presented_Format, Formats.Fps(presented));
@@ -49,7 +49,7 @@ public sealed record FpsReadoutModel
/// <summary>The one line, per the rule: <c>62 → 118 FPS (×1.9 FG)</c>, or <c>144 FPS</c>. Never a factor that was not counted.</summary>
public string Line => Kind switch
{
FpsReadoutKind.Generated when Factor is double f => FpsPresentation.GeneratedLine(Native, Displayed, f),
FpsReadoutKind.Generated when Factor is double f => FpsPresentation.GeneratedLine(Native, Displayed, f, SteadyShare),
FpsReadoutKind.None => FpsPresentation.PresentedLine(Native),
FpsReadoutKind.Presented or FpsReadoutKind.IdentifiedUncounted => FpsPresentation.PresentedLine(Presented),
_ => Strings.Common_NotAvailable,
@@ -21,9 +21,18 @@ public sealed record HookingConsentResult(HookingConsentOutcome Outcome, string?
return Shared.Strings.Safety_Refused_CouldNotVerify;
}
string? family = Refusal.Family ?? Refusal.Signal;
return family is null
? Shared.Strings.Safety_Refused_Unnamed
: string.Format(System.Globalization.CultureInfo.CurrentCulture, Shared.Strings.Safety_Refused_Named_Format, family, Refusal.Signal ?? Refusal.Reason);
// beta.8: the Agent refused because the executable cannot run as x64 — nothing was scanned (AgentCommandHandler.NotX64Reason).
if (string.Equals(Refusal.Reason, "ExecutableNotX64", StringComparison.Ordinal))
{
return string.Format(System.Globalization.CultureInfo.CurrentCulture, Strings.Hooking_NotX64_Format, Formats.Architecture(Refusal.Signal));
}
// A refusal no family names is said as what it is (beta.8), never as its signal "detected in this game".
if (Refusal.Family is null)
{
return string.IsNullOrEmpty(Refusal.Reason) ? Shared.Strings.Safety_Refused_Unnamed : Formats.GuardSentence(Refusal.Reason);
}
return string.Format(System.Globalization.CultureInfo.CurrentCulture, Shared.Strings.Safety_Refused_Named_Format, Refusal.Family, Refusal.Signal ?? Refusal.Reason);
}
}
@@ -0,0 +1,11 @@
namespace FrameLedger.App.Services;
/// <summary>
/// D33's disclosure as a question: shows the versioned text for one game and answers whether the user accepted the risk
/// and chose to make the exception. The WPF implementation is <see cref="AntiCheatExceptionPrompt"/>; a test substitutes an
/// answer.
/// </summary>
public interface IAntiCheatExceptionPrompt
{
Task<bool> ShowAsync(AntiCheatExceptionFacts facts, CancellationToken ct = default);
}
@@ -0,0 +1,211 @@
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text.Json;
using FrameLedger.Application.Capture;
using FrameLedger.Application.Recording;
using S = FrameLedger.Application.Capture.NvidiaDriverSettings;
namespace FrameLedger.App.Services;
/// <summary>
/// What the NVIDIA driver was told to do with a game, in words (beta.8, owner request 2026-09-25): the NVIDIA App's DLSS and
/// frame-generation overrides as the driver profile stores them (<c>sessions.driver_profile</c>), and what the driver itself
/// reported applying in the game's process (<c>sessions.ngx_driver_words</c>).
/// </summary>
/// <remarks>
/// A configuration and a driver's report — never a measurement. What a session MEASURED (the upscaler a hook saw, the frame
/// generation it counted) stays the hooks' and is shown as such; these lines say what the driver was set to do and what it
/// says it did (<c>03_METRICS</c> §Upscaling). The meanings of the values are NVIDIA's <c>NvApiDriverSettings.h</c>.
/// </remarks>
[SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public static class NvidiaOverrides
{
/// <summary>
/// The session summary's line for the profile: which profile the driver applied and what it overrides. Null when there
/// is nothing to say — no profile read (no NVIDIA driver, or a row from before beta.8).
/// </summary>
public static string? ProfileLine(string? driverProfileJson)
{
DriverProfileRecord? profile = DriverProfileRecord.Parse(driverProfileJson);
if (profile is null || !IsRead(profile))
{
return null;
}
string overrides = OverridesText(profile);
return string.Equals(profile.Outcome, nameof(DriverProfileOutcome.Application), StringComparison.Ordinal)
? string.Format(CultureInfo.CurrentCulture, Strings.Nv_Profile_Format, profile.Profile ?? Strings.Common_NotAvailable, overrides)
: string.Format(CultureInfo.CurrentCulture, Strings.Nv_Profile_Global_Format, overrides);
}
/// <summary>What the profile overrides, as one phrase list — or "no DLSS or frame generation override".</summary>
public static string OverridesText(DriverProfileRecord profile)
{
IReadOnlyList<string> parts = Of(profile);
return parts.Count == 0 ? Strings.Nv_Override_None : string.Join(" · ", parts);
}
/// <summary>Whether the record holds a profile that was read (an application's or the global one).</summary>
public static bool IsRead(DriverProfileRecord profile)
{
ArgumentNullException.ThrowIfNull(profile);
return profile.Outcome is nameof(DriverProfileOutcome.Application) or nameof(DriverProfileOutcome.Global);
}
/// <summary>The overrides a profile sets, one phrase each; empty when it sets none.</summary>
public static IReadOnlyList<string> Of(DriverProfileRecord profile)
{
ArgumentNullException.ThrowIfNull(profile);
List<string> parts = [];
if (profile.ValueOf(S.DlssSrOverride) == 1)
{
parts.Add(Detailed(Strings.Nv_Override_Sr, Preset(profile.ValueOf(S.DlssSrPreset)),
Mode(profile.ValueOf(S.DlssSrMode), profile.ValueOf(S.DlssSrScalingRatio)),
profile.ValueOf(S.DlaaOverride) == 1 ? Strings.Nv_Mode_Dlaa : null));
}
if (profile.ValueOf(S.DlssRrOverride) == 1)
{
parts.Add(Detailed(Strings.Nv_Override_Rr, Preset(profile.ValueOf(S.DlssRrPreset)),
Mode(profile.ValueOf(S.DlssRrMode), profile.ValueOf(S.DlssRrScalingRatio))));
}
if (profile.ValueOf(S.DlssFgOverride) == 1)
{
parts.Add(Detailed(Strings.Nv_Override_Fg, Multiplier(profile.ValueOf(S.DlssgMultiFrameCount)), Preset(profile.ValueOf(S.DlssFgPreset)),
FrameGenerationMode(profile.ValueOf(S.DlssgMode)), DynamicTarget(profile.ValueOf(S.DlssgDynamicTargetFrameRate))));
}
else if (FrameGenerationMode(profile.ValueOf(S.DlssgMode)) is { } forced)
{
parts.Add(forced);
}
if (profile.ValueOf(S.StreamlineDlssOverride) == 1)
{
parts.Add(Strings.Nv_Override_Sl);
}
if (profile.ValueOf(S.SmoothMotion) == 1)
{
parts.Add(Strings.Nv_SmoothMotion);
}
return parts;
}
/// <summary>
/// The session summary's line for the driver's own report on the game's process (<c>NvAPI_NGX_GetNGXOverrideState</c>):
/// what its override bits say it applied. Null when it answered nothing, or reported no override.
/// </summary>
public static string? DriverLine(string? ngxDriverWordsJson)
{
if (string.IsNullOrWhiteSpace(ngxDriverWordsJson))
{
return null;
}
NgxDriverWords? words;
try
{
words = JsonSerializer.Deserialize(ngxDriverWordsJson, RecordingJsonContext.Default.NgxDriverWords);
}
catch (JsonException)
{
return null;
}
if (words is null || !string.Equals(words.Outcome, nameof(NgxProbeOutcome.Answered), StringComparison.Ordinal))
{
return null;
}
ulong sr = Mask(words.Sr);
ulong fg = Mask(words.Fg);
List<string> parts = [];
if ((sr & NgxOverrideFlags.DllSelected) != 0)
{
parts.Add(Strings.Nv_Driver_DllSelected);
}
if ((sr & NgxOverrideFlags.Preset) != 0 && Preset(words.Preset) is { } preset)
{
parts.Add(preset);
}
if ((sr & NgxOverrideFlags.PerfMode) != 0 && Mode(words.Mode, ratio: null) is { } mode)
{
parts.Add(mode);
}
if ((sr & NgxOverrideFlags.ScalingRatio) != 0 && words.Ratio is float ratio && ratio > 0)
{
parts.Add(string.Format(CultureInfo.CurrentCulture, Strings.Nv_Driver_Ratio_Format, ratio.ToString("0.###", CultureInfo.CurrentCulture)));
}
if ((sr & NgxOverrideFlags.SrDlaaMode) != 0)
{
parts.Add(Strings.Nv_Mode_Dlaa);
}
if ((fg & NgxOverrideFlags.FgMultiFrame) != 0 && Multiplier(words.FgCount) is { } multiplier)
{
parts.Add(Detailed(Strings.Nv_Override_Fg, multiplier));
}
return parts.Count == 0 ? null : string.Format(CultureInfo.CurrentCulture, Strings.Nv_Driver_Format, string.Join(" · ", parts));
}
private static ulong Mask(string? hex) =>
hex is { Length: > 2 } && ulong.TryParse(hex.AsSpan(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong value) ? value : 0;
private static string Detailed(string head, params string?[] details)
{
string[] present = [.. details.Where(static d => !string.IsNullOrEmpty(d)).Select(static d => d!)];
return present.Length == 0 ? head : string.Format(CultureInfo.CurrentCulture, Strings.Nv_Details_Format, head, string.Join(", ", present));
}
/// <summary>A render preset: 1 = A … 26 = Z, "latest", "default"; 0 (off) and anything else say nothing.</summary>
public static string? Preset(uint? value) => value switch
{
null or 0 => null,
S.PresetLatest => Strings.Nv_Preset_Latest,
S.PresetDefault => Strings.Nv_Preset_Default,
>= 1 and <= 26 => string.Format(CultureInfo.CurrentCulture, Strings.Nv_Preset_Format, (char)('A' + (int)value.Value - 1)),
_ => null,
};
/// <summary><c>NGX_DLSS_SR_MODE</c> / <c>_RR_MODE</c>; 3 is "the game's own" — no override — and says nothing.</summary>
public static string? Mode(uint? value, uint? ratio) => value switch
{
0 => Strings.Nv_Mode_Performance,
1 => Strings.Nv_Mode_Balanced,
2 => Strings.Nv_Mode_Quality,
4 => Strings.Nv_Mode_Dlaa,
5 => Strings.Nv_Mode_UltraPerformance,
6 => ratio is >= 33 and <= 100
? string.Format(CultureInfo.CurrentCulture, Strings.Nv_Mode_Custom_Format, ratio.Value)
: Strings.Nv_Mode_Custom,
_ => null,
};
/// <summary><c>NGX_DLSSG_MULTI_FRAME_COUNT</c>: frames generated per rendered frame, said as the multiplier (1 = ×2 … 3 = ×4).</summary>
public static string? Multiplier(uint? generated) =>
generated is >= 1 and <= 15 ? string.Format(CultureInfo.CurrentCulture, Strings.Nv_Mfg_Format, generated.Value + 1) : null;
private static string? FrameGenerationMode(uint? value) => value switch
{
1 => Strings.Nv_FgMode_Off,
2 => Strings.Nv_FgMode_On,
3 => Strings.Nv_FgMode_Auto,
4 => Strings.Nv_FgMode_Dynamic,
_ => null,
};
private static string? DynamicTarget(uint? value) => value switch
{
null or 0 => null,
S.DynamicTargetAuto => Strings.Nv_DynamicTarget_Auto,
< S.DynamicTargetAuto => string.Format(CultureInfo.CurrentCulture, Strings.Nv_DynamicTarget_Format, value.Value),
_ => null,
};
}
@@ -80,10 +80,14 @@ public sealed class SafetyNotices : IDisposable
return Shared.Strings.Safety_Refused_TargetUnreadable;
}
string? named = family ?? signal;
return named is null
? Shared.Strings.Safety_Refused_Unnamed
: string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Refused_Named_Format, named, signal ?? reason);
// A refusal no anti-cheat family names (beta.8) — the guard could not look, the game is 32-bit — is said as what it
// is. It used to name its SIGNAL as the family, and the notice read "Access is denied was detected in this game".
if (family is null)
{
return string.IsNullOrEmpty(reason) ? Shared.Strings.Safety_Refused_Unnamed : Formats.GuardSentence(reason);
}
return string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Refused_Named_Format, family, signal ?? reason);
}
private void OnEvent(object? sender, AgentEventArgs e)
@@ -100,6 +100,13 @@ public sealed class SessionExporter
w.WriteLine("# started_at: " + row.StartedAt.ToString("O", _inv));
w.WriteLine("# ended_at: " + row.EndedAt.ToString("O", _inv));
w.WriteLine("# capture_tier: " + ((int)row.Tier).ToString(_inv) + (row.Tier == CaptureTier.Hooked ? " (hooked, measured)" : " (not hooked: duration and sensors only; no per-frame rows)"));
if (row.AcExceptionFamily is { Length: > 0 } excepted)
{
// D33: a session hooked under the game's user-mode anti-cheat exception says so wherever it goes (the JSON carries
// the column in its aggregates).
w.WriteLine("# ac_exception: " + excepted + " (hooked under the game's user-mode anti-cheat exception)");
}
w.WriteLine("# api: " + (row.Api ?? "N/A") + "; present_mode: " + (row.PresentMode ?? "N/A") + "; swap_effect: " + (row.SwapEffect ?? "N/A"));
w.WriteLine("# hardware: " + (hardware is null ? "N/A" : string.Join("; ", new[] { hardware.CpuName, hardware.GpuName, hardware.GpuDriver, hardware.OsBuild, hardware.DisplayRes }.Where(static s => !string.IsNullOrEmpty(s)))));
w.WriteLine("# rt: " + row.RtFlag + " (" + (row.RtSource ?? "n/a") + "); pt: " + row.PtFlag + " (" + (row.PtSource ?? "n/a") + "); rr: " + row.RrFlag + " (" + (row.RrSource ?? "n/a") + ")");
@@ -110,6 +117,7 @@ public sealed class SessionExporter
}
w.WriteLine("# note: vram_mb is a held 1 Hz sample, not a per-frame measurement; qpc_ms is relative to the first present");
w.WriteLine("# note: one swapchain's presents, the stream the statistics are over; qpc_ms closes up every gap (frametime_ms 0)");
}
private static SegmentRow? SegmentAt(SegmentRow[] byFrame, uint frameIndex)
+546
View File
@@ -46,6 +46,14 @@ public static class Strings
nameof(Agent_State_Offline),
nameof(Agent_State_Starting),
nameof(App_Title),
nameof(Arch_AnyCpu),
nameof(Arch_AnyCpu32),
nameof(Arch_Arm),
nameof(Arch_Arm64),
nameof(Arch_Other),
nameof(Arch_Unknown),
nameof(Arch_X64),
nameof(Arch_X86),
nameof(Blocked_Directory_Format),
nameof(Blocked_Executable_Format),
nameof(Blocked_File_Format),
@@ -77,12 +85,20 @@ public static class Strings
nameof(Chart_Axis_Percentile),
nameof(Chart_Axis_Sensor),
nameof(Chart_Axis_Time),
nameof(Chart_Axis_TimeFromFirstFrame),
nameof(Chart_Axis_TimeFromStart),
nameof(Chart_Decimated_Format),
nameof(Chart_Note_GapsClosed_Format),
nameof(Chart_Note_NoApplicationFrames),
nameof(Chart_Note_OutsideRange_Format),
nameof(Chart_Note_PresentsTiming),
nameof(Chart_Series_AppFrames),
nameof(Chart_Series_Displayed),
nameof(Chart_Series_GpuLoad),
nameof(Chart_Series_GpuTemp),
nameof(Chart_Series_Native),
nameof(Chart_Series_Percentile),
nameof(Chart_Series_Presents),
nameof(Chart_Series_Stutter),
nameof(Chart_Series_StutterPso),
nameof(Chip_NA),
@@ -172,9 +188,74 @@ public static class Strings
nameof(EditGame_Saved),
nameof(EditGame_Title),
nameof(EditGame_Version),
nameof(End_AttachRefused),
nameof(End_ExecutableUnreadable),
nameof(End_KillSwitchEngaged),
nameof(End_LaunchCannotStart),
nameof(End_LaunchNoPresentationRuntime),
nameof(End_LaunchTargetExited),
nameof(End_PreScanCouldNotVerify),
nameof(End_RefusedByGuard),
nameof(End_RefusedConsentMissing),
nameof(End_RefusedHookNotEnabled),
nameof(End_RefusedKillSwitch),
nameof(End_RefusedPreviouslyBlocked),
nameof(End_Running),
nameof(End_SafetyUnhook),
nameof(End_StoppedByUser),
nameof(End_SupervisionFaulted),
nameof(End_SupervisionLost),
nameof(End_TargetAmbiguous),
nameof(End_TargetCannotBePinned),
nameof(End_TargetExited),
nameof(End_TargetNotRunning),
nameof(End_TargetUnreadable),
nameof(End_WriterNeverInstalledHooks),
nameof(End_WriterSelfDisabled),
nameof(End_WriterStoppedBlocklisted),
nameof(Exception_Finding_Format),
nameof(Exception_Lapse_ExecutableChanged),
nameof(Exception_Lapse_NewFinding),
nameof(Exception_Lapse_NoLongerEligible),
nameof(Exception_Lapse_OverlayStopped),
nameof(Exception_Lapse_SafetyUnhook),
nameof(Exception_Lapse_SessionCrashed),
nameof(Exception_Lapse_Withdrawn),
nameof(Exception_Lapsed_Format),
nameof(Exception_Result_Granted_Format),
nameof(Exception_Result_Refused_Format),
nameof(Exception_Result_Withdrawn_Format),
nameof(Exception_Sessions_Format),
nameof(Exception_State_Checking),
nameof(Exception_State_CouldNotVerify),
nameof(Exception_State_Eligible),
nameof(Exception_State_Granted_Format),
nameof(Exception_State_NotAsked),
nameof(Exception_State_NotUserMode_Format),
nameof(Exception_State_Refused_Format),
nameof(Exception_State_TooFew_Format),
nameof(Exe_DriveMissing_Format),
nameof(Exe_FileMissing_Format),
nameof(Exit_Code_Format),
nameof(Exit_Code1),
nameof(Exit_Crashed),
nameof(Exit_Crashed_Format),
nameof(Exit_CrashEvent),
nameof(Exit_Degraded),
nameof(Exit_EndedNormally),
nameof(Exit_Ex_AccessViolation),
nameof(Exit_Ex_BadImage),
nameof(Exit_Ex_Breakpoint),
nameof(Exit_Ex_Clr),
nameof(Exit_Ex_Cpp),
nameof(Exit_Ex_DllInit),
nameof(Exit_Ex_DllNotFound),
nameof(Exit_Ex_FailFast),
nameof(Exit_Ex_HeapCorruption),
nameof(Exit_Ex_InPageError),
nameof(Exit_Ex_StackOverflow),
nameof(Exit_Interrupted),
nameof(Exit_Line_Format),
nameof(Exit_Normal),
nameof(Exit_UnhookedSafety),
nameof(Export_NoSelection_Body),
@@ -248,6 +329,7 @@ public static class Strings
nameof(Fps_Fg_Format),
nameof(Fps_Fg_Identified_Format),
nameof(Fps_Fg_Identified_Tooltip_Format),
nameof(Fps_Fg_Steady_Format),
nameof(Fps_Fg_Steady_Tooltip_Format),
nameof(Fps_Native_Tooltip),
nameof(Fps_None_Tooltip),
@@ -256,7 +338,25 @@ public static class Strings
nameof(GameDetail_AntiCheat_Header),
nameof(GameDetail_Back),
nameof(GameDetail_ChangeExe),
nameof(GameDetail_Details_Architecture),
nameof(GameDetail_Details_Engine),
nameof(GameDetail_Details_FileVersion),
nameof(GameDetail_Details_Header),
nameof(GameDetail_Details_Libraries),
nameof(GameDetail_Details_Library_Format),
nameof(GameDetail_Details_LibraryNoVersion_Format),
nameof(GameDetail_Details_NoLibraries),
nameof(GameDetail_Details_NotRead),
nameof(GameDetail_Details_NvidiaOverride),
nameof(GameDetail_Details_ProductVersion),
nameof(GameDetail_Details_Store),
nameof(GameDetail_Details_Version),
nameof(GameDetail_Edit),
nameof(GameDetail_Exception_Grant),
nameof(GameDetail_Exception_Granted_Format),
nameof(GameDetail_Exception_Header),
nameof(GameDetail_Exception_Suspended),
nameof(GameDetail_Exception_Withdraw),
nameof(GameDetail_ExeMissing),
nameof(GameDetail_Hooking_Body),
nameof(GameDetail_Hooking_Busy),
@@ -289,6 +389,7 @@ public static class Strings
nameof(GameDetail_Tab_Trend),
nameof(Games_Add),
nameof(Games_Card_AntiCheat),
nameof(Games_Card_Exception),
nameof(Games_Card_HookOff),
nameof(Games_Card_HookOn),
nameof(Games_Card_LastPlayed_Format),
@@ -304,6 +405,28 @@ public static class Strings
nameof(Games_Sort_LastPlayed),
nameof(Games_Sort_Name),
nameof(Games_Sort_Playtime),
nameof(Guard_ConsentMissing),
nameof(Guard_DriverScanFailed),
nameof(Guard_HookNotEnabled),
nameof(Guard_InjectionFailed),
nameof(Guard_LaunchNoPresentationRuntime),
nameof(Guard_LaunchTargetExited),
nameof(Guard_ModuleScanFailed),
nameof(Guard_Other_Format),
nameof(Guard_PayloadNotOurs),
nameof(Guard_PreScanFailed),
nameof(Guard_PreviouslyBlocked),
nameof(Guard_ProcessTreeUnavailable),
nameof(Guard_ProcessUnreadable),
nameof(Guard_Refused_Format),
nameof(Guard_RulesIncomplete),
nameof(Guard_RulesMalformed),
nameof(Guard_RulesUnreadable),
nameof(Guard_ServiceQueryFailed),
nameof(Guard_SuspiciousUnsigned),
nameof(Guard_TargetIsVulkanLayered),
nameof(Guard_TargetIsWow64),
nameof(Hooking_NotX64_Format),
nameof(Import_Add),
nameof(Import_Column_Exe),
nameof(Import_Column_Name),
@@ -327,6 +450,13 @@ public static class Strings
nameof(Latency_P95),
nameof(Latency_Series),
nameof(Latency_Stats_Format),
nameof(Launch_Error_193),
nameof(Launch_Error_2),
nameof(Launch_Error_3),
nameof(Launch_Error_5),
nameof(Launch_Error_740),
nameof(Launch_Error_Format),
nameof(Launch_Failed_Format),
nameof(Logs_Bundle_Exported_Format),
nameof(Logs_Bundle_Failed_Format),
nameof(Logs_Empty),
@@ -405,6 +535,35 @@ public static class Strings
nameof(Notice_Refused_Recording),
nameof(Notice_Refused_Title_Format),
nameof(Notice_Unhooked_Title),
nameof(Nv_Details_Format),
nameof(Nv_Driver_DllSelected),
nameof(Nv_Driver_Format),
nameof(Nv_Driver_Ratio_Format),
nameof(Nv_DynamicTarget_Auto),
nameof(Nv_DynamicTarget_Format),
nameof(Nv_FgMode_Auto),
nameof(Nv_FgMode_Dynamic),
nameof(Nv_FgMode_Off),
nameof(Nv_FgMode_On),
nameof(Nv_Mfg_Format),
nameof(Nv_Mode_Balanced),
nameof(Nv_Mode_Custom),
nameof(Nv_Mode_Custom_Format),
nameof(Nv_Mode_Dlaa),
nameof(Nv_Mode_Performance),
nameof(Nv_Mode_Quality),
nameof(Nv_Mode_UltraPerformance),
nameof(Nv_Override_Fg),
nameof(Nv_Override_None),
nameof(Nv_Override_Rr),
nameof(Nv_Override_Sl),
nameof(Nv_Override_Sr),
nameof(Nv_Preset_Default),
nameof(Nv_Preset_Format),
nameof(Nv_Preset_Latest),
nameof(Nv_Profile_Format),
nameof(Nv_Profile_Global_Format),
nameof(Nv_SmoothMotion),
nameof(Override_Apply),
nameof(Override_Body),
nameof(Override_Default),
@@ -420,6 +579,7 @@ public static class Strings
nameof(Rules_Update_NoAgent),
nameof(Rules_Update_Title),
nameof(Sensors_Axis_Mb),
nameof(Sensors_Axis_Watts),
nameof(Sensors_Empty),
nameof(Sensors_Series_CpuLoad),
nameof(Sensors_Series_CpuTemp),
@@ -432,6 +592,7 @@ public static class Strings
nameof(Sensors_Series_VramProcess),
nameof(Sensors_Temps_Header),
nameof(Sensors_Vram_Header),
nameof(Session_UnderException_Format),
nameof(Sessions_Col_Api),
nameof(Sessions_Col_Date),
nameof(Sessions_Col_Displayed),
@@ -467,6 +628,17 @@ public static class Strings
nameof(Settings_Capture_Header),
nameof(Settings_Channel_Beta),
nameof(Settings_Channel_Stable),
nameof(Settings_Exceptions_Body),
nameof(Settings_Exceptions_Checking),
nameof(Settings_Exceptions_Empty),
nameof(Settings_Exceptions_Grant),
nameof(Settings_Exceptions_Header),
nameof(Settings_Exceptions_Label),
nameof(Settings_Exceptions_Refresh),
nameof(Settings_Exceptions_Suspended),
nameof(Settings_Exceptions_Withdraw),
nameof(Settings_FpsDecimals_Body),
nameof(Settings_FpsDecimals_Label),
nameof(Settings_Header),
nameof(Settings_HideAntiCheatHooking_Body),
nameof(Settings_HideAntiCheatHooking_Label),
@@ -524,6 +696,9 @@ public static class Strings
nameof(Settings_Window_Header),
nameof(StartupFailed_Body_Format),
nameof(StartupFailed_Title),
nameof(Store_Epic_Format),
nameof(Store_Gog_Format),
nameof(Store_Steam_Format),
nameof(Summary_Annotations_Header),
nameof(Summary_Crash_Body),
nameof(Summary_Crash_Title),
@@ -535,6 +710,8 @@ public static class Strings
nameof(Summary_Export_Tier2),
nameof(Summary_Exported_Format),
nameof(Summary_Frametime_Header),
nameof(Summary_Libraries_Format),
nameof(Summary_Library_Differs_Format),
nameof(Summary_Line_Format),
nameof(Summary_Lows_Presented),
nameof(Summary_Notes_Placeholder),
@@ -583,6 +760,7 @@ public static class Strings
nameof(Tier_Dash_Tooltip),
nameof(Tier_Hooked),
nameof(Tier_Hooked_Tooltip),
nameof(Tier_HookedException),
nameof(Tier_NA_Tooltip),
nameof(Tier_NotHooked),
nameof(Tier_NotHooked_Tooltip),
@@ -606,6 +784,7 @@ public static class Strings
nameof(Trend_Change_GpuDriver),
nameof(Trend_Change_Os),
nameof(Trend_Empty),
nameof(Trend_Empty_Format),
nameof(Trend_Excluded_Format),
nameof(Trend_IncludeMidSession),
nameof(Trend_Metric_Average),
@@ -619,8 +798,11 @@ public static class Strings
nameof(Trend_Metric_MaxCpuTemp),
nameof(Trend_Metric_MaxGpuTemp),
nameof(Trend_Metric_MaxVramProcess),
nameof(Trend_Metric_NativeFps),
nameof(Trend_Metric_P01Low),
nameof(Trend_Metric_P1Low),
nameof(Trend_Metric_PresentedFps),
nameof(Trend_Partial_Note),
nameof(Uninstall_DataFolder_Body),
nameof(Uninstall_DataFolder_Title),
nameof(Update_AgentStillRunning),
@@ -694,6 +876,22 @@ public static class Strings
public static string App_Title => ResourceManager.GetString(nameof(App_Title), Culture) ?? nameof(App_Title);
public static string Arch_AnyCpu => ResourceManager.GetString(nameof(Arch_AnyCpu), Culture) ?? nameof(Arch_AnyCpu);
public static string Arch_AnyCpu32 => ResourceManager.GetString(nameof(Arch_AnyCpu32), Culture) ?? nameof(Arch_AnyCpu32);
public static string Arch_Arm => ResourceManager.GetString(nameof(Arch_Arm), Culture) ?? nameof(Arch_Arm);
public static string Arch_Arm64 => ResourceManager.GetString(nameof(Arch_Arm64), Culture) ?? nameof(Arch_Arm64);
public static string Arch_Other => ResourceManager.GetString(nameof(Arch_Other), Culture) ?? nameof(Arch_Other);
public static string Arch_Unknown => ResourceManager.GetString(nameof(Arch_Unknown), Culture) ?? nameof(Arch_Unknown);
public static string Arch_X64 => ResourceManager.GetString(nameof(Arch_X64), Culture) ?? nameof(Arch_X64);
public static string Arch_X86 => ResourceManager.GetString(nameof(Arch_X86), Culture) ?? nameof(Arch_X86);
public static string Blocked_Directory_Format => ResourceManager.GetString(nameof(Blocked_Directory_Format), Culture) ?? nameof(Blocked_Directory_Format);
public static string Blocked_Executable_Format => ResourceManager.GetString(nameof(Blocked_Executable_Format), Culture) ?? nameof(Blocked_Executable_Format);
@@ -756,8 +954,22 @@ public static class Strings
public static string Chart_Axis_Time => ResourceManager.GetString(nameof(Chart_Axis_Time), Culture) ?? nameof(Chart_Axis_Time);
public static string Chart_Axis_TimeFromFirstFrame => ResourceManager.GetString(nameof(Chart_Axis_TimeFromFirstFrame), Culture) ?? nameof(Chart_Axis_TimeFromFirstFrame);
public static string Chart_Axis_TimeFromStart => ResourceManager.GetString(nameof(Chart_Axis_TimeFromStart), Culture) ?? nameof(Chart_Axis_TimeFromStart);
public static string Chart_Decimated_Format => ResourceManager.GetString(nameof(Chart_Decimated_Format), Culture) ?? nameof(Chart_Decimated_Format);
public static string Chart_Note_GapsClosed_Format => ResourceManager.GetString(nameof(Chart_Note_GapsClosed_Format), Culture) ?? nameof(Chart_Note_GapsClosed_Format);
public static string Chart_Note_NoApplicationFrames => ResourceManager.GetString(nameof(Chart_Note_NoApplicationFrames), Culture) ?? nameof(Chart_Note_NoApplicationFrames);
public static string Chart_Note_OutsideRange_Format => ResourceManager.GetString(nameof(Chart_Note_OutsideRange_Format), Culture) ?? nameof(Chart_Note_OutsideRange_Format);
public static string Chart_Note_PresentsTiming => ResourceManager.GetString(nameof(Chart_Note_PresentsTiming), Culture) ?? nameof(Chart_Note_PresentsTiming);
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);
public static string Chart_Series_GpuLoad => ResourceManager.GetString(nameof(Chart_Series_GpuLoad), Culture) ?? nameof(Chart_Series_GpuLoad);
@@ -768,6 +980,8 @@ public static class Strings
public static string Chart_Series_Percentile => ResourceManager.GetString(nameof(Chart_Series_Percentile), Culture) ?? nameof(Chart_Series_Percentile);
public static string Chart_Series_Presents => ResourceManager.GetString(nameof(Chart_Series_Presents), Culture) ?? nameof(Chart_Series_Presents);
public static string Chart_Series_Stutter => ResourceManager.GetString(nameof(Chart_Series_Stutter), Culture) ?? nameof(Chart_Series_Stutter);
public static string Chart_Series_StutterPso => ResourceManager.GetString(nameof(Chart_Series_StutterPso), Culture) ?? nameof(Chart_Series_StutterPso);
@@ -946,12 +1160,142 @@ public static class Strings
public static string EditGame_Version => ResourceManager.GetString(nameof(EditGame_Version), Culture) ?? nameof(EditGame_Version);
public static string End_AttachRefused => ResourceManager.GetString(nameof(End_AttachRefused), Culture) ?? nameof(End_AttachRefused);
public static string End_ExecutableUnreadable => ResourceManager.GetString(nameof(End_ExecutableUnreadable), Culture) ?? nameof(End_ExecutableUnreadable);
public static string End_KillSwitchEngaged => ResourceManager.GetString(nameof(End_KillSwitchEngaged), Culture) ?? nameof(End_KillSwitchEngaged);
public static string End_LaunchCannotStart => ResourceManager.GetString(nameof(End_LaunchCannotStart), Culture) ?? nameof(End_LaunchCannotStart);
public static string End_LaunchNoPresentationRuntime => ResourceManager.GetString(nameof(End_LaunchNoPresentationRuntime), Culture) ?? nameof(End_LaunchNoPresentationRuntime);
public static string End_LaunchTargetExited => ResourceManager.GetString(nameof(End_LaunchTargetExited), Culture) ?? nameof(End_LaunchTargetExited);
public static string End_PreScanCouldNotVerify => ResourceManager.GetString(nameof(End_PreScanCouldNotVerify), Culture) ?? nameof(End_PreScanCouldNotVerify);
public static string End_RefusedByGuard => ResourceManager.GetString(nameof(End_RefusedByGuard), Culture) ?? nameof(End_RefusedByGuard);
public static string End_RefusedConsentMissing => ResourceManager.GetString(nameof(End_RefusedConsentMissing), Culture) ?? nameof(End_RefusedConsentMissing);
public static string End_RefusedHookNotEnabled => ResourceManager.GetString(nameof(End_RefusedHookNotEnabled), Culture) ?? nameof(End_RefusedHookNotEnabled);
public static string End_RefusedKillSwitch => ResourceManager.GetString(nameof(End_RefusedKillSwitch), Culture) ?? nameof(End_RefusedKillSwitch);
public static string End_RefusedPreviouslyBlocked => ResourceManager.GetString(nameof(End_RefusedPreviouslyBlocked), Culture) ?? nameof(End_RefusedPreviouslyBlocked);
public static string End_Running => ResourceManager.GetString(nameof(End_Running), Culture) ?? nameof(End_Running);
public static string End_SafetyUnhook => ResourceManager.GetString(nameof(End_SafetyUnhook), Culture) ?? nameof(End_SafetyUnhook);
public static string End_StoppedByUser => ResourceManager.GetString(nameof(End_StoppedByUser), Culture) ?? nameof(End_StoppedByUser);
public static string End_SupervisionFaulted => ResourceManager.GetString(nameof(End_SupervisionFaulted), Culture) ?? nameof(End_SupervisionFaulted);
public static string End_SupervisionLost => ResourceManager.GetString(nameof(End_SupervisionLost), Culture) ?? nameof(End_SupervisionLost);
public static string End_TargetAmbiguous => ResourceManager.GetString(nameof(End_TargetAmbiguous), Culture) ?? nameof(End_TargetAmbiguous);
public static string End_TargetCannotBePinned => ResourceManager.GetString(nameof(End_TargetCannotBePinned), Culture) ?? nameof(End_TargetCannotBePinned);
public static string End_TargetExited => ResourceManager.GetString(nameof(End_TargetExited), Culture) ?? nameof(End_TargetExited);
public static string End_TargetNotRunning => ResourceManager.GetString(nameof(End_TargetNotRunning), Culture) ?? nameof(End_TargetNotRunning);
public static string End_TargetUnreadable => ResourceManager.GetString(nameof(End_TargetUnreadable), Culture) ?? nameof(End_TargetUnreadable);
public static string End_WriterNeverInstalledHooks => ResourceManager.GetString(nameof(End_WriterNeverInstalledHooks), Culture) ?? nameof(End_WriterNeverInstalledHooks);
public static string End_WriterSelfDisabled => ResourceManager.GetString(nameof(End_WriterSelfDisabled), Culture) ?? nameof(End_WriterSelfDisabled);
public static string End_WriterStoppedBlocklisted => ResourceManager.GetString(nameof(End_WriterStoppedBlocklisted), Culture) ?? nameof(End_WriterStoppedBlocklisted);
public static string Exception_Finding_Format => ResourceManager.GetString(nameof(Exception_Finding_Format), Culture) ?? nameof(Exception_Finding_Format);
public static string Exception_Lapse_ExecutableChanged => ResourceManager.GetString(nameof(Exception_Lapse_ExecutableChanged), Culture) ?? nameof(Exception_Lapse_ExecutableChanged);
public static string Exception_Lapse_NewFinding => ResourceManager.GetString(nameof(Exception_Lapse_NewFinding), Culture) ?? nameof(Exception_Lapse_NewFinding);
public static string Exception_Lapse_NoLongerEligible => ResourceManager.GetString(nameof(Exception_Lapse_NoLongerEligible), Culture) ?? nameof(Exception_Lapse_NoLongerEligible);
public static string Exception_Lapse_OverlayStopped => ResourceManager.GetString(nameof(Exception_Lapse_OverlayStopped), Culture) ?? nameof(Exception_Lapse_OverlayStopped);
public static string Exception_Lapse_SafetyUnhook => ResourceManager.GetString(nameof(Exception_Lapse_SafetyUnhook), Culture) ?? nameof(Exception_Lapse_SafetyUnhook);
public static string Exception_Lapse_SessionCrashed => ResourceManager.GetString(nameof(Exception_Lapse_SessionCrashed), Culture) ?? nameof(Exception_Lapse_SessionCrashed);
public static string Exception_Lapse_Withdrawn => ResourceManager.GetString(nameof(Exception_Lapse_Withdrawn), Culture) ?? nameof(Exception_Lapse_Withdrawn);
public static string Exception_Lapsed_Format => ResourceManager.GetString(nameof(Exception_Lapsed_Format), Culture) ?? nameof(Exception_Lapsed_Format);
public static string Exception_Result_Granted_Format => ResourceManager.GetString(nameof(Exception_Result_Granted_Format), Culture) ?? nameof(Exception_Result_Granted_Format);
public static string Exception_Result_Refused_Format => ResourceManager.GetString(nameof(Exception_Result_Refused_Format), Culture) ?? nameof(Exception_Result_Refused_Format);
public static string Exception_Result_Withdrawn_Format => ResourceManager.GetString(nameof(Exception_Result_Withdrawn_Format), Culture) ?? nameof(Exception_Result_Withdrawn_Format);
public static string Exception_Sessions_Format => ResourceManager.GetString(nameof(Exception_Sessions_Format), Culture) ?? nameof(Exception_Sessions_Format);
public static string Exception_State_Checking => ResourceManager.GetString(nameof(Exception_State_Checking), Culture) ?? nameof(Exception_State_Checking);
public static string Exception_State_CouldNotVerify => ResourceManager.GetString(nameof(Exception_State_CouldNotVerify), Culture) ?? nameof(Exception_State_CouldNotVerify);
public static string Exception_State_Eligible => ResourceManager.GetString(nameof(Exception_State_Eligible), Culture) ?? nameof(Exception_State_Eligible);
public static string Exception_State_Granted_Format => ResourceManager.GetString(nameof(Exception_State_Granted_Format), Culture) ?? nameof(Exception_State_Granted_Format);
public static string Exception_State_NotAsked => ResourceManager.GetString(nameof(Exception_State_NotAsked), Culture) ?? nameof(Exception_State_NotAsked);
public static string Exception_State_NotUserMode_Format => ResourceManager.GetString(nameof(Exception_State_NotUserMode_Format), Culture) ?? nameof(Exception_State_NotUserMode_Format);
public static string Exception_State_Refused_Format => ResourceManager.GetString(nameof(Exception_State_Refused_Format), Culture) ?? nameof(Exception_State_Refused_Format);
public static string Exception_State_TooFew_Format => ResourceManager.GetString(nameof(Exception_State_TooFew_Format), Culture) ?? nameof(Exception_State_TooFew_Format);
public static string Exe_DriveMissing_Format => ResourceManager.GetString(nameof(Exe_DriveMissing_Format), Culture) ?? nameof(Exe_DriveMissing_Format);
public static string Exe_FileMissing_Format => ResourceManager.GetString(nameof(Exe_FileMissing_Format), Culture) ?? nameof(Exe_FileMissing_Format);
public static string Exit_Code_Format => ResourceManager.GetString(nameof(Exit_Code_Format), Culture) ?? nameof(Exit_Code_Format);
public static string Exit_Code1 => ResourceManager.GetString(nameof(Exit_Code1), Culture) ?? nameof(Exit_Code1);
public static string Exit_Crashed => ResourceManager.GetString(nameof(Exit_Crashed), Culture) ?? nameof(Exit_Crashed);
public static string Exit_Crashed_Format => ResourceManager.GetString(nameof(Exit_Crashed_Format), Culture) ?? nameof(Exit_Crashed_Format);
public static string Exit_CrashEvent => ResourceManager.GetString(nameof(Exit_CrashEvent), Culture) ?? nameof(Exit_CrashEvent);
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);
public static string Exit_Ex_AccessViolation => ResourceManager.GetString(nameof(Exit_Ex_AccessViolation), Culture) ?? nameof(Exit_Ex_AccessViolation);
public static string Exit_Ex_BadImage => ResourceManager.GetString(nameof(Exit_Ex_BadImage), Culture) ?? nameof(Exit_Ex_BadImage);
public static string Exit_Ex_Breakpoint => ResourceManager.GetString(nameof(Exit_Ex_Breakpoint), Culture) ?? nameof(Exit_Ex_Breakpoint);
public static string Exit_Ex_Clr => ResourceManager.GetString(nameof(Exit_Ex_Clr), Culture) ?? nameof(Exit_Ex_Clr);
public static string Exit_Ex_Cpp => ResourceManager.GetString(nameof(Exit_Ex_Cpp), Culture) ?? nameof(Exit_Ex_Cpp);
public static string Exit_Ex_DllInit => ResourceManager.GetString(nameof(Exit_Ex_DllInit), Culture) ?? nameof(Exit_Ex_DllInit);
public static string Exit_Ex_DllNotFound => ResourceManager.GetString(nameof(Exit_Ex_DllNotFound), Culture) ?? nameof(Exit_Ex_DllNotFound);
public static string Exit_Ex_FailFast => ResourceManager.GetString(nameof(Exit_Ex_FailFast), Culture) ?? nameof(Exit_Ex_FailFast);
public static string Exit_Ex_HeapCorruption => ResourceManager.GetString(nameof(Exit_Ex_HeapCorruption), Culture) ?? nameof(Exit_Ex_HeapCorruption);
public static string Exit_Ex_InPageError => ResourceManager.GetString(nameof(Exit_Ex_InPageError), Culture) ?? nameof(Exit_Ex_InPageError);
public static string Exit_Ex_StackOverflow => ResourceManager.GetString(nameof(Exit_Ex_StackOverflow), Culture) ?? nameof(Exit_Ex_StackOverflow);
public static string Exit_Interrupted => ResourceManager.GetString(nameof(Exit_Interrupted), Culture) ?? nameof(Exit_Interrupted);
public static string Exit_Line_Format => ResourceManager.GetString(nameof(Exit_Line_Format), Culture) ?? nameof(Exit_Line_Format);
public static string Exit_Normal => ResourceManager.GetString(nameof(Exit_Normal), Culture) ?? nameof(Exit_Normal);
public static string Exit_UnhookedSafety => ResourceManager.GetString(nameof(Exit_UnhookedSafety), Culture) ?? nameof(Exit_UnhookedSafety);
@@ -1098,6 +1442,8 @@ public static class Strings
public static string Fps_Fg_Identified_Tooltip_Format => ResourceManager.GetString(nameof(Fps_Fg_Identified_Tooltip_Format), Culture) ?? nameof(Fps_Fg_Identified_Tooltip_Format);
public static string Fps_Fg_Steady_Format => ResourceManager.GetString(nameof(Fps_Fg_Steady_Format), Culture) ?? nameof(Fps_Fg_Steady_Format);
public static string Fps_Fg_Steady_Tooltip_Format => ResourceManager.GetString(nameof(Fps_Fg_Steady_Tooltip_Format), Culture) ?? nameof(Fps_Fg_Steady_Tooltip_Format);
public static string Fps_Native_Tooltip => ResourceManager.GetString(nameof(Fps_Native_Tooltip), Culture) ?? nameof(Fps_Native_Tooltip);
@@ -1114,8 +1460,44 @@ public static class Strings
public static string GameDetail_ChangeExe => ResourceManager.GetString(nameof(GameDetail_ChangeExe), Culture) ?? nameof(GameDetail_ChangeExe);
public static string GameDetail_Details_Architecture => ResourceManager.GetString(nameof(GameDetail_Details_Architecture), Culture) ?? nameof(GameDetail_Details_Architecture);
public static string GameDetail_Details_Engine => ResourceManager.GetString(nameof(GameDetail_Details_Engine), Culture) ?? nameof(GameDetail_Details_Engine);
public static string GameDetail_Details_FileVersion => ResourceManager.GetString(nameof(GameDetail_Details_FileVersion), Culture) ?? nameof(GameDetail_Details_FileVersion);
public static string GameDetail_Details_Header => ResourceManager.GetString(nameof(GameDetail_Details_Header), Culture) ?? nameof(GameDetail_Details_Header);
public static string GameDetail_Details_Libraries => ResourceManager.GetString(nameof(GameDetail_Details_Libraries), Culture) ?? nameof(GameDetail_Details_Libraries);
public static string GameDetail_Details_Library_Format => ResourceManager.GetString(nameof(GameDetail_Details_Library_Format), Culture) ?? nameof(GameDetail_Details_Library_Format);
public static string GameDetail_Details_LibraryNoVersion_Format => ResourceManager.GetString(nameof(GameDetail_Details_LibraryNoVersion_Format), Culture) ?? nameof(GameDetail_Details_LibraryNoVersion_Format);
public static string GameDetail_Details_NoLibraries => ResourceManager.GetString(nameof(GameDetail_Details_NoLibraries), Culture) ?? nameof(GameDetail_Details_NoLibraries);
public static string GameDetail_Details_NotRead => ResourceManager.GetString(nameof(GameDetail_Details_NotRead), Culture) ?? nameof(GameDetail_Details_NotRead);
public static string GameDetail_Details_NvidiaOverride => ResourceManager.GetString(nameof(GameDetail_Details_NvidiaOverride), Culture) ?? nameof(GameDetail_Details_NvidiaOverride);
public static string GameDetail_Details_ProductVersion => ResourceManager.GetString(nameof(GameDetail_Details_ProductVersion), Culture) ?? nameof(GameDetail_Details_ProductVersion);
public static string GameDetail_Details_Store => ResourceManager.GetString(nameof(GameDetail_Details_Store), Culture) ?? nameof(GameDetail_Details_Store);
public static string GameDetail_Details_Version => ResourceManager.GetString(nameof(GameDetail_Details_Version), Culture) ?? nameof(GameDetail_Details_Version);
public static string GameDetail_Edit => ResourceManager.GetString(nameof(GameDetail_Edit), Culture) ?? nameof(GameDetail_Edit);
public static string GameDetail_Exception_Grant => ResourceManager.GetString(nameof(GameDetail_Exception_Grant), Culture) ?? nameof(GameDetail_Exception_Grant);
public static string GameDetail_Exception_Granted_Format => ResourceManager.GetString(nameof(GameDetail_Exception_Granted_Format), Culture) ?? nameof(GameDetail_Exception_Granted_Format);
public static string GameDetail_Exception_Header => ResourceManager.GetString(nameof(GameDetail_Exception_Header), Culture) ?? nameof(GameDetail_Exception_Header);
public static string GameDetail_Exception_Suspended => ResourceManager.GetString(nameof(GameDetail_Exception_Suspended), Culture) ?? nameof(GameDetail_Exception_Suspended);
public static string GameDetail_Exception_Withdraw => ResourceManager.GetString(nameof(GameDetail_Exception_Withdraw), Culture) ?? nameof(GameDetail_Exception_Withdraw);
public static string GameDetail_ExeMissing => ResourceManager.GetString(nameof(GameDetail_ExeMissing), Culture) ?? nameof(GameDetail_ExeMissing);
public static string GameDetail_Hooking_Body => ResourceManager.GetString(nameof(GameDetail_Hooking_Body), Culture) ?? nameof(GameDetail_Hooking_Body);
@@ -1180,6 +1562,8 @@ public static class Strings
public static string Games_Card_AntiCheat => ResourceManager.GetString(nameof(Games_Card_AntiCheat), Culture) ?? nameof(Games_Card_AntiCheat);
public static string Games_Card_Exception => ResourceManager.GetString(nameof(Games_Card_Exception), Culture) ?? nameof(Games_Card_Exception);
public static string Games_Card_HookOff => ResourceManager.GetString(nameof(Games_Card_HookOff), Culture) ?? nameof(Games_Card_HookOff);
public static string Games_Card_HookOn => ResourceManager.GetString(nameof(Games_Card_HookOn), Culture) ?? nameof(Games_Card_HookOn);
@@ -1210,6 +1594,50 @@ public static class Strings
public static string Games_Sort_Playtime => ResourceManager.GetString(nameof(Games_Sort_Playtime), Culture) ?? nameof(Games_Sort_Playtime);
public static string Guard_ConsentMissing => ResourceManager.GetString(nameof(Guard_ConsentMissing), Culture) ?? nameof(Guard_ConsentMissing);
public static string Guard_DriverScanFailed => ResourceManager.GetString(nameof(Guard_DriverScanFailed), Culture) ?? nameof(Guard_DriverScanFailed);
public static string Guard_HookNotEnabled => ResourceManager.GetString(nameof(Guard_HookNotEnabled), Culture) ?? nameof(Guard_HookNotEnabled);
public static string Guard_InjectionFailed => ResourceManager.GetString(nameof(Guard_InjectionFailed), Culture) ?? nameof(Guard_InjectionFailed);
public static string Guard_LaunchNoPresentationRuntime => ResourceManager.GetString(nameof(Guard_LaunchNoPresentationRuntime), Culture) ?? nameof(Guard_LaunchNoPresentationRuntime);
public static string Guard_LaunchTargetExited => ResourceManager.GetString(nameof(Guard_LaunchTargetExited), Culture) ?? nameof(Guard_LaunchTargetExited);
public static string Guard_ModuleScanFailed => ResourceManager.GetString(nameof(Guard_ModuleScanFailed), Culture) ?? nameof(Guard_ModuleScanFailed);
public static string Guard_Other_Format => ResourceManager.GetString(nameof(Guard_Other_Format), Culture) ?? nameof(Guard_Other_Format);
public static string Guard_PayloadNotOurs => ResourceManager.GetString(nameof(Guard_PayloadNotOurs), Culture) ?? nameof(Guard_PayloadNotOurs);
public static string Guard_PreScanFailed => ResourceManager.GetString(nameof(Guard_PreScanFailed), Culture) ?? nameof(Guard_PreScanFailed);
public static string Guard_PreviouslyBlocked => ResourceManager.GetString(nameof(Guard_PreviouslyBlocked), Culture) ?? nameof(Guard_PreviouslyBlocked);
public static string Guard_ProcessTreeUnavailable => ResourceManager.GetString(nameof(Guard_ProcessTreeUnavailable), Culture) ?? nameof(Guard_ProcessTreeUnavailable);
public static string Guard_ProcessUnreadable => ResourceManager.GetString(nameof(Guard_ProcessUnreadable), Culture) ?? nameof(Guard_ProcessUnreadable);
public static string Guard_Refused_Format => ResourceManager.GetString(nameof(Guard_Refused_Format), Culture) ?? nameof(Guard_Refused_Format);
public static string Guard_RulesIncomplete => ResourceManager.GetString(nameof(Guard_RulesIncomplete), Culture) ?? nameof(Guard_RulesIncomplete);
public static string Guard_RulesMalformed => ResourceManager.GetString(nameof(Guard_RulesMalformed), Culture) ?? nameof(Guard_RulesMalformed);
public static string Guard_RulesUnreadable => ResourceManager.GetString(nameof(Guard_RulesUnreadable), Culture) ?? nameof(Guard_RulesUnreadable);
public static string Guard_ServiceQueryFailed => ResourceManager.GetString(nameof(Guard_ServiceQueryFailed), Culture) ?? nameof(Guard_ServiceQueryFailed);
public static string Guard_SuspiciousUnsigned => ResourceManager.GetString(nameof(Guard_SuspiciousUnsigned), Culture) ?? nameof(Guard_SuspiciousUnsigned);
public static string Guard_TargetIsVulkanLayered => ResourceManager.GetString(nameof(Guard_TargetIsVulkanLayered), Culture) ?? nameof(Guard_TargetIsVulkanLayered);
public static string Guard_TargetIsWow64 => ResourceManager.GetString(nameof(Guard_TargetIsWow64), Culture) ?? nameof(Guard_TargetIsWow64);
public static string Hooking_NotX64_Format => ResourceManager.GetString(nameof(Hooking_NotX64_Format), Culture) ?? nameof(Hooking_NotX64_Format);
public static string Import_Add => ResourceManager.GetString(nameof(Import_Add), Culture) ?? nameof(Import_Add);
public static string Import_Column_Exe => ResourceManager.GetString(nameof(Import_Column_Exe), Culture) ?? nameof(Import_Column_Exe);
@@ -1256,6 +1684,20 @@ public static class Strings
public static string Latency_Stats_Format => ResourceManager.GetString(nameof(Latency_Stats_Format), Culture) ?? nameof(Latency_Stats_Format);
public static string Launch_Error_193 => ResourceManager.GetString(nameof(Launch_Error_193), Culture) ?? nameof(Launch_Error_193);
public static string Launch_Error_2 => ResourceManager.GetString(nameof(Launch_Error_2), Culture) ?? nameof(Launch_Error_2);
public static string Launch_Error_3 => ResourceManager.GetString(nameof(Launch_Error_3), Culture) ?? nameof(Launch_Error_3);
public static string Launch_Error_5 => ResourceManager.GetString(nameof(Launch_Error_5), Culture) ?? nameof(Launch_Error_5);
public static string Launch_Error_740 => ResourceManager.GetString(nameof(Launch_Error_740), Culture) ?? nameof(Launch_Error_740);
public static string Launch_Error_Format => ResourceManager.GetString(nameof(Launch_Error_Format), Culture) ?? nameof(Launch_Error_Format);
public static string Launch_Failed_Format => ResourceManager.GetString(nameof(Launch_Failed_Format), Culture) ?? nameof(Launch_Failed_Format);
public static string Logs_Bundle_Exported_Format => ResourceManager.GetString(nameof(Logs_Bundle_Exported_Format), Culture) ?? nameof(Logs_Bundle_Exported_Format);
public static string Logs_Bundle_Failed_Format => ResourceManager.GetString(nameof(Logs_Bundle_Failed_Format), Culture) ?? nameof(Logs_Bundle_Failed_Format);
@@ -1412,6 +1854,64 @@ public static class Strings
public static string Notice_Unhooked_Title => ResourceManager.GetString(nameof(Notice_Unhooked_Title), Culture) ?? nameof(Notice_Unhooked_Title);
public static string Nv_Details_Format => ResourceManager.GetString(nameof(Nv_Details_Format), Culture) ?? nameof(Nv_Details_Format);
public static string Nv_Driver_DllSelected => ResourceManager.GetString(nameof(Nv_Driver_DllSelected), Culture) ?? nameof(Nv_Driver_DllSelected);
public static string Nv_Driver_Format => ResourceManager.GetString(nameof(Nv_Driver_Format), Culture) ?? nameof(Nv_Driver_Format);
public static string Nv_Driver_Ratio_Format => ResourceManager.GetString(nameof(Nv_Driver_Ratio_Format), Culture) ?? nameof(Nv_Driver_Ratio_Format);
public static string Nv_DynamicTarget_Auto => ResourceManager.GetString(nameof(Nv_DynamicTarget_Auto), Culture) ?? nameof(Nv_DynamicTarget_Auto);
public static string Nv_DynamicTarget_Format => ResourceManager.GetString(nameof(Nv_DynamicTarget_Format), Culture) ?? nameof(Nv_DynamicTarget_Format);
public static string Nv_FgMode_Auto => ResourceManager.GetString(nameof(Nv_FgMode_Auto), Culture) ?? nameof(Nv_FgMode_Auto);
public static string Nv_FgMode_Dynamic => ResourceManager.GetString(nameof(Nv_FgMode_Dynamic), Culture) ?? nameof(Nv_FgMode_Dynamic);
public static string Nv_FgMode_Off => ResourceManager.GetString(nameof(Nv_FgMode_Off), Culture) ?? nameof(Nv_FgMode_Off);
public static string Nv_FgMode_On => ResourceManager.GetString(nameof(Nv_FgMode_On), Culture) ?? nameof(Nv_FgMode_On);
public static string Nv_Mfg_Format => ResourceManager.GetString(nameof(Nv_Mfg_Format), Culture) ?? nameof(Nv_Mfg_Format);
public static string Nv_Mode_Balanced => ResourceManager.GetString(nameof(Nv_Mode_Balanced), Culture) ?? nameof(Nv_Mode_Balanced);
public static string Nv_Mode_Custom => ResourceManager.GetString(nameof(Nv_Mode_Custom), Culture) ?? nameof(Nv_Mode_Custom);
public static string Nv_Mode_Custom_Format => ResourceManager.GetString(nameof(Nv_Mode_Custom_Format), Culture) ?? nameof(Nv_Mode_Custom_Format);
public static string Nv_Mode_Dlaa => ResourceManager.GetString(nameof(Nv_Mode_Dlaa), Culture) ?? nameof(Nv_Mode_Dlaa);
public static string Nv_Mode_Performance => ResourceManager.GetString(nameof(Nv_Mode_Performance), Culture) ?? nameof(Nv_Mode_Performance);
public static string Nv_Mode_Quality => ResourceManager.GetString(nameof(Nv_Mode_Quality), Culture) ?? nameof(Nv_Mode_Quality);
public static string Nv_Mode_UltraPerformance => ResourceManager.GetString(nameof(Nv_Mode_UltraPerformance), Culture) ?? nameof(Nv_Mode_UltraPerformance);
public static string Nv_Override_Fg => ResourceManager.GetString(nameof(Nv_Override_Fg), Culture) ?? nameof(Nv_Override_Fg);
public static string Nv_Override_None => ResourceManager.GetString(nameof(Nv_Override_None), Culture) ?? nameof(Nv_Override_None);
public static string Nv_Override_Rr => ResourceManager.GetString(nameof(Nv_Override_Rr), Culture) ?? nameof(Nv_Override_Rr);
public static string Nv_Override_Sl => ResourceManager.GetString(nameof(Nv_Override_Sl), Culture) ?? nameof(Nv_Override_Sl);
public static string Nv_Override_Sr => ResourceManager.GetString(nameof(Nv_Override_Sr), Culture) ?? nameof(Nv_Override_Sr);
public static string Nv_Preset_Default => ResourceManager.GetString(nameof(Nv_Preset_Default), Culture) ?? nameof(Nv_Preset_Default);
public static string Nv_Preset_Format => ResourceManager.GetString(nameof(Nv_Preset_Format), Culture) ?? nameof(Nv_Preset_Format);
public static string Nv_Preset_Latest => ResourceManager.GetString(nameof(Nv_Preset_Latest), Culture) ?? nameof(Nv_Preset_Latest);
public static string Nv_Profile_Format => ResourceManager.GetString(nameof(Nv_Profile_Format), Culture) ?? nameof(Nv_Profile_Format);
public static string Nv_Profile_Global_Format => ResourceManager.GetString(nameof(Nv_Profile_Global_Format), Culture) ?? nameof(Nv_Profile_Global_Format);
public static string Nv_SmoothMotion => ResourceManager.GetString(nameof(Nv_SmoothMotion), Culture) ?? nameof(Nv_SmoothMotion);
public static string Override_Apply => ResourceManager.GetString(nameof(Override_Apply), Culture) ?? nameof(Override_Apply);
public static string Override_Body => ResourceManager.GetString(nameof(Override_Body), Culture) ?? nameof(Override_Body);
@@ -1442,6 +1942,8 @@ public static class Strings
public static string Sensors_Axis_Mb => ResourceManager.GetString(nameof(Sensors_Axis_Mb), Culture) ?? nameof(Sensors_Axis_Mb);
public static string Sensors_Axis_Watts => ResourceManager.GetString(nameof(Sensors_Axis_Watts), Culture) ?? nameof(Sensors_Axis_Watts);
public static string Sensors_Empty => ResourceManager.GetString(nameof(Sensors_Empty), Culture) ?? nameof(Sensors_Empty);
public static string Sensors_Series_CpuLoad => ResourceManager.GetString(nameof(Sensors_Series_CpuLoad), Culture) ?? nameof(Sensors_Series_CpuLoad);
@@ -1466,6 +1968,8 @@ public static class Strings
public static string Sensors_Vram_Header => ResourceManager.GetString(nameof(Sensors_Vram_Header), Culture) ?? nameof(Sensors_Vram_Header);
public static string Session_UnderException_Format => ResourceManager.GetString(nameof(Session_UnderException_Format), Culture) ?? nameof(Session_UnderException_Format);
public static string Sessions_Col_Api => ResourceManager.GetString(nameof(Sessions_Col_Api), Culture) ?? nameof(Sessions_Col_Api);
public static string Sessions_Col_Date => ResourceManager.GetString(nameof(Sessions_Col_Date), Culture) ?? nameof(Sessions_Col_Date);
@@ -1536,6 +2040,28 @@ public static class Strings
public static string Settings_Channel_Stable => ResourceManager.GetString(nameof(Settings_Channel_Stable), Culture) ?? nameof(Settings_Channel_Stable);
public static string Settings_Exceptions_Body => ResourceManager.GetString(nameof(Settings_Exceptions_Body), Culture) ?? nameof(Settings_Exceptions_Body);
public static string Settings_Exceptions_Checking => ResourceManager.GetString(nameof(Settings_Exceptions_Checking), Culture) ?? nameof(Settings_Exceptions_Checking);
public static string Settings_Exceptions_Empty => ResourceManager.GetString(nameof(Settings_Exceptions_Empty), Culture) ?? nameof(Settings_Exceptions_Empty);
public static string Settings_Exceptions_Grant => ResourceManager.GetString(nameof(Settings_Exceptions_Grant), Culture) ?? nameof(Settings_Exceptions_Grant);
public static string Settings_Exceptions_Header => ResourceManager.GetString(nameof(Settings_Exceptions_Header), Culture) ?? nameof(Settings_Exceptions_Header);
public static string Settings_Exceptions_Label => ResourceManager.GetString(nameof(Settings_Exceptions_Label), Culture) ?? nameof(Settings_Exceptions_Label);
public static string Settings_Exceptions_Refresh => ResourceManager.GetString(nameof(Settings_Exceptions_Refresh), Culture) ?? nameof(Settings_Exceptions_Refresh);
public static string Settings_Exceptions_Suspended => ResourceManager.GetString(nameof(Settings_Exceptions_Suspended), Culture) ?? nameof(Settings_Exceptions_Suspended);
public static string Settings_Exceptions_Withdraw => ResourceManager.GetString(nameof(Settings_Exceptions_Withdraw), Culture) ?? nameof(Settings_Exceptions_Withdraw);
public static string Settings_FpsDecimals_Body => ResourceManager.GetString(nameof(Settings_FpsDecimals_Body), Culture) ?? nameof(Settings_FpsDecimals_Body);
public static string Settings_FpsDecimals_Label => ResourceManager.GetString(nameof(Settings_FpsDecimals_Label), Culture) ?? nameof(Settings_FpsDecimals_Label);
public static string Settings_Header => ResourceManager.GetString(nameof(Settings_Header), Culture) ?? nameof(Settings_Header);
public static string Settings_HideAntiCheatHooking_Body => ResourceManager.GetString(nameof(Settings_HideAntiCheatHooking_Body), Culture) ?? nameof(Settings_HideAntiCheatHooking_Body);
@@ -1650,6 +2176,12 @@ public static class Strings
public static string StartupFailed_Title => ResourceManager.GetString(nameof(StartupFailed_Title), Culture) ?? nameof(StartupFailed_Title);
public static string Store_Epic_Format => ResourceManager.GetString(nameof(Store_Epic_Format), Culture) ?? nameof(Store_Epic_Format);
public static string Store_Gog_Format => ResourceManager.GetString(nameof(Store_Gog_Format), Culture) ?? nameof(Store_Gog_Format);
public static string Store_Steam_Format => ResourceManager.GetString(nameof(Store_Steam_Format), Culture) ?? nameof(Store_Steam_Format);
public static string Summary_Annotations_Header => ResourceManager.GetString(nameof(Summary_Annotations_Header), Culture) ?? nameof(Summary_Annotations_Header);
public static string Summary_Crash_Body => ResourceManager.GetString(nameof(Summary_Crash_Body), Culture) ?? nameof(Summary_Crash_Body);
@@ -1672,6 +2204,10 @@ public static class Strings
public static string Summary_Frametime_Header => ResourceManager.GetString(nameof(Summary_Frametime_Header), Culture) ?? nameof(Summary_Frametime_Header);
public static string Summary_Libraries_Format => ResourceManager.GetString(nameof(Summary_Libraries_Format), Culture) ?? nameof(Summary_Libraries_Format);
public static string Summary_Library_Differs_Format => ResourceManager.GetString(nameof(Summary_Library_Differs_Format), Culture) ?? nameof(Summary_Library_Differs_Format);
public static string Summary_Line_Format => ResourceManager.GetString(nameof(Summary_Line_Format), Culture) ?? nameof(Summary_Line_Format);
public static string Summary_Lows_Presented => ResourceManager.GetString(nameof(Summary_Lows_Presented), Culture) ?? nameof(Summary_Lows_Presented);
@@ -1768,6 +2304,8 @@ public static class Strings
public static string Tier_Hooked_Tooltip => ResourceManager.GetString(nameof(Tier_Hooked_Tooltip), Culture) ?? nameof(Tier_Hooked_Tooltip);
public static string Tier_HookedException => ResourceManager.GetString(nameof(Tier_HookedException), Culture) ?? nameof(Tier_HookedException);
public static string Tier_NA_Tooltip => ResourceManager.GetString(nameof(Tier_NA_Tooltip), Culture) ?? nameof(Tier_NA_Tooltip);
public static string Tier_NotHooked => ResourceManager.GetString(nameof(Tier_NotHooked), Culture) ?? nameof(Tier_NotHooked);
@@ -1814,6 +2352,8 @@ public static class Strings
public static string Trend_Empty => ResourceManager.GetString(nameof(Trend_Empty), Culture) ?? nameof(Trend_Empty);
public static string Trend_Empty_Format => ResourceManager.GetString(nameof(Trend_Empty_Format), Culture) ?? nameof(Trend_Empty_Format);
public static string Trend_Excluded_Format => ResourceManager.GetString(nameof(Trend_Excluded_Format), Culture) ?? nameof(Trend_Excluded_Format);
public static string Trend_IncludeMidSession => ResourceManager.GetString(nameof(Trend_IncludeMidSession), Culture) ?? nameof(Trend_IncludeMidSession);
@@ -1840,10 +2380,16 @@ public static class Strings
public static string Trend_Metric_MaxVramProcess => ResourceManager.GetString(nameof(Trend_Metric_MaxVramProcess), Culture) ?? nameof(Trend_Metric_MaxVramProcess);
public static string Trend_Metric_NativeFps => ResourceManager.GetString(nameof(Trend_Metric_NativeFps), Culture) ?? nameof(Trend_Metric_NativeFps);
public static string Trend_Metric_P01Low => ResourceManager.GetString(nameof(Trend_Metric_P01Low), Culture) ?? nameof(Trend_Metric_P01Low);
public static string Trend_Metric_P1Low => ResourceManager.GetString(nameof(Trend_Metric_P1Low), Culture) ?? nameof(Trend_Metric_P1Low);
public static string Trend_Metric_PresentedFps => ResourceManager.GetString(nameof(Trend_Metric_PresentedFps), Culture) ?? nameof(Trend_Metric_PresentedFps);
public static string Trend_Partial_Note => ResourceManager.GetString(nameof(Trend_Partial_Note), Culture) ?? nameof(Trend_Partial_Note);
public static string Uninstall_DataFolder_Body => ResourceManager.GetString(nameof(Uninstall_DataFolder_Body), Culture) ?? nameof(Uninstall_DataFolder_Body);
public static string Uninstall_DataFolder_Title => ResourceManager.GetString(nameof(Uninstall_DataFolder_Title), Culture) ?? nameof(Uninstall_DataFolder_Title);
+733 -5
View File
@@ -810,7 +810,7 @@
<comment>review</comment>
</data>
<data name="GameDetail_LifetimeAvg" xml:space="preserve">
<value>全期間平均</value>
<value>最後に計測したセッション</value>
<comment>review</comment>
</data>
<data name="GameDetail_Measured_Empty" xml:space="preserve">
@@ -1462,11 +1462,11 @@
<comment>review</comment>
</data>
<data name="Sensors_Temps_Header" xml:space="preserve">
<value>温度と負荷</value>
<value>温度・負荷・電力</value>
<comment>review</comment>
</data>
<data name="Sensors_Vram_Header" xml:space="preserve">
<value>VRAM</value>
<value>メモリ</value>
<comment>review</comment>
</data>
<data name="Tabs_SelectASession" xml:space="preserve">
@@ -1482,7 +1482,7 @@
<comment>review</comment>
</data>
<data name="Trend_Average_Note" xml:space="preserve">
<value>平均は、フレーム生成が実測された場合はネイティブ FPS、未実測の場合は提示 FPS です。</value>
<value>ネイティブ FPS はゲーム自身のフレームだけを数え、フレーム生成を計測できたセッションにだけあります。表示された FPS は、生成フレームを数えなかったセッションで表示されたすべてのフレームを数えます。</value>
<comment>review</comment>
</data>
<data name="Trend_Axis_Date" xml:space="preserve">
@@ -2530,11 +2530,739 @@
<comment>review</comment>
</data>
<data name="Settings_HideAntiCheatHooking_Body" xml:space="preserve">
<value>アンチチートが検出されたゲームはフックできません。オンにするとゲームのページには検出内容だけが表示され、オフにすると無効化されたフックのスイッチも表示されます。どちらの場合も、フックなしで記録は続きます。</value>
<value>アンチチートが検出されたゲームは、ユーザーモード例外(下記)を作成しない限りフックできません。オンにするとゲームのページには検出内容だけが表示され、オフにすると無効化されたフックのスイッチも表示されます。どちらの場合も、フックなしで記録は続きます。</value>
<comment>review</comment>
</data>
<data name="Notice_HookingOff_Title_Format" xml:space="preserve">
<value>{0}: フックがオフになりました</value>
<comment>review</comment>
</data>
<data name="Arch_X64" xml:space="preserve">
<value>64ビット (x64)</value>
<comment>review</comment>
</data>
<data name="Arch_X86" xml:space="preserve">
<value>32ビット (x86)</value>
<comment>review</comment>
</data>
<data name="Arch_Arm64" xml:space="preserve">
<value>ARM64</value>
<comment>review</comment>
</data>
<data name="Arch_Arm" xml:space="preserve">
<value>ARM (32ビット)</value>
<comment>review</comment>
</data>
<data name="Arch_AnyCpu" xml:space="preserve">
<value>.NET、任意の CPU(64ビットで実行)</value>
<comment>review</comment>
</data>
<data name="Arch_AnyCpu32" xml:space="preserve">
<value>.NET、任意の CPU、32ビット優先(32ビットで実行)</value>
<comment>review</comment>
</data>
<data name="Arch_Other" xml:space="preserve">
<value>その他のアーキテクチャ</value>
<comment>review</comment>
</data>
<data name="Arch_Unknown" xml:space="preserve">
<value>読み取れませんでした</value>
<comment>review</comment>
</data>
<data name="Store_Steam_Format" xml:space="preserve">
<value>Steam ビルド {0}</value>
<comment>review</comment>
</data>
<data name="Store_Gog_Format" xml:space="preserve">
<value>GOG バージョン {0}</value>
<comment>review</comment>
</data>
<data name="Store_Epic_Format" xml:space="preserve">
<value>Epic バージョン {0}</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Header" xml:space="preserve">
<value>詳細</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Architecture" xml:space="preserve">
<value>実行形式</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_FileVersion" xml:space="preserve">
<value>ファイル バージョン</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_ProductVersion" xml:space="preserve">
<value>製品バージョン</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Store" xml:space="preserve">
<value>ストア</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Version" xml:space="preserve">
<value>バージョン</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Engine" xml:space="preserve">
<value>エンジン</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Libraries" xml:space="preserve">
<value>同梱ライブラリ</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_Library_Format" xml:space="preserve">
<value>{0}: {1} {2}</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_LibraryNoVersion_Format" xml:space="preserve">
<value>{0}: {1}(バージョンなし)</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_NoLibraries" xml:space="preserve">
<value>ルールが挙げるファイルはありません</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_NotRead" xml:space="preserve">
<value>まだ読み取っていません。キャプチャ エージェントが起動後まもなくゲームのファイルを読み取ります。</value>
<comment>review</comment>
</data>
<data name="Hooking_NotX64_Format" xml:space="preserve">
<value>このゲームの実行ファイルは {0} です。FrameLedger のフックは 64ビット (x64) のゲームでのみ動作するため、フックをオンにすることはできません。セッションにはプレイ時間とセンサーの値が記録されます。</value>
<comment>review</comment>
</data>
<data name="Summary_Libraries_Format" xml:space="preserve">
<value>読み込まれたライブラリ: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Library_Differs_Format" xml:space="preserve">
<value>{0} {1}(ゲーム同梱は {2}。ドライバーや NVIDIA App などにより別のコピーが読み込まれました)</value>
<comment>review</comment>
</data>
<data name="Nv_Profile_Format" xml:space="preserve">
<value>NVIDIA プロファイル「{0}」: {1}</value>
<comment>review</comment>
</data>
<data name="Nv_Profile_Global_Format" xml:space="preserve">
<value>NVIDIA グローバル プロファイル(このゲーム用のプロファイルはありません): {0}</value>
<comment>review</comment>
</data>
<data name="Nv_Override_None" xml:space="preserve">
<value>DLSS やフレーム生成の上書きはありません</value>
<comment>review</comment>
</data>
<data name="Nv_Override_Sr" xml:space="preserve">
<value>DLSS の上書き</value>
<comment>review</comment>
</data>
<data name="Nv_Override_Rr" xml:space="preserve">
<value>レイ再構成の上書き</value>
<comment>review</comment>
</data>
<data name="Nv_Override_Fg" xml:space="preserve">
<value>フレーム生成の上書き</value>
<comment>review</comment>
</data>
<data name="Nv_Override_Sl" xml:space="preserve">
<value>Streamline 経由の DLSS の上書き</value>
<comment>review</comment>
</data>
<data name="Nv_FgMode_Off" xml:space="preserve">
<value>フレーム生成を強制オフ</value>
<comment>review</comment>
</data>
<data name="Nv_FgMode_On" xml:space="preserve">
<value>フレーム生成を強制オン</value>
<comment>review</comment>
</data>
<data name="Nv_FgMode_Auto" xml:space="preserve">
<value>フレーム生成は自動</value>
<comment>review</comment>
</data>
<data name="Nv_FgMode_Dynamic" xml:space="preserve">
<value>動的フレーム生成</value>
<comment>review</comment>
</data>
<data name="Nv_SmoothMotion" xml:space="preserve">
<value>Smooth Motion(NVIDIA ではなくコミュニティのツールが記載している設定)</value>
<comment>review</comment>
</data>
<data name="Nv_Details_Format" xml:space="preserve">
<value>{0}({1})</value>
<comment>review</comment>
</data>
<data name="Nv_Preset_Format" xml:space="preserve">
<value>プリセット {0}</value>
<comment>review</comment>
</data>
<data name="Nv_Preset_Latest" xml:space="preserve">
<value>最新のプリセット</value>
<comment>review</comment>
</data>
<data name="Nv_Preset_Default" xml:space="preserve">
<value>既定のプリセット</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Performance" xml:space="preserve">
<value>パフォーマンス</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Balanced" xml:space="preserve">
<value>バランス</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Quality" xml:space="preserve">
<value>クオリティ</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Dlaa" xml:space="preserve">
<value>DLAA</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_UltraPerformance" xml:space="preserve">
<value>ウルトラ パフォーマンス</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Custom_Format" xml:space="preserve">
<value>カスタム {0}%</value>
<comment>review</comment>
</data>
<data name="Nv_Mode_Custom" xml:space="preserve">
<value>カスタム比率</value>
<comment>review</comment>
</data>
<data name="Nv_Mfg_Format" xml:space="preserve">
<value>×{0}</value>
<comment>review</comment>
</data>
<data name="Nv_DynamicTarget_Format" xml:space="preserve">
<value>動的ターゲット {0} FPS</value>
<comment>review</comment>
</data>
<data name="Nv_DynamicTarget_Auto" xml:space="preserve">
<value>動的ターゲットは自動</value>
<comment>review</comment>
</data>
<data name="Nv_Driver_Format" xml:space="preserve">
<value>NVIDIA ドライバー(このゲームのプロセス): {0}</value>
<comment>review</comment>
</data>
<data name="Nv_Driver_DllSelected" xml:space="preserve">
<value>ドライバーが選んだ DLSS DLL</value>
<comment>review</comment>
</data>
<data name="Nv_Driver_Ratio_Format" xml:space="preserve">
<value>比率 {0}</value>
<comment>review</comment>
</data>
<data name="GameDetail_Details_NvidiaOverride" xml:space="preserve">
<value>NVIDIA App の上書き</value>
<comment>review</comment>
</data>
<data name="End_Running" xml:space="preserve">
<value>キャプチャは時間指定で、ゲームの実行中に終了しました。</value>
<comment>review</comment>
</data>
<data name="End_TargetExited" xml:space="preserve">
<value>ゲームが終了しました。</value>
<comment>review</comment>
</data>
<data name="End_SafetyUnhook" xml:space="preserve">
<value>セッション中にアンチチートが現れたため、計測を停止しました。</value>
<comment>review</comment>
</data>
<data name="End_SupervisionLost" xml:space="preserve">
<value>ゲームのプロセスを見失ったため、計測を停止しました。</value>
<comment>review</comment>
</data>
<data name="End_WriterSelfDisabled" xml:space="preserve">
<value>計測フックがエラーの繰り返しにより自ら停止したため、計測を停止しました。</value>
<comment>review</comment>
</data>
<data name="End_WriterStoppedBlocklisted" xml:space="preserve">
<value>ブロックリストにあるモジュールがゲームに読み込まれたため、計測フックが停止しました。</value>
<comment>review</comment>
</data>
<data name="End_WriterNeverInstalledHooks" xml:space="preserve">
<value>計測フックは読み込まれましたが、計測できるグラフィックス API が見つかりませんでした。</value>
<comment>review</comment>
</data>
<data name="End_RefusedHookNotEnabled" xml:space="preserve">
<value>このゲームのフックはオフのため、何も計測されていません。</value>
<comment>review</comment>
</data>
<data name="End_RefusedConsentMissing" xml:space="preserve">
<value>フックへの同意はこの実行ファイルの別のビルドに対するものだったため、フックしませんでした。</value>
<comment>review</comment>
</data>
<data name="End_RefusedPreviouslyBlocked" xml:space="preserve">
<value>このゲームでは以前にアンチチートが検出されたため、フックすることはありません。</value>
<comment>review</comment>
</data>
<data name="End_RefusedByGuard" xml:space="preserve">
<value>アンチチート ガードがこのゲームのフックを拒否しました。</value>
<comment>review</comment>
</data>
<data name="End_PreScanCouldNotVerify" xml:space="preserve">
<value>ゲームのファイルにアンチチートがないか確認できなかったため、フックしませんでした。</value>
<comment>review</comment>
</data>
<data name="End_TargetNotRunning" xml:space="preserve">
<value>セッション開始時にゲームが実行されていませんでした。</value>
<comment>review</comment>
</data>
<data name="End_TargetCannotBePinned" xml:space="preserve">
<value>ゲームのプロセスを保持できなかったため、計測しませんでした。</value>
<comment>review</comment>
</data>
<data name="End_ExecutableUnreadable" xml:space="preserve">
<value>ゲームの実行ファイルを読み取れませんでした。移動または削除されたか、ドライブが接続されていません。</value>
<comment>review</comment>
</data>
<data name="End_SupervisionFaulted" xml:space="preserve">
<value>セッションの監視に失敗したため、計測を停止しました。</value>
<comment>review</comment>
</data>
<data name="End_TargetAmbiguous" xml:space="preserve">
<value>このゲームに一致するプロセスが複数あったため、どれもフックしませんでした。</value>
<comment>review</comment>
</data>
<data name="End_AttachRefused" xml:space="preserve">
<value>計測フックのデータがこのビルドの FrameLedger と一致しなかったため、何も読み取っていません。</value>
<comment>review</comment>
</data>
<data name="End_LaunchCannotStart" xml:space="preserve">
<value>ゲームを起動できませんでした。</value>
<comment>review</comment>
</data>
<data name="End_LaunchTargetExited" xml:space="preserve">
<value>計測を始める前にゲームが終了しました。</value>
<comment>review</comment>
</data>
<data name="End_LaunchNoPresentationRuntime" xml:space="preserve">
<value>ゲームは FrameLedger が計測するグラフィックス API を読み込みませんでした(DirectX 9 以前は計測しません)。</value>
<comment>review</comment>
</data>
<data name="End_RefusedKillSwitch" xml:space="preserve">
<value>設定ですべてのフックがオフになっているため、何も計測されていません。</value>
<comment>review</comment>
</data>
<data name="End_KillSwitchEngaged" xml:space="preserve">
<value>セッション中に設定ですべてのフックがオフにされたため、計測を停止しました。</value>
<comment>review</comment>
</data>
<data name="End_StoppedByUser" xml:space="preserve">
<value>キャプチャを手動で停止しました。</value>
<comment>review</comment>
</data>
<data name="End_TargetUnreadable" xml:space="preserve">
<value>ゲームのプロセスを開けませんでした。アンチチートのドライバーに保護されているか、管理者として実行されています。</value>
<comment>review</comment>
</data>
<data name="Guard_Refused_Format" xml:space="preserve">
<value>アンチチート ガードはこのゲームをフックしませんでした: {0}。</value>
<comment>review</comment>
</data>
<data name="Guard_ModuleScanFailed" xml:space="preserve">
<value>ゲームが読み込んだモジュールをすべて列挙できませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_ProcessUnreadable" xml:space="preserve">
<value>ゲームのプロセスを開けませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_ProcessTreeUnavailable" xml:space="preserve">
<value>ゲームのプロセス ツリーを確定できませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_DriverScanFailed" xml:space="preserve">
<value>読み込まれているドライバーを列挙できませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_ServiceQueryFailed" xml:space="preserve">
<value>アンチチートのサービスを照会できませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_RulesUnreadable" xml:space="preserve">
<value>アンチチートのルールを読み取れませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_RulesMalformed" xml:space="preserve">
<value>アンチチートのルール ファイルが破損しています</value>
<comment>review</comment>
</data>
<data name="Guard_RulesIncomplete" xml:space="preserve">
<value>アンチチートのルール ファイルに必要な項目がありません</value>
<comment>review</comment>
</data>
<data name="Guard_PreScanFailed" xml:space="preserve">
<value>ゲームのフォルダーをスキャンできませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_InjectionFailed" xml:space="preserve">
<value>すべてのチェックに合格しましたが、フックを読み込めませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_TargetIsWow64" xml:space="preserve">
<value>ゲームは 32 ビットで、フックは 64 ビットのゲームでのみ動作します</value>
<comment>review</comment>
</data>
<data name="Guard_PayloadNotOurs" xml:space="preserve">
<value>フックのファイルが FrameLedger 自身のビルドではありません</value>
<comment>review</comment>
</data>
<data name="Guard_HookNotEnabled" xml:space="preserve">
<value>このゲームのフックはオフです</value>
<comment>review</comment>
</data>
<data name="Guard_ConsentMissing" xml:space="preserve">
<value>この実行ファイルへのフックに同意していません</value>
<comment>review</comment>
</data>
<data name="Guard_PreviouslyBlocked" xml:space="preserve">
<value>このゲームでは以前にアンチチートが検出されています</value>
<comment>review</comment>
</data>
<data name="Guard_LaunchTargetExited" xml:space="preserve">
<value>チェックの前にゲームが終了しました</value>
<comment>review</comment>
</data>
<data name="Guard_LaunchNoPresentationRuntime" xml:space="preserve">
<value>ゲームは FrameLedger が計測するグラフィックス API を読み込みませんでした</value>
<comment>review</comment>
</data>
<data name="Guard_TargetIsVulkanLayered" xml:space="preserve">
<value>ゲームは Vulkan で描画しており、代わりに Vulkan レイヤーが計測します</value>
<comment>review</comment>
</data>
<data name="Guard_SuspiciousUnsigned" xml:space="preserve">
<value>アンチチートに似た名前の署名のないモジュールが読み込まれていました</value>
<comment>review</comment>
</data>
<data name="Guard_Other_Format" xml:space="preserve">
<value>理由 {0}</value>
<comment>review</comment>
</data>
<data name="Exit_Line_Format" xml:space="preserve">
<value>終了: {0}</value>
<comment>review</comment>
</data>
<data name="Exit_Code_Format" xml:space="preserve">
<value>終了コード {0} で終了</value>
<comment>review</comment>
</data>
<data name="Exit_Code1" xml:space="preserve">
<value>終了コード 1 で終了 — タスクの終了や taskkill が残すコードで、多くのプログラムのエラー終了でもあります</value>
<comment>review</comment>
</data>
<data name="Exit_Crashed_Format" xml:space="preserve">
<value>クラッシュ({0})</value>
<comment>review</comment>
</data>
<data name="Exit_CrashEvent" xml:space="preserve">
<value>クラッシュ(Windows がアプリケーション エラーを記録)</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_AccessViolation" xml:space="preserve">
<value>0xC0000005 アクセス違反</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_InPageError" xml:space="preserve">
<value>0xC0000006 ページ内 I/O エラー: ゲームがファイルを読む間にディスクまたはドライブが失敗しました</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_StackOverflow" xml:space="preserve">
<value>0xC00000FD スタック オーバーフロー</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_HeapCorruption" xml:space="preserve">
<value>0xC0000374 ヒープ破損</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_FailFast" xml:space="preserve">
<value>0xC0000409 フェイル ファスト: ゲームが検出した障害で自ら停止しました</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_DllInit" xml:space="preserve">
<value>0xC0000142 DLL の初期化に失敗しました</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_DllNotFound" xml:space="preserve">
<value>0xC0000135 必要な DLL が見つかりませんでした</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_BadImage" xml:space="preserve">
<value>0xC000007B 無効なイメージ(多くは 32/64 ビットの混在)</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_Cpp" xml:space="preserve">
<value>0xE06D7363 処理されない C++ 例外</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_Clr" xml:space="preserve">
<value>0xE0434352 処理されない .NET 例外</value>
<comment>review</comment>
</data>
<data name="Exit_Ex_Breakpoint" xml:space="preserve">
<value>0x80000003 ブレークポイント</value>
<comment>review</comment>
</data>
<data name="Launch_Error_Format" xml:space="preserve">
<value>Windows エラー {0}</value>
<comment>review</comment>
</data>
<data name="Launch_Error_2" xml:space="preserve">
<value>ファイルが見つかりません</value>
<comment>review</comment>
</data>
<data name="Launch_Error_3" xml:space="preserve">
<value>パスが見つかりません</value>
<comment>review</comment>
</data>
<data name="Launch_Error_5" xml:space="preserve">
<value>アクセスが拒否されました</value>
<comment>review</comment>
</data>
<data name="Launch_Error_193" xml:space="preserve">
<value>有効な Windows プログラムではありません</value>
<comment>review</comment>
</data>
<data name="Launch_Error_740" xml:space="preserve">
<value>ゲームには管理者権限が必要です</value>
<comment>review</comment>
</data>
<data name="Launch_Failed_Format" xml:space="preserve">
<value>{0}({1})</value>
<comment>review</comment>
</data>
<data name="Exe_DriveMissing_Format" xml:space="preserve">
<value>ドライブ {0} が接続されていません。接続されると FrameLedger はゲームを再び見つけます。</value>
<comment>review</comment>
</data>
<data name="Exe_FileMissing_Format" xml:space="preserve">
<value>ゲームの実行ファイルは {0} にありません。</value>
<comment>review</comment>
</data>
<data name="Exit_EndedNormally" xml:space="preserve">
<value>正常に終了</value>
<comment>review</comment>
</data>
<data name="Settings_FpsDecimals_Label" xml:space="preserve">
<value>FPS を小数点以下 2 桁で表示</value>
<comment>review</comment>
</data>
<data name="Settings_FpsDecimals_Body" xml:space="preserve">
<value>平均、ロー、トレンドなどすべての FPS の値を、整数(62)ではなく小数点以下 2 桁(62.40)で表示します。各ページには次に読み込んだときに反映されます。</value>
<comment>review</comment>
</data>
<data name="Fps_Fg_Steady_Format" xml:space="preserve">
<value>{0} → {1} FPS (×{2:0.0} FG · {3:0}%)</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_NativeFps" xml:space="preserve">
<value>ネイティブ FPS</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_PresentedFps" xml:space="preserve">
<value>表示された FPS(Presented)</value>
<comment>review</comment>
</data>
<data name="Trend_Partial_Note" xml:space="preserve">
<value>白抜きの点はセッションの一部だけを表します。途中で設定が変わったか、値が定常状態のものです。</value>
<comment>review</comment>
</data>
<data name="Trend_Empty_Format" xml:space="preserve">
<value>このゲームのセッションには、まだ {0} の値がありません。</value>
<comment>review</comment>
</data>
<data name="Chart_Series_AppFrames" xml:space="preserve">
<value>アプリケーションフレーム</value>
<comment>review</comment>
</data>
<data name="Chart_Series_Presents" xml:space="preserve">
<value>提示</value>
<comment>review</comment>
</data>
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
<value>このセッションではフレーム生成がアプリケーションフレームを一つも数えなかったため、グラフはすべての提示を表示しています。</value>
<comment>review</comment>
</data>
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
<value>提示はゲームが送信した時点で計時されます。生成フレームはまとめて送信され、後で均等な間隔で表示されることが多いため、「表示」の線は画面の表示間隔ではありません。</value>
<comment>review</comment>
</data>
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
<value>時間軸は {0} 個の欠落(一時停止、または失われた記録)を詰めて表示するため、その後のセンサーの線はフレームより先行します。</value>
<comment>review</comment>
</data>
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
<value>0.5〜99.5 パーセンタイルの範囲外にある {0} フレームはヒストグラムに描画されていません。</value>
<comment>review</comment>
</data>
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
<value>最初のフレームからの時間 (秒)</value>
<comment>review</comment>
</data>
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
<value>セッション開始からの時間 (秒)</value>
<comment>review</comment>
</data>
<data name="Sensors_Axis_Watts" xml:space="preserve">
<value>W</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Label" xml:space="preserve">
<value>以前に計測できたユーザーモードのアンチチート搭載ゲームでフックを許可する</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Body" xml:space="preserve">
<value>既定ではオフです。オンにすると、アンチチートがユーザーモードのみで動作し(カーネルドライバーがなく、ほかに何も検出されない)、フックで2回以上計測できたゲームに、開示を確認したうえでゲームごとに例外を与えられます。ガードはすべてのチェックを続け、アカウント停止の可能性は残ります。</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Header" xml:space="preserve">
<value>ユーザーモード例外</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Empty" xml:space="preserve">
<value>ライブラリに対象のゲームはありません。</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Suspended" xml:space="preserve">
<value>オプションがオフです。下の例外は保持されますが適用されません。</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Grant" xml:space="preserve">
<value>例外を作成…</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Withdraw" xml:space="preserve">
<value>取り消す</value>
<comment>review</comment>
</data>
<data name="Exception_Finding_Format" xml:space="preserve">
<value>{0} — {1}</value>
<comment>review</comment>
</data>
<data name="Exception_Sessions_Format" xml:space="preserve">
<value>フック計測の成功 {0} 回</value>
<comment>review</comment>
</data>
<data name="Exception_State_Granted_Format" xml:space="preserve">
<value>{0} から例外が有効</value>
<comment>review</comment>
</data>
<data name="Exception_State_Eligible" xml:space="preserve">
<value>対象 — 例外は未作成</value>
<comment>review</comment>
</data>
<data name="Exception_State_Checking" xml:space="preserve">
<value>確認中…</value>
<comment>review</comment>
</data>
<data name="Exception_State_TooFew_Format" xml:space="preserve">
<value>対象外: フック計測の成功は {0} 回で、2 回必要です</value>
<comment>review</comment>
</data>
<data name="Exception_State_Refused_Format" xml:space="preserve">
<value>対象外: ガードは {0}({1})も検出しました</value>
<comment>review</comment>
</data>
<data name="Exception_State_NotUserMode_Format" xml:space="preserve">
<value>対象外: {0} は完全なユーザーモードではない(ドライバーまたはサービスがある)ため、FrameLedger は例外にしません</value>
<comment>review</comment>
</data>
<data name="Exception_State_NotAsked" xml:space="preserve">
<value>対象外: この検出は単一のアンチチートのモジュール・ファイル・フォルダーではありません</value>
<comment>review</comment>
</data>
<data name="Exception_State_CouldNotVerify" xml:space="preserve">
<value>現在は対象外: 確認を完了できませんでした。自動で再実行されます</value>
<comment>review</comment>
</data>
<data name="Exception_Lapsed_Format" xml:space="preserve">
<value>直近の例外は {0} に終了しました: {1}</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_Withdrawn" xml:space="preserve">
<value>取り消されました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_ExecutableChanged" xml:space="preserve">
<value>ゲームが更新されました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_NoLongerEligible" xml:space="preserve">
<value>ゲームが条件を満たさなくなりました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_NewFinding" xml:space="preserve">
<value>ゲームで新たなアンチチートが検出されました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_SafetyUnhook" xml:space="preserve">
<value>例外下のセッションが安全のため停止されました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_OverlayStopped" xml:space="preserve">
<value>別のアンチチートが読み込まれたため FrameLedger が観測を停止しました</value>
<comment>review</comment>
</data>
<data name="Exception_Lapse_SessionCrashed" xml:space="preserve">
<value>例外下のセッションがクラッシュしました</value>
<comment>review</comment>
</data>
<data name="Exception_Result_Granted_Format" xml:space="preserve">
<value>{0} の例外を作成しました。計測するときは、ゲームのページでフックをオンにしてください。</value>
<comment>review</comment>
</data>
<data name="Exception_Result_Withdrawn_Format" xml:space="preserve">
<value>{0} の例外を取り消しました。フックはオフです。</value>
<comment>review</comment>
</data>
<data name="Exception_Result_Refused_Format" xml:space="preserve">
<value>{0} の例外は作成されませんでした: {1}</value>
<comment>review</comment>
</data>
<data name="GameDetail_Exception_Header" xml:space="preserve">
<value>ユーザーモード例外</value>
<comment>review</comment>
</data>
<data name="GameDetail_Exception_Granted_Format" xml:space="preserve">
<value>{0} に対するユーザーモード例外のもとでフックできます。ガードはすべてのチェックを続け、アカウント停止の可能性は残ります。</value>
<comment>review</comment>
</data>
<data name="GameDetail_Exception_Suspended" xml:space="preserve">
<value>このゲームの例外は保持されていますが、設定でオプションがオフのため適用されません。</value>
<comment>review</comment>
</data>
<data name="GameDetail_Exception_Grant" xml:space="preserve">
<value>例外を作成…</value>
<comment>review</comment>
</data>
<data name="GameDetail_Exception_Withdraw" xml:space="preserve">
<value>例外を取り消す</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Refresh" xml:space="preserve">
<value>更新</value>
<comment>review</comment>
</data>
<data name="Settings_Exceptions_Checking" xml:space="preserve">
<value>キャプチャエージェントがライブラリを確認しています。対象のゲームは1分以内にここに表示されます。更新して確認してください。</value>
<comment>review</comment>
</data>
<data name="Tier_HookedException" xml:space="preserve">
<value>フック・例外</value>
<comment>review</comment>
</data>
<data name="Games_Card_Exception" xml:space="preserve">
<value>例外</value>
<comment>review</comment>
</data>
<data name="Session_UnderException_Format" xml:space="preserve">
<value>{0} のユーザーモード例外のもとでフック</value>
<comment>review</comment>
</data>
</root>
+551 -5
View File
@@ -613,7 +613,7 @@
<value>Last session: {0} · {1}</value>
</data>
<data name="GameDetail_LifetimeAvg" xml:space="preserve">
<value>Lifetime average</value>
<value>Last measured session</value>
</data>
<data name="GameDetail_Measured_Empty" xml:space="preserve">
<value>No measured session yet.</value>
@@ -1102,10 +1102,10 @@
<value>VRAM used by this game (MB)</value>
</data>
<data name="Sensors_Temps_Header" xml:space="preserve">
<value>Temperatures and load</value>
<value>Temperatures, load and power</value>
</data>
<data name="Sensors_Vram_Header" xml:space="preserve">
<value>VRAM</value>
<value>Memory</value>
</data>
<data name="Tabs_SelectASession" xml:space="preserve">
<value>Select a session in the Sessions tab to see it here.</value>
@@ -1117,7 +1117,7 @@
<value>The selected session was not hooked; there are no frames to chart.</value>
</data>
<data name="Trend_Average_Note" xml:space="preserve">
<value>Average is Native FPS where frame generation was measured and Presented FPS where it was not.</value>
<value>Native FPS counts the game's own frames and exists where frame generation was measured. Presented FPS counts every frame presented, on sessions where no generated frames were counted.</value>
</data>
<data name="Trend_Axis_Date" xml:space="preserve">
<value>Date</value>
@@ -1908,9 +1908,555 @@ The documents below are the full terms; this summary does not replace them.</val
<value>Hide hooking on anti-cheat games</value>
</data>
<data name="Settings_HideAntiCheatHooking_Body" xml:space="preserve">
<value>A game in which anti-cheat was found can never be hooked. On, its page shows only what was found; off, it also shows the disabled Hooking switch. Either way it is still recorded without hooking.</value>
<value>A game in which anti-cheat was found cannot be hooked, unless you make a user-mode exception for it (below). On, its page shows only what was found; off, it also shows the disabled Hooking switch. Either way it is still recorded without hooking.</value>
</data>
<data name="Notice_HookingOff_Title_Format" xml:space="preserve">
<value>{0}: hooking turned off</value>
</data>
<data name="Arch_X64" xml:space="preserve">
<value>64-bit (x64)</value>
</data>
<data name="Arch_X86" xml:space="preserve">
<value>32-bit (x86)</value>
</data>
<data name="Arch_Arm64" xml:space="preserve">
<value>ARM64</value>
</data>
<data name="Arch_Arm" xml:space="preserve">
<value>ARM (32-bit)</value>
</data>
<data name="Arch_AnyCpu" xml:space="preserve">
<value>.NET, any CPU (runs as 64-bit)</value>
</data>
<data name="Arch_AnyCpu32" xml:space="preserve">
<value>.NET, any CPU, 32-bit preferred (runs as 32-bit)</value>
</data>
<data name="Arch_Other" xml:space="preserve">
<value>another architecture</value>
</data>
<data name="Arch_Unknown" xml:space="preserve">
<value>could not be read</value>
</data>
<data name="Store_Steam_Format" xml:space="preserve">
<value>Steam build {0}</value>
</data>
<data name="Store_Gog_Format" xml:space="preserve">
<value>GOG version {0}</value>
</data>
<data name="Store_Epic_Format" xml:space="preserve">
<value>Epic version {0}</value>
</data>
<data name="GameDetail_Details_Header" xml:space="preserve">
<value>Details</value>
</data>
<data name="GameDetail_Details_Architecture" xml:space="preserve">
<value>Runs as</value>
</data>
<data name="GameDetail_Details_FileVersion" xml:space="preserve">
<value>File version</value>
</data>
<data name="GameDetail_Details_ProductVersion" xml:space="preserve">
<value>Product version</value>
</data>
<data name="GameDetail_Details_Store" xml:space="preserve">
<value>Store</value>
</data>
<data name="GameDetail_Details_Version" xml:space="preserve">
<value>Version</value>
</data>
<data name="GameDetail_Details_Engine" xml:space="preserve">
<value>Engine</value>
</data>
<data name="GameDetail_Details_Libraries" xml:space="preserve">
<value>Ships with</value>
</data>
<data name="GameDetail_Details_Library_Format" xml:space="preserve">
<value>{0}: {1} {2}</value>
</data>
<data name="GameDetail_Details_LibraryNoVersion_Format" xml:space="preserve">
<value>{0}: {1} (no version)</value>
</data>
<data name="GameDetail_Details_NoLibraries" xml:space="preserve">
<value>none of the files the rules name</value>
</data>
<data name="GameDetail_Details_NotRead" xml:space="preserve">
<value>Not read yet: the capture agent reads the game's files shortly after it starts.</value>
</data>
<data name="Hooking_NotX64_Format" xml:space="preserve">
<value>This game's executable is {0}. FrameLedger's hook runs in 64-bit (x64) games only, so hooking cannot be turned on; its sessions record play time and sensors.</value>
</data>
<data name="Summary_Libraries_Format" xml:space="preserve">
<value>Loaded: {0}</value>
</data>
<data name="Summary_Library_Differs_Format" xml:space="preserve">
<value>{0} {1} (the game ships {2}: another copy was loaded, for example by the driver or the NVIDIA App)</value>
</data>
<data name="Nv_Profile_Format" xml:space="preserve">
<value>NVIDIA profile “{0}”: {1}</value>
</data>
<data name="Nv_Profile_Global_Format" xml:space="preserve">
<value>NVIDIA global profile (no profile names this game): {0}</value>
</data>
<data name="Nv_Override_None" xml:space="preserve">
<value>no DLSS or frame generation override</value>
</data>
<data name="Nv_Override_Sr" xml:space="preserve">
<value>DLSS override</value>
</data>
<data name="Nv_Override_Rr" xml:space="preserve">
<value>Ray Reconstruction override</value>
</data>
<data name="Nv_Override_Fg" xml:space="preserve">
<value>Frame Generation override</value>
</data>
<data name="Nv_Override_Sl" xml:space="preserve">
<value>Streamline DLSS override</value>
</data>
<data name="Nv_FgMode_Off" xml:space="preserve">
<value>frame generation forced off</value>
</data>
<data name="Nv_FgMode_On" xml:space="preserve">
<value>frame generation forced on</value>
</data>
<data name="Nv_FgMode_Auto" xml:space="preserve">
<value>frame generation automatic</value>
</data>
<data name="Nv_FgMode_Dynamic" xml:space="preserve">
<value>dynamic frame generation</value>
</data>
<data name="Nv_SmoothMotion" xml:space="preserve">
<value>Smooth Motion (a setting community tools document, not NVIDIA)</value>
</data>
<data name="Nv_Details_Format" xml:space="preserve">
<value>{0} ({1})</value>
</data>
<data name="Nv_Preset_Format" xml:space="preserve">
<value>preset {0}</value>
</data>
<data name="Nv_Preset_Latest" xml:space="preserve">
<value>latest preset</value>
</data>
<data name="Nv_Preset_Default" xml:space="preserve">
<value>default preset</value>
</data>
<data name="Nv_Mode_Performance" xml:space="preserve">
<value>Performance</value>
</data>
<data name="Nv_Mode_Balanced" xml:space="preserve">
<value>Balanced</value>
</data>
<data name="Nv_Mode_Quality" xml:space="preserve">
<value>Quality</value>
</data>
<data name="Nv_Mode_Dlaa" xml:space="preserve">
<value>DLAA</value>
</data>
<data name="Nv_Mode_UltraPerformance" xml:space="preserve">
<value>Ultra Performance</value>
</data>
<data name="Nv_Mode_Custom_Format" xml:space="preserve">
<value>custom {0}%</value>
</data>
<data name="Nv_Mode_Custom" xml:space="preserve">
<value>custom ratio</value>
</data>
<data name="Nv_Mfg_Format" xml:space="preserve">
<value>×{0}</value>
</data>
<data name="Nv_DynamicTarget_Format" xml:space="preserve">
<value>dynamic target {0} FPS</value>
</data>
<data name="Nv_DynamicTarget_Auto" xml:space="preserve">
<value>dynamic target automatic</value>
</data>
<data name="Nv_Driver_Format" xml:space="preserve">
<value>NVIDIA driver, for this game's process: {0}</value>
</data>
<data name="Nv_Driver_DllSelected" xml:space="preserve">
<value>DLSS DLL chosen by the driver</value>
</data>
<data name="Nv_Driver_Ratio_Format" xml:space="preserve">
<value>ratio {0}</value>
</data>
<data name="GameDetail_Details_NvidiaOverride" xml:space="preserve">
<value>NVIDIA App override</value>
</data>
<data name="End_Running" xml:space="preserve">
<value>The capture was bounded and ended while the game still ran.</value>
</data>
<data name="End_TargetExited" xml:space="preserve">
<value>The game exited.</value>
</data>
<data name="End_SafetyUnhook" xml:space="preserve">
<value>Anti-cheat appeared during the session, so measuring stopped.</value>
</data>
<data name="End_SupervisionLost" xml:space="preserve">
<value>FrameLedger lost track of the game's process, so measuring stopped.</value>
</data>
<data name="End_WriterSelfDisabled" xml:space="preserve">
<value>The measuring hook turned itself off after repeated faults, so measuring stopped.</value>
</data>
<data name="End_WriterStoppedBlocklisted" xml:space="preserve">
<value>The measuring hook stopped because a blocklisted module loaded into the game.</value>
</data>
<data name="End_WriterNeverInstalledHooks" xml:space="preserve">
<value>The measuring hook loaded but found no graphics API it could measure.</value>
</data>
<data name="End_RefusedHookNotEnabled" xml:space="preserve">
<value>Hooking is off for this game, so nothing was measured.</value>
</data>
<data name="End_RefusedConsentMissing" xml:space="preserve">
<value>Hooking was consented to for another build of this executable, so it was not hooked.</value>
</data>
<data name="End_RefusedPreviouslyBlocked" xml:space="preserve">
<value>Anti-cheat was found in this game before, so it is never hooked.</value>
</data>
<data name="End_RefusedByGuard" xml:space="preserve">
<value>The anti-cheat guard refused to hook this game.</value>
</data>
<data name="End_PreScanCouldNotVerify" xml:space="preserve">
<value>FrameLedger could not check this game's files for anti-cheat, so it did not hook it.</value>
</data>
<data name="End_TargetNotRunning" xml:space="preserve">
<value>The game was not running when the session was to start.</value>
</data>
<data name="End_TargetCannotBePinned" xml:space="preserve">
<value>The game's process could not be held open, so it was not measured.</value>
</data>
<data name="End_ExecutableUnreadable" xml:space="preserve">
<value>The game's executable could not be read: it moved, was deleted, or its drive is not connected.</value>
</data>
<data name="End_SupervisionFaulted" xml:space="preserve">
<value>Supervising the session failed, so measuring stopped.</value>
</data>
<data name="End_TargetAmbiguous" xml:space="preserve">
<value>More than one process matched this game, so none was hooked.</value>
</data>
<data name="End_AttachRefused" xml:space="preserve">
<value>The measuring hook's data did not match this build of FrameLedger, so nothing was read.</value>
</data>
<data name="End_LaunchCannotStart" xml:space="preserve">
<value>FrameLedger could not start the game.</value>
</data>
<data name="End_LaunchTargetExited" xml:space="preserve">
<value>The game exited before it could be measured.</value>
</data>
<data name="End_LaunchNoPresentationRuntime" xml:space="preserve">
<value>The game never loaded a graphics API FrameLedger measures (DirectX 9 and older are not measured).</value>
</data>
<data name="End_RefusedKillSwitch" xml:space="preserve">
<value>All hooking is switched off in Settings, so nothing was measured.</value>
</data>
<data name="End_KillSwitchEngaged" xml:space="preserve">
<value>All hooking was switched off in Settings during the session, so measuring stopped.</value>
</data>
<data name="End_StoppedByUser" xml:space="preserve">
<value>You stopped the capture.</value>
</data>
<data name="End_TargetUnreadable" xml:space="preserve">
<value>The game's process could not be opened: an anti-cheat driver protects it, or it runs as administrator.</value>
</data>
<data name="Guard_Refused_Format" xml:space="preserve">
<value>The anti-cheat guard did not hook this game: {0}.</value>
</data>
<data name="Guard_ModuleScanFailed" xml:space="preserve">
<value>the game's loaded modules could not be listed completely</value>
</data>
<data name="Guard_ProcessUnreadable" xml:space="preserve">
<value>the game's process could not be opened</value>
</data>
<data name="Guard_ProcessTreeUnavailable" xml:space="preserve">
<value>the game's process tree could not be established</value>
</data>
<data name="Guard_DriverScanFailed" xml:space="preserve">
<value>the loaded drivers could not be listed</value>
</data>
<data name="Guard_ServiceQueryFailed" xml:space="preserve">
<value>the anti-cheat services could not be queried</value>
</data>
<data name="Guard_RulesUnreadable" xml:space="preserve">
<value>the anti-cheat rules could not be read</value>
</data>
<data name="Guard_RulesMalformed" xml:space="preserve">
<value>the anti-cheat rules file is damaged</value>
</data>
<data name="Guard_RulesIncomplete" xml:space="preserve">
<value>the anti-cheat rules file lacks required entries</value>
</data>
<data name="Guard_PreScanFailed" xml:space="preserve">
<value>the game's folder could not be scanned</value>
</data>
<data name="Guard_InjectionFailed" xml:space="preserve">
<value>every check passed, but the hook could not be loaded</value>
</data>
<data name="Guard_TargetIsWow64" xml:space="preserve">
<value>the game is 32-bit, and the hook runs in 64-bit games only</value>
</data>
<data name="Guard_PayloadNotOurs" xml:space="preserve">
<value>the hook file is not FrameLedger's own build</value>
</data>
<data name="Guard_HookNotEnabled" xml:space="preserve">
<value>hooking is off for this game</value>
</data>
<data name="Guard_ConsentMissing" xml:space="preserve">
<value>hooking was never consented to for this executable</value>
</data>
<data name="Guard_PreviouslyBlocked" xml:space="preserve">
<value>anti-cheat was found in this game before</value>
</data>
<data name="Guard_LaunchTargetExited" xml:space="preserve">
<value>the game exited before it could be checked</value>
</data>
<data name="Guard_LaunchNoPresentationRuntime" xml:space="preserve">
<value>the game loaded no graphics API FrameLedger measures</value>
</data>
<data name="Guard_TargetIsVulkanLayered" xml:space="preserve">
<value>the game renders with Vulkan, which the Vulkan layer measures instead</value>
</data>
<data name="Guard_SuspiciousUnsigned" xml:space="preserve">
<value>an unsigned module with an anti-cheat-like name was loaded</value>
</data>
<data name="Guard_Other_Format" xml:space="preserve">
<value>reason {0}</value>
</data>
<data name="Exit_Line_Format" xml:space="preserve">
<value>How it ended: {0}</value>
</data>
<data name="Exit_Code_Format" xml:space="preserve">
<value>ended with exit code {0}</value>
</data>
<data name="Exit_Code1" xml:space="preserve">
<value>ended with exit code 1 — what End task and taskkill leave, and many programs' own error exit</value>
</data>
<data name="Exit_Crashed_Format" xml:space="preserve">
<value>crashed ({0})</value>
</data>
<data name="Exit_CrashEvent" xml:space="preserve">
<value>crashed (Windows logged an application error)</value>
</data>
<data name="Exit_Ex_AccessViolation" xml:space="preserve">
<value>0xC0000005 access violation</value>
</data>
<data name="Exit_Ex_InPageError" xml:space="preserve">
<value>0xC0000006 in-page I/O error: a disk or drive failed while the game read its files</value>
</data>
<data name="Exit_Ex_StackOverflow" xml:space="preserve">
<value>0xC00000FD stack overflow</value>
</data>
<data name="Exit_Ex_HeapCorruption" xml:space="preserve">
<value>0xC0000374 heap corruption</value>
</data>
<data name="Exit_Ex_FailFast" xml:space="preserve">
<value>0xC0000409 fail-fast: the game stopped itself on a fault it detected</value>
</data>
<data name="Exit_Ex_DllInit" xml:space="preserve">
<value>0xC0000142 a DLL failed to initialise</value>
</data>
<data name="Exit_Ex_DllNotFound" xml:space="preserve">
<value>0xC0000135 a required DLL was not found</value>
</data>
<data name="Exit_Ex_BadImage" xml:space="preserve">
<value>0xC000007B an invalid image, often a 32/64-bit mix</value>
</data>
<data name="Exit_Ex_Cpp" xml:space="preserve">
<value>0xE06D7363 unhandled C++ exception</value>
</data>
<data name="Exit_Ex_Clr" xml:space="preserve">
<value>0xE0434352 unhandled .NET exception</value>
</data>
<data name="Exit_Ex_Breakpoint" xml:space="preserve">
<value>0x80000003 breakpoint</value>
</data>
<data name="Launch_Error_Format" xml:space="preserve">
<value>Windows error {0}</value>
</data>
<data name="Launch_Error_2" xml:space="preserve">
<value>the file was not found</value>
</data>
<data name="Launch_Error_3" xml:space="preserve">
<value>the path was not found</value>
</data>
<data name="Launch_Error_5" xml:space="preserve">
<value>access was denied</value>
</data>
<data name="Launch_Error_193" xml:space="preserve">
<value>it is not a valid Windows program</value>
</data>
<data name="Launch_Error_740" xml:space="preserve">
<value>the game requires administrator rights</value>
</data>
<data name="Launch_Failed_Format" xml:space="preserve">
<value>{0} ({1})</value>
</data>
<data name="Exe_DriveMissing_Format" xml:space="preserve">
<value>The drive {0} is not connected. FrameLedger finds the game again when it is.</value>
</data>
<data name="Exe_FileMissing_Format" xml:space="preserve">
<value>The game's executable is no longer at {0}.</value>
</data>
<data name="Exit_EndedNormally" xml:space="preserve">
<value>ended normally</value>
</data>
<data name="Settings_FpsDecimals_Label" xml:space="preserve">
<value>Show FPS with two decimals</value>
</data>
<data name="Settings_FpsDecimals_Body" xml:space="preserve">
<value>Every FPS figure — averages, lows, the trend — shows two decimals (62.40) instead of a whole number (62). Pages show it the next time they load.</value>
</data>
<data name="Fps_Fg_Steady_Format" xml:space="preserve">
<value>{0} → {1} FPS (×{2:0.0} FG · {3:0}%)</value>
</data>
<data name="Trend_Metric_NativeFps" xml:space="preserve">
<value>Native FPS</value>
</data>
<data name="Trend_Metric_PresentedFps" xml:space="preserve">
<value>Presented FPS</value>
</data>
<data name="Trend_Partial_Note" xml:space="preserve">
<value>Hollow points describe part of their session: its settings changed, or the value is its steady state's.</value>
</data>
<data name="Trend_Empty_Format" xml:space="preserve">
<value>No session of this game has a value for {0} yet.</value>
</data>
<data name="Chart_Series_AppFrames" xml:space="preserve">
<value>Application frames</value>
</data>
<data name="Chart_Series_Presents" xml:space="preserve">
<value>Presents</value>
</data>
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
<value>Frame generation counted no application frame in this session, so the chart shows every present.</value>
</data>
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
<value>Presents are timed when the game submits them. Generated frames are often submitted in a burst and shown later at an even pace, so the Displayed line is not the display's cadence.</value>
</data>
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
<value>The time axis closes up {0} gap(s) — a pause, or records that were lost — so the sensor lines run ahead of the frames after each.</value>
</data>
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
<value>{0} frame(s) outside the 0.5–99.5 percentile range are not drawn in the histogram.</value>
</data>
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
<value>Time from the first frame (s)</value>
</data>
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
<value>Time from the session's start (s)</value>
</data>
<data name="Sensors_Axis_Watts" xml:space="preserve">
<value>W</value>
</data>
<data name="Settings_Exceptions_Label" xml:space="preserve">
<value>Allow hooking in games with user-mode anti-cheat that were measured before</value>
</data>
<data name="Settings_Exceptions_Body" xml:space="preserve">
<value>Off by default. On, a game whose only anti-cheat runs in user mode — no kernel driver, nothing else found — and that was measured hooked at least twice can be given an exception below, one game at a time, after a disclosure. The guard still runs every check, and a ban remains possible.</value>
</data>
<data name="Settings_Exceptions_Header" xml:space="preserve">
<value>User-mode exceptions</value>
</data>
<data name="Settings_Exceptions_Empty" xml:space="preserve">
<value>No game in your library qualifies.</value>
</data>
<data name="Settings_Exceptions_Suspended" xml:space="preserve">
<value>The option is off: the exceptions below are kept but do not apply.</value>
</data>
<data name="Settings_Exceptions_Grant" xml:space="preserve">
<value>Make exception…</value>
</data>
<data name="Settings_Exceptions_Withdraw" xml:space="preserve">
<value>Withdraw</value>
</data>
<data name="Exception_Finding_Format" xml:space="preserve">
<value>{0} — {1}</value>
</data>
<data name="Exception_Sessions_Format" xml:space="preserve">
<value>{0} successful hooked sessions</value>
</data>
<data name="Exception_State_Granted_Format" xml:space="preserve">
<value>Exception in force since {0}</value>
</data>
<data name="Exception_State_Eligible" xml:space="preserve">
<value>Eligible — no exception made</value>
</data>
<data name="Exception_State_Checking" xml:space="preserve">
<value>Checking…</value>
</data>
<data name="Exception_State_TooFew_Format" xml:space="preserve">
<value>Not eligible: {0} successful hooked session(s), two are needed</value>
</data>
<data name="Exception_State_Refused_Format" xml:space="preserve">
<value>Not eligible: the guard also found {0} ({1})</value>
</data>
<data name="Exception_State_NotUserMode_Format" xml:space="preserve">
<value>Not eligible: {0} is not user-mode throughout (it has a driver or a service), so FrameLedger never excepts it</value>
</data>
<data name="Exception_State_NotAsked" xml:space="preserve">
<value>Not eligible: this finding is not a module, file or folder of one anti-cheat</value>
</data>
<data name="Exception_State_CouldNotVerify" xml:space="preserve">
<value>Not eligible now: the check could not finish; it runs again by itself</value>
</data>
<data name="Exception_Lapsed_Format" xml:space="preserve">
<value>The last exception ended on {0}: {1}</value>
</data>
<data name="Exception_Lapse_Withdrawn" xml:space="preserve">
<value>you withdrew it</value>
</data>
<data name="Exception_Lapse_ExecutableChanged" xml:space="preserve">
<value>the game was updated</value>
</data>
<data name="Exception_Lapse_NoLongerEligible" xml:space="preserve">
<value>the game no longer qualifies</value>
</data>
<data name="Exception_Lapse_NewFinding" xml:space="preserve">
<value>new anti-cheat was found in the game</value>
</data>
<data name="Exception_Lapse_SafetyUnhook" xml:space="preserve">
<value>a session under it was stopped for safety</value>
</data>
<data name="Exception_Lapse_OverlayStopped" xml:space="preserve">
<value>FrameLedger stopped observing because another anti-cheat loaded</value>
</data>
<data name="Exception_Lapse_SessionCrashed" xml:space="preserve">
<value>a session under it crashed</value>
</data>
<data name="Exception_Result_Granted_Format" xml:space="preserve">
<value>Exception made for {0}. Turn hooking on for the game on its page when you want to measure it.</value>
</data>
<data name="Exception_Result_Withdrawn_Format" xml:space="preserve">
<value>Exception withdrawn for {0}; its hooking is off.</value>
</data>
<data name="Exception_Result_Refused_Format" xml:space="preserve">
<value>No exception was made for {0}: {1}</value>
</data>
<data name="GameDetail_Exception_Header" xml:space="preserve">
<value>User-mode exception</value>
</data>
<data name="GameDetail_Exception_Granted_Format" xml:space="preserve">
<value>Hooking may run under a user-mode exception for {0}. The guard still runs every check; a ban remains possible.</value>
</data>
<data name="GameDetail_Exception_Suspended" xml:space="preserve">
<value>An exception is kept for this game, but the option is off in Settings, so it does not apply.</value>
</data>
<data name="GameDetail_Exception_Grant" xml:space="preserve">
<value>Make exception…</value>
</data>
<data name="GameDetail_Exception_Withdraw" xml:space="preserve">
<value>Withdraw exception</value>
</data>
<data name="Settings_Exceptions_Refresh" xml:space="preserve">
<value>Refresh</value>
</data>
<data name="Settings_Exceptions_Checking" xml:space="preserve">
<value>The capture agent is checking your library; the games that qualify appear here within a minute. Refresh to see them.</value>
</data>
<data name="Tier_HookedException" xml:space="preserve">
<value>Hooked · exception</value>
</data>
<data name="Games_Card_Exception" xml:space="preserve">
<value>Exception</value>
</data>
<data name="Session_UnderException_Format" xml:space="preserve">
<value>Hooked under the user-mode exception for {0}</value>
</data>
</root>
+551 -5
View File
@@ -608,7 +608,7 @@
<value>Phiên gần nhất: {0} · {1}</value>
</data>
<data name="GameDetail_LifetimeAvg" xml:space="preserve">
<value>Trung bình toàn bộ</value>
<value>Phiên đo gần nhất</value>
</data>
<data name="GameDetail_Measured_Empty" xml:space="preserve">
<value>Chưa có phiên nào được đo.</value>
@@ -1097,10 +1097,10 @@
<value>VRAM game này dùng (MB)</value>
</data>
<data name="Sensors_Temps_Header" xml:space="preserve">
<value>Nhiệt độ và tải</value>
<value>Nhiệt độ, tải và công suất</value>
</data>
<data name="Sensors_Vram_Header" xml:space="preserve">
<value>VRAM</value>
<value>Bộ nhớ</value>
</data>
<data name="Tabs_SelectASession" xml:space="preserve">
<value>Chọn một phiên ở thẻ Phiên chơi để xem tại đây.</value>
@@ -1112,7 +1112,7 @@
<value>Phiên đã chọn không hook; không có khung hình để vẽ.</value>
</data>
<data name="Trend_Average_Note" xml:space="preserve">
<value>Trung bình là FPS gốc khi đã đo frame generation và FPS xuất khung khi chưa đo.</value>
<value>FPS gốc chỉ đếm khung hình của chính game và chỉ có ở các phiên đã đo được tạo khung hình. FPS được trình chiếu đếm mọi khung hình được trình chiếu, ở các phiên không đếm được khung hình tạo thêm.</value>
</data>
<data name="Trend_Axis_Date" xml:space="preserve">
<value>Ngày</value>
@@ -1903,9 +1903,555 @@ Các tài liệu bên dưới là điều khoản đầy đủ; phần tóm tắ
<value>Ẩn phần hooking ở game có anti-cheat</value>
</data>
<data name="Settings_HideAntiCheatHooking_Body" xml:space="preserve">
<value>Game được phát hiện có anti-cheat sẽ không bao giờ được hook. Bật: trang game chỉ hiện điều đã phát hiện; tắt: hiện thêm công tắc Hooking bị vô hiệu hoá. Dù bật hay tắt, game vẫn được ghi mà không hook.</value>
<value>Game được phát hiện có anti-cheat sẽ không được hook, trừ khi bạn tạo ngoại lệ user-mode cho nó (bên dưới). Bật: trang game chỉ hiện điều đã phát hiện; tắt: hiện thêm công tắc Hooking bị vô hiệu hoá. Dù bật hay tắt, game vẫn được ghi mà không hook.</value>
</data>
<data name="Notice_HookingOff_Title_Format" xml:space="preserve">
<value>{0}: đã tắt hooking</value>
</data>
<data name="Arch_X64" xml:space="preserve">
<value>64-bit (x64)</value>
</data>
<data name="Arch_X86" xml:space="preserve">
<value>32-bit (x86)</value>
</data>
<data name="Arch_Arm64" xml:space="preserve">
<value>ARM64</value>
</data>
<data name="Arch_Arm" xml:space="preserve">
<value>ARM (32-bit)</value>
</data>
<data name="Arch_AnyCpu" xml:space="preserve">
<value>.NET, mọi CPU (chạy ở 64-bit)</value>
</data>
<data name="Arch_AnyCpu32" xml:space="preserve">
<value>.NET, mọi CPU, ưu tiên 32-bit (chạy ở 32-bit)</value>
</data>
<data name="Arch_Other" xml:space="preserve">
<value>kiến trúc khác</value>
</data>
<data name="Arch_Unknown" xml:space="preserve">
<value>không đọc được</value>
</data>
<data name="Store_Steam_Format" xml:space="preserve">
<value>Steam build {0}</value>
</data>
<data name="Store_Gog_Format" xml:space="preserve">
<value>GOG phiên bản {0}</value>
</data>
<data name="Store_Epic_Format" xml:space="preserve">
<value>Epic phiên bản {0}</value>
</data>
<data name="GameDetail_Details_Header" xml:space="preserve">
<value>Chi tiết</value>
</data>
<data name="GameDetail_Details_Architecture" xml:space="preserve">
<value>Chạy ở dạng</value>
</data>
<data name="GameDetail_Details_FileVersion" xml:space="preserve">
<value>Phiên bản file</value>
</data>
<data name="GameDetail_Details_ProductVersion" xml:space="preserve">
<value>Phiên bản sản phẩm</value>
</data>
<data name="GameDetail_Details_Store" xml:space="preserve">
<value>Cửa hàng</value>
</data>
<data name="GameDetail_Details_Version" xml:space="preserve">
<value>Phiên bản</value>
</data>
<data name="GameDetail_Details_Engine" xml:space="preserve">
<value>Engine</value>
</data>
<data name="GameDetail_Details_Libraries" xml:space="preserve">
<value>Đi kèm</value>
</data>
<data name="GameDetail_Details_Library_Format" xml:space="preserve">
<value>{0}: {1} {2}</value>
</data>
<data name="GameDetail_Details_LibraryNoVersion_Format" xml:space="preserve">
<value>{0}: {1} (không có phiên bản)</value>
</data>
<data name="GameDetail_Details_NoLibraries" xml:space="preserve">
<value>không có file nào mà bộ luật nêu tên</value>
</data>
<data name="GameDetail_Details_NotRead" xml:space="preserve">
<value>Chưa đọc: capture agent sẽ đọc các file của game ngay sau khi nó khởi động.</value>
</data>
<data name="Hooking_NotX64_Format" xml:space="preserve">
<value>File thực thi của game này là {0}. Hook của FrameLedger chỉ chạy trong game 64-bit (x64), nên không thể bật hooking; các phiên của nó ghi thời gian chơi và cảm biến.</value>
</data>
<data name="Summary_Libraries_Format" xml:space="preserve">
<value>Đã nạp: {0}</value>
</data>
<data name="Summary_Library_Differs_Format" xml:space="preserve">
<value>{0} {1} (game kèm bản {2}: một bản khác đã được nạp, ví dụ bởi driver hoặc NVIDIA App)</value>
</data>
<data name="Nv_Profile_Format" xml:space="preserve">
<value>Profile NVIDIA “{0}”: {1}</value>
</data>
<data name="Nv_Profile_Global_Format" xml:space="preserve">
<value>Profile toàn cục của NVIDIA (không có profile riêng cho game này): {0}</value>
</data>
<data name="Nv_Override_None" xml:space="preserve">
<value>không ghi đè DLSS hay tạo khung hình</value>
</data>
<data name="Nv_Override_Sr" xml:space="preserve">
<value>Ghi đè DLSS</value>
</data>
<data name="Nv_Override_Rr" xml:space="preserve">
<value>Ghi đè Ray Reconstruction</value>
</data>
<data name="Nv_Override_Fg" xml:space="preserve">
<value>Ghi đè Frame Generation</value>
</data>
<data name="Nv_Override_Sl" xml:space="preserve">
<value>Ghi đè DLSS qua Streamline</value>
</data>
<data name="Nv_FgMode_Off" xml:space="preserve">
<value>tạo khung hình bị ép tắt</value>
</data>
<data name="Nv_FgMode_On" xml:space="preserve">
<value>tạo khung hình bị ép bật</value>
</data>
<data name="Nv_FgMode_Auto" xml:space="preserve">
<value>tạo khung hình tự động</value>
</data>
<data name="Nv_FgMode_Dynamic" xml:space="preserve">
<value>tạo khung hình động</value>
</data>
<data name="Nv_SmoothMotion" xml:space="preserve">
<value>Smooth Motion (setting do công cụ cộng đồng ghi nhận, không phải NVIDIA)</value>
</data>
<data name="Nv_Details_Format" xml:space="preserve">
<value>{0} ({1})</value>
</data>
<data name="Nv_Preset_Format" xml:space="preserve">
<value>preset {0}</value>
</data>
<data name="Nv_Preset_Latest" xml:space="preserve">
<value>preset mới nhất</value>
</data>
<data name="Nv_Preset_Default" xml:space="preserve">
<value>preset mặc định</value>
</data>
<data name="Nv_Mode_Performance" xml:space="preserve">
<value>Performance</value>
</data>
<data name="Nv_Mode_Balanced" xml:space="preserve">
<value>Balanced</value>
</data>
<data name="Nv_Mode_Quality" xml:space="preserve">
<value>Quality</value>
</data>
<data name="Nv_Mode_Dlaa" xml:space="preserve">
<value>DLAA</value>
</data>
<data name="Nv_Mode_UltraPerformance" xml:space="preserve">
<value>Ultra Performance</value>
</data>
<data name="Nv_Mode_Custom_Format" xml:space="preserve">
<value>tùy chỉnh {0}%</value>
</data>
<data name="Nv_Mode_Custom" xml:space="preserve">
<value>tỷ lệ tùy chỉnh</value>
</data>
<data name="Nv_Mfg_Format" xml:space="preserve">
<value>×{0}</value>
</data>
<data name="Nv_DynamicTarget_Format" xml:space="preserve">
<value>mục tiêu động {0} FPS</value>
</data>
<data name="Nv_DynamicTarget_Auto" xml:space="preserve">
<value>mục tiêu động tự động</value>
</data>
<data name="Nv_Driver_Format" xml:space="preserve">
<value>Driver NVIDIA, cho tiến trình của game này: {0}</value>
</data>
<data name="Nv_Driver_DllSelected" xml:space="preserve">
<value>DLL DLSS do driver chọn</value>
</data>
<data name="Nv_Driver_Ratio_Format" xml:space="preserve">
<value>tỷ lệ {0}</value>
</data>
<data name="GameDetail_Details_NvidiaOverride" xml:space="preserve">
<value>Ghi đè của NVIDIA App</value>
</data>
<data name="End_Running" xml:space="preserve">
<value>Phiên ghi có giới hạn thời gian và đã kết thúc khi game vẫn đang chạy.</value>
</data>
<data name="End_TargetExited" xml:space="preserve">
<value>Game đã thoát.</value>
</data>
<data name="End_SafetyUnhook" xml:space="preserve">
<value>Anti-cheat xuất hiện giữa phiên, nên việc đo đã dừng.</value>
</data>
<data name="End_SupervisionLost" xml:space="preserve">
<value>FrameLedger mất dấu tiến trình của game, nên việc đo đã dừng.</value>
</data>
<data name="End_WriterSelfDisabled" xml:space="preserve">
<value>Hook đo tự tắt sau nhiều lỗi liên tiếp, nên việc đo đã dừng.</value>
</data>
<data name="End_WriterStoppedBlocklisted" xml:space="preserve">
<value>Hook đo đã dừng vì một mô-đun trong danh sách chặn được nạp vào game.</value>
</data>
<data name="End_WriterNeverInstalledHooks" xml:space="preserve">
<value>Hook đo đã được nạp nhưng không tìm thấy API đồ hoạ nào để đo.</value>
</data>
<data name="End_RefusedHookNotEnabled" xml:space="preserve">
<value>Hooking đang tắt cho game này, nên không có gì được đo.</value>
</data>
<data name="End_RefusedConsentMissing" xml:space="preserve">
<value>Sự đồng ý hooking là cho một bản khác của file thực thi này, nên game không được hook.</value>
</data>
<data name="End_RefusedPreviouslyBlocked" xml:space="preserve">
<value>Anti-cheat đã được phát hiện trong game này trước đây, nên game không bao giờ được hook.</value>
</data>
<data name="End_RefusedByGuard" xml:space="preserve">
<value>Guard anti-cheat đã từ chối hook game này.</value>
</data>
<data name="End_PreScanCouldNotVerify" xml:space="preserve">
<value>FrameLedger không kiểm tra được các file của game để tìm anti-cheat, nên đã không hook.</value>
</data>
<data name="End_TargetNotRunning" xml:space="preserve">
<value>Game không chạy vào lúc phiên đáng lẽ bắt đầu.</value>
</data>
<data name="End_TargetCannotBePinned" xml:space="preserve">
<value>Không giữ được tiến trình của game, nên game không được đo.</value>
</data>
<data name="End_ExecutableUnreadable" xml:space="preserve">
<value>Không đọc được file thực thi của game: nó đã bị chuyển, bị xoá, hoặc ổ đĩa chứa nó chưa được kết nối.</value>
</data>
<data name="End_SupervisionFaulted" xml:space="preserve">
<value>Việc giám sát phiên bị lỗi, nên việc đo đã dừng.</value>
</data>
<data name="End_TargetAmbiguous" xml:space="preserve">
<value>Có nhiều hơn một tiến trình khớp với game này, nên không tiến trình nào được hook.</value>
</data>
<data name="End_AttachRefused" xml:space="preserve">
<value>Dữ liệu của hook đo không khớp với bản FrameLedger này, nên không có gì được đọc.</value>
</data>
<data name="End_LaunchCannotStart" xml:space="preserve">
<value>FrameLedger không khởi động được game.</value>
</data>
<data name="End_LaunchTargetExited" xml:space="preserve">
<value>Game đã thoát trước khi có thể đo.</value>
</data>
<data name="End_LaunchNoPresentationRuntime" xml:space="preserve">
<value>Game không nạp API đồ hoạ nào mà FrameLedger đo được (DirectX 9 trở về trước không được đo).</value>
</data>
<data name="End_RefusedKillSwitch" xml:space="preserve">
<value>Mọi hooking đang bị tắt trong Cài đặt, nên không có gì được đo.</value>
</data>
<data name="End_KillSwitchEngaged" xml:space="preserve">
<value>Mọi hooking đã bị tắt trong Cài đặt giữa phiên, nên việc đo đã dừng.</value>
</data>
<data name="End_StoppedByUser" xml:space="preserve">
<value>Bạn đã dừng phiên ghi.</value>
</data>
<data name="End_TargetUnreadable" xml:space="preserve">
<value>Không mở được tiến trình của game: một driver anti-cheat bảo vệ nó, hoặc nó chạy với quyền quản trị.</value>
</data>
<data name="Guard_Refused_Format" xml:space="preserve">
<value>Guard anti-cheat đã không hook game này: {0}.</value>
</data>
<data name="Guard_ModuleScanFailed" xml:space="preserve">
<value>không liệt kê đầy đủ được các mô-đun game đã nạp</value>
</data>
<data name="Guard_ProcessUnreadable" xml:space="preserve">
<value>không mở được tiến trình của game</value>
</data>
<data name="Guard_ProcessTreeUnavailable" xml:space="preserve">
<value>không xác định được cây tiến trình của game</value>
</data>
<data name="Guard_DriverScanFailed" xml:space="preserve">
<value>không liệt kê được các driver đã nạp</value>
</data>
<data name="Guard_ServiceQueryFailed" xml:space="preserve">
<value>không truy vấn được các dịch vụ anti-cheat</value>
</data>
<data name="Guard_RulesUnreadable" xml:space="preserve">
<value>không đọc được bộ luật anti-cheat</value>
</data>
<data name="Guard_RulesMalformed" xml:space="preserve">
<value>file luật anti-cheat bị hỏng</value>
</data>
<data name="Guard_RulesIncomplete" xml:space="preserve">
<value>file luật anti-cheat thiếu các mục bắt buộc</value>
</data>
<data name="Guard_PreScanFailed" xml:space="preserve">
<value>không quét được thư mục của game</value>
</data>
<data name="Guard_InjectionFailed" xml:space="preserve">
<value>mọi kiểm tra đều qua, nhưng không nạp được hook</value>
</data>
<data name="Guard_TargetIsWow64" xml:space="preserve">
<value>game là 32-bit, còn hook chỉ chạy trong game 64-bit</value>
</data>
<data name="Guard_PayloadNotOurs" xml:space="preserve">
<value>file hook không phải bản build của chính FrameLedger</value>
</data>
<data name="Guard_HookNotEnabled" xml:space="preserve">
<value>hooking đang tắt cho game này</value>
</data>
<data name="Guard_ConsentMissing" xml:space="preserve">
<value>chưa từng đồng ý hooking cho file thực thi này</value>
</data>
<data name="Guard_PreviouslyBlocked" xml:space="preserve">
<value>anti-cheat đã được phát hiện trong game này trước đây</value>
</data>
<data name="Guard_LaunchTargetExited" xml:space="preserve">
<value>game đã thoát trước khi kịp kiểm tra</value>
</data>
<data name="Guard_LaunchNoPresentationRuntime" xml:space="preserve">
<value>game không nạp API đồ hoạ nào mà FrameLedger đo được</value>
</data>
<data name="Guard_TargetIsVulkanLayered" xml:space="preserve">
<value>game kết xuất bằng Vulkan, thứ mà Vulkan layer đo thay</value>
</data>
<data name="Guard_SuspiciousUnsigned" xml:space="preserve">
<value>một mô-đun không ký số có tên giống anti-cheat đã được nạp</value>
</data>
<data name="Guard_Other_Format" xml:space="preserve">
<value>lý do {0}</value>
</data>
<data name="Exit_Line_Format" xml:space="preserve">
<value>Kết thúc: {0}</value>
</data>
<data name="Exit_Code_Format" xml:space="preserve">
<value>kết thúc với mã thoát {0}</value>
</data>
<data name="Exit_Code1" xml:space="preserve">
<value>kết thúc với mã thoát 1 — mã mà End task và taskkill để lại, cũng là mã lỗi thường gặp của nhiều chương trình</value>
</data>
<data name="Exit_Crashed_Format" xml:space="preserve">
<value>bị crash ({0})</value>
</data>
<data name="Exit_CrashEvent" xml:space="preserve">
<value>bị crash (Windows ghi nhận một lỗi ứng dụng)</value>
</data>
<data name="Exit_Ex_AccessViolation" xml:space="preserve">
<value>0xC0000005 truy cập bộ nhớ không hợp lệ</value>
</data>
<data name="Exit_Ex_InPageError" xml:space="preserve">
<value>0xC0000006 lỗi I/O khi nạp trang: một ổ đĩa bị lỗi khi game đọc file</value>
</data>
<data name="Exit_Ex_StackOverflow" xml:space="preserve">
<value>0xC00000FD tràn stack</value>
</data>
<data name="Exit_Ex_HeapCorruption" xml:space="preserve">
<value>0xC0000374 hỏng heap</value>
</data>
<data name="Exit_Ex_FailFast" xml:space="preserve">
<value>0xC0000409 fail-fast: game tự dừng khi phát hiện lỗi</value>
</data>
<data name="Exit_Ex_DllInit" xml:space="preserve">
<value>0xC0000142 một DLL khởi tạo thất bại</value>
</data>
<data name="Exit_Ex_DllNotFound" xml:space="preserve">
<value>0xC0000135 không tìm thấy một DLL cần thiết</value>
</data>
<data name="Exit_Ex_BadImage" xml:space="preserve">
<value>0xC000007B image không hợp lệ, thường do lẫn 32/64-bit</value>
</data>
<data name="Exit_Ex_Cpp" xml:space="preserve">
<value>0xE06D7363 ngoại lệ C++ không được xử lý</value>
</data>
<data name="Exit_Ex_Clr" xml:space="preserve">
<value>0xE0434352 ngoại lệ .NET không được xử lý</value>
</data>
<data name="Exit_Ex_Breakpoint" xml:space="preserve">
<value>0x80000003 breakpoint</value>
</data>
<data name="Launch_Error_Format" xml:space="preserve">
<value>lỗi Windows {0}</value>
</data>
<data name="Launch_Error_2" xml:space="preserve">
<value>không tìm thấy file</value>
</data>
<data name="Launch_Error_3" xml:space="preserve">
<value>không tìm thấy đường dẫn</value>
</data>
<data name="Launch_Error_5" xml:space="preserve">
<value>bị từ chối truy cập</value>
</data>
<data name="Launch_Error_193" xml:space="preserve">
<value>đây không phải chương trình Windows hợp lệ</value>
</data>
<data name="Launch_Error_740" xml:space="preserve">
<value>game yêu cầu quyền quản trị</value>
</data>
<data name="Launch_Failed_Format" xml:space="preserve">
<value>{0} ({1})</value>
</data>
<data name="Exe_DriveMissing_Format" xml:space="preserve">
<value>Ổ {0} chưa được kết nối. FrameLedger sẽ tìm lại game khi ổ được kết nối.</value>
</data>
<data name="Exe_FileMissing_Format" xml:space="preserve">
<value>File thực thi của game không còn ở {0}.</value>
</data>
<data name="Exit_EndedNormally" xml:space="preserve">
<value>kết thúc bình thường</value>
</data>
<data name="Settings_FpsDecimals_Label" xml:space="preserve">
<value>Hiển thị FPS với hai chữ số thập phân</value>
</data>
<data name="Settings_FpsDecimals_Body" xml:space="preserve">
<value>Mọi con số FPS — trung bình, low, xu hướng — hiển thị hai chữ số thập phân (62,40) thay vì số nguyên (62). Các trang áp dụng ở lần tải tiếp theo.</value>
</data>
<data name="Fps_Fg_Steady_Format" xml:space="preserve">
<value>{0} → {1} FPS (×{2:0.0} FG · {3:0}%)</value>
</data>
<data name="Trend_Metric_NativeFps" xml:space="preserve">
<value>FPS gốc (Native)</value>
</data>
<data name="Trend_Metric_PresentedFps" xml:space="preserve">
<value>FPS được trình chiếu (Presented)</value>
</data>
<data name="Trend_Partial_Note" xml:space="preserve">
<value>Điểm rỗng chỉ mô tả một phần phiên của nó: cài đặt đã đổi giữa phiên, hoặc giá trị là của trạng thái ổn định.</value>
</data>
<data name="Trend_Empty_Format" xml:space="preserve">
<value>Chưa có phiên nào của game này có giá trị cho {0}.</value>
</data>
<data name="Chart_Series_AppFrames" xml:space="preserve">
<value>Khung hình ứng dụng</value>
</data>
<data name="Chart_Series_Presents" xml:space="preserve">
<value>Lần xuất khung</value>
</data>
<data name="Chart_Note_NoApplicationFrames" xml:space="preserve">
<value>Phiên này đếm frame generation nhưng không có khung hình ứng dụng nào, nên biểu đồ vẽ mọi lần xuất khung.</value>
</data>
<data name="Chart_Note_PresentsTiming" xml:space="preserve">
<value>Mỗi lần xuất khung được đo lúc game gửi đi. Khung hình sinh thường được gửi dồn một lúc rồi mới hiển thị đều, nên đường Hiển thị không phải nhịp của màn hình.</value>
</data>
<data name="Chart_Note_GapsClosed_Format" xml:space="preserve">
<value>Trục thời gian bỏ qua {0} khoảng trống (tạm dừng, hoặc bản ghi bị mất), nên đường cảm biến chạy trước khung hình sau mỗi khoảng.</value>
</data>
<data name="Chart_Note_OutsideRange_Format" xml:space="preserve">
<value>{0} khung hình nằm ngoài khoảng phân vị 0,5–99,5 không được vẽ trong biểu đồ tần suất.</value>
</data>
<data name="Chart_Axis_TimeFromFirstFrame" xml:space="preserve">
<value>Thời gian từ khung hình đầu (s)</value>
</data>
<data name="Chart_Axis_TimeFromStart" xml:space="preserve">
<value>Thời gian từ lúc bắt đầu phiên (s)</value>
</data>
<data name="Sensors_Axis_Watts" xml:space="preserve">
<value>W</value>
</data>
<data name="Settings_Exceptions_Label" xml:space="preserve">
<value>Cho phép hooking ở game có anti-cheat user-mode đã từng đo thành công</value>
</data>
<data name="Settings_Exceptions_Body" xml:space="preserve">
<value>Mặc định tắt. Khi bật, game có anti-cheat duy nhất chạy ở user mode — không có kernel driver, không phát hiện gì khác — và đã được đo ở chế độ hook ít nhất hai lần có thể được cấp ngoại lệ bên dưới, từng game một, sau một bản công bố rủi ro. Bộ bảo vệ vẫn chạy mọi bước kiểm tra, và vẫn có thể bị khoá tài khoản.</value>
</data>
<data name="Settings_Exceptions_Header" xml:space="preserve">
<value>Ngoại lệ user-mode</value>
</data>
<data name="Settings_Exceptions_Empty" xml:space="preserve">
<value>Không có game nào trong thư viện đủ điều kiện.</value>
</data>
<data name="Settings_Exceptions_Suspended" xml:space="preserve">
<value>Tuỳ chọn đang tắt: các ngoại lệ bên dưới được giữ lại nhưng không có hiệu lực.</value>
</data>
<data name="Settings_Exceptions_Grant" xml:space="preserve">
<value>Tạo ngoại lệ…</value>
</data>
<data name="Settings_Exceptions_Withdraw" xml:space="preserve">
<value>Rút lại</value>
</data>
<data name="Exception_Finding_Format" xml:space="preserve">
<value>{0} — {1}</value>
</data>
<data name="Exception_Sessions_Format" xml:space="preserve">
<value>{0} phiên hook thành công</value>
</data>
<data name="Exception_State_Granted_Format" xml:space="preserve">
<value>Ngoại lệ có hiệu lực từ {0}</value>
</data>
<data name="Exception_State_Eligible" xml:space="preserve">
<value>Đủ điều kiện — chưa tạo ngoại lệ</value>
</data>
<data name="Exception_State_Checking" xml:space="preserve">
<value>Đang kiểm tra…</value>
</data>
<data name="Exception_State_TooFew_Format" xml:space="preserve">
<value>Chưa đủ điều kiện: {0} phiên hook thành công, cần hai</value>
</data>
<data name="Exception_State_Refused_Format" xml:space="preserve">
<value>Không đủ điều kiện: bộ bảo vệ còn phát hiện {0} ({1})</value>
</data>
<data name="Exception_State_NotUserMode_Format" xml:space="preserve">
<value>Không đủ điều kiện: {0} không chạy hoàn toàn ở user mode (có driver hoặc service), nên FrameLedger không bao giờ cấp ngoại lệ</value>
</data>
<data name="Exception_State_NotAsked" xml:space="preserve">
<value>Không đủ điều kiện: phát hiện này không phải module, tệp hay thư mục của một anti-cheat</value>
</data>
<data name="Exception_State_CouldNotVerify" xml:space="preserve">
<value>Hiện chưa đủ điều kiện: lần kiểm tra không hoàn tất; nó sẽ tự chạy lại</value>
</data>
<data name="Exception_Lapsed_Format" xml:space="preserve">
<value>Ngoại lệ gần nhất đã kết thúc ngày {0}: {1}</value>
</data>
<data name="Exception_Lapse_Withdrawn" xml:space="preserve">
<value>bạn đã rút lại</value>
</data>
<data name="Exception_Lapse_ExecutableChanged" xml:space="preserve">
<value>game đã được cập nhật</value>
</data>
<data name="Exception_Lapse_NoLongerEligible" xml:space="preserve">
<value>game không còn đủ điều kiện</value>
</data>
<data name="Exception_Lapse_NewFinding" xml:space="preserve">
<value>phát hiện anti-cheat mới trong game</value>
</data>
<data name="Exception_Lapse_SafetyUnhook" xml:space="preserve">
<value>một phiên dưới ngoại lệ bị dừng vì an toàn</value>
</data>
<data name="Exception_Lapse_OverlayStopped" xml:space="preserve">
<value>FrameLedger ngừng quan sát vì một anti-cheat khác được nạp</value>
</data>
<data name="Exception_Lapse_SessionCrashed" xml:space="preserve">
<value>một phiên dưới ngoại lệ bị crash</value>
</data>
<data name="Exception_Result_Granted_Format" xml:space="preserve">
<value>Đã tạo ngoại lệ cho {0}. Khi muốn đo, hãy bật hooking cho game trên trang của nó.</value>
</data>
<data name="Exception_Result_Withdrawn_Format" xml:space="preserve">
<value>Đã rút ngoại lệ cho {0}; hooking của nó đã tắt.</value>
</data>
<data name="Exception_Result_Refused_Format" xml:space="preserve">
<value>Không tạo ngoại lệ cho {0}: {1}</value>
</data>
<data name="GameDetail_Exception_Header" xml:space="preserve">
<value>Ngoại lệ user-mode</value>
</data>
<data name="GameDetail_Exception_Granted_Format" xml:space="preserve">
<value>Hooking có thể chạy dưới ngoại lệ user-mode cho {0}. Bộ bảo vệ vẫn chạy mọi bước kiểm tra; vẫn có thể bị khoá tài khoản.</value>
</data>
<data name="GameDetail_Exception_Suspended" xml:space="preserve">
<value>Game này có ngoại lệ được giữ lại, nhưng tuỳ chọn đang tắt trong Cài đặt nên nó không có hiệu lực.</value>
</data>
<data name="GameDetail_Exception_Grant" xml:space="preserve">
<value>Tạo ngoại lệ…</value>
</data>
<data name="GameDetail_Exception_Withdraw" xml:space="preserve">
<value>Rút ngoại lệ</value>
</data>
<data name="Settings_Exceptions_Refresh" xml:space="preserve">
<value>Làm mới</value>
</data>
<data name="Settings_Exceptions_Checking" xml:space="preserve">
<value>Capture agent đang kiểm tra thư viện; các game đủ điều kiện sẽ hiện ở đây trong vòng một phút. Bấm Làm mới để xem.</value>
</data>
<data name="Tier_HookedException" xml:space="preserve">
<value>Hook · ngoại lệ</value>
</data>
<data name="Games_Card_Exception" xml:space="preserve">
<value>Ngoại lệ</value>
</data>
<data name="Session_UnderException_Format" xml:space="preserve">
<value>Được hook dưới ngoại lệ user-mode cho {0}</value>
</data>
</root>
@@ -17,5 +17,6 @@
<Color x:Key="Chart_SensorSecondary">#FFE0C060</Color>
<Color x:Key="Chart_Segment">#2260CDFF</Color>
<Color x:Key="Chart_Histogram">#CC4CC2FF</Color>
<Color x:Key="Chart_Percentile">#FFFFC857</Color>
<!-- Not a second gold beside Chart_SensorSecondary (beta.8): the Sensors tab draws both. -->
<Color x:Key="Chart_Percentile">#FFFF79C6</Color>
</ResourceDictionary>
@@ -13,5 +13,6 @@
<Color x:Key="Chart_SensorSecondary">#FFB8860B</Color>
<Color x:Key="Chart_Segment">#1A0A6FB3</Color>
<Color x:Key="Chart_Histogram">#CC0A6FB3</Color>
<Color x:Key="Chart_Percentile">#FFB8860B</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>
</ResourceDictionary>
@@ -0,0 +1,53 @@
using System.Globalization;
using CommunityToolkit.Mvvm.ComponentModel;
using FrameLedger.App.Services;
using SafetyStrings = FrameLedger.Shared.Strings;
namespace FrameLedger.App.ViewModels;
/// <summary>
/// D33's disclosure content (<c>19_SAFETY</c> §The user-mode exception): why the exception is offered, the risk at the same
/// grain as FR-2.1's dialog, what is still refused, how it ends, and that it turns nothing on. <see cref="Accepted"/> — the
/// user ticking "I accept the risk of a ban for this game" — is the one thing that enables the dialog's primary button.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime; a cached CompositeFormat would pin the first culture")]
public sealed partial class AntiCheatExceptionDialogViewModel : ObservableObject
{
[ObservableProperty]
private bool _accepted;
public AntiCheatExceptionDialogViewModel(AntiCheatExceptionFacts facts)
{
ArgumentNullException.ThrowIfNull(facts);
Facts = facts;
Title = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Exception_Title_Format, facts.GameName);
Intro = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Exception_Intro_Format, facts.Family, facts.Signal);
Why = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Exception_Why_Format, facts.Family, facts.Sessions);
Risk = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Exception_Risk_Format, facts.Family);
Still = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Exception_Still_Format, facts.Family);
}
public AntiCheatExceptionFacts Facts { get; }
public string Title { get; }
public string Intro { get; }
public string Why { get; }
public string Risk { get; }
public string Still { get; }
public static string Ends => SafetyStrings.Safety_Exception_Ends;
public static string Next => SafetyStrings.Safety_Exception_Next;
public static string Online => SafetyStrings.Safety_Exception_Online;
public static string AcceptText => SafetyStrings.Safety_Exception_Accept;
public static string GrantText => SafetyStrings.Safety_Exception_Grant;
public static string CancelText => SafetyStrings.Safety_Exception_Cancel;
}
@@ -124,7 +124,7 @@ public sealed partial class CompareViewModel : ObservableObject
return;
}
await Task.Run(() => plot.SavePng(path, 1600, 800)).ConfigureAwait(true);
await Task.Run(() => Charts.ChartTheme.SavePng(plot, path, 1600, 800)).ConfigureAwait(true);
_strip.Success(Strings.Compare_Header, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Exported_Format, path));
});
}
@@ -187,18 +187,30 @@ public sealed partial class CompareViewModel : ObservableObject
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_MaxGpuTemp, rows, static r => r.MaxGpuTemp, Formats.Temperature, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_AvgGpuLoad, rows, static r => r.AvgGpuLoad, Formats.Percent, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_AvgCpuLoad, rows, static r => r.AvgCpuLoad, Formats.Percent, 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.
Rows.Add(Row(Strings.Compare_Metric_AvgGpuLoad, rows, static r => r.AvgGpuLoad, Formats.Percent, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_AvgCpuLoad, rows, static r => r.AvgCpuLoad, Formats.Percent, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_MaxCpuTemp, rows, static r => r.MaxCpuTemp, Formats.Temperature, higherIsBetter: false));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Duration, [.. rows.Select(static r => new CompareCell(Formats.Duration(r.DurationSeconds), false))]));
}
/// <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.</summary>
internal static CompareRowViewModel Row(string metric, IReadOnlyList<SessionRow> rows, Func<SessionRow, double?> value, Func<double?, string> text, bool higherIsBetter)
/// <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)
{
double?[] values = [.. rows.Select(value)];
double? best = higherIsBetter ? values.Where(static v => v.HasValue).Max() : values.Where(static v => v.HasValue).Min();
return new CompareRowViewModel(metric, [.. values.Select(v => new CompareCell(text(v), best.HasValue && v.HasValue && v.Value == best.Value))]);
double? best = higherIsBetter switch
{
true => values.Where(static v => v.HasValue).Max(),
false => values.Where(static v => v.HasValue).Min(),
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)))]);
}
private void OnCandidateChanged(object? sender, PropertyChangedEventArgs e)
@@ -72,6 +72,9 @@ public sealed partial class EditGameViewModel : ObservableObject
private static string? Blank(string value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
/// <summary>Whether <paramref name="field"/> of <c>field_provenance</c> is badged <c>detected</c> (a store or the detection sweep wrote it).</summary>
internal static bool IsDetectedField(string? provenanceJson, string field) => IsDetected(ParseProvenance(provenanceJson), field);
private static bool IsDetected(Dictionary<string, string> provenance, string field) =>
provenance.TryGetValue(field, out string? p) && string.Equals(p, "detected", StringComparison.Ordinal);
@@ -0,0 +1,52 @@
using System.Globalization;
using CommunityToolkit.Mvvm.Input;
using FrameLedger.App.Services;
namespace FrameLedger.App.ViewModels;
/// <summary>
/// One row of Settings ▸ Capture's user-mode exception list (D33): the game, what was found, the evidence, the state — and
/// the one action the state allows, making the exception (through its disclosure) or withdrawing it.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public sealed partial class ExceptionGameViewModel
{
private readonly Func<ExceptionGameViewModel, Task> _grant;
private readonly Func<ExceptionGameViewModel, Task> _withdraw;
public ExceptionGameViewModel(long gameId, string name, ExceptionView view, Func<ExceptionGameViewModel, Task> grant, Func<ExceptionGameViewModel, Task> withdraw)
{
ArgumentNullException.ThrowIfNull(view);
GameId = gameId;
Name = name ?? throw new ArgumentNullException(nameof(name));
View = view;
_grant = grant ?? throw new ArgumentNullException(nameof(grant));
_withdraw = withdraw ?? throw new ArgumentNullException(nameof(withdraw));
FindingText = string.Format(CultureInfo.CurrentCulture, Strings.Exception_Finding_Format, view.Family ?? Strings.Common_NotAvailable, view.Signal ?? Strings.Common_NotAvailable);
SessionsText = string.Format(CultureInfo.CurrentCulture, Strings.Exception_Sessions_Format, view.Sessions);
}
public long GameId { get; }
public string Name { get; }
public ExceptionView View { get; }
public string FindingText { get; }
public string SessionsText { get; }
public string StateText => View.Text;
public string? LapseText => View.LapseText;
public bool CanGrant => View.CanGrant;
public bool CanWithdraw => View.CanWithdraw;
[RelayCommand]
private Task GrantAsync() => _grant(this);
[RelayCommand]
private Task WithdrawAsync() => _withdraw(this);
}
@@ -25,7 +25,11 @@ public sealed class GameCardViewModel
// An entry the guard found anti-cheat in says so (beta.8): its hooking is off for good, and "Hooking off" read as
// a switch the user could still flip. Not recorded still comes first — nothing runs for it at all.
AntiCheat = Recorded && card.Row.BlockedByGuard;
// D33: a blocked game with a user-mode exception on its row says so; whether Settings' option lets it apply is the
// game page's to say.
Excepted = AntiCheat && card.Row.AcException.IsGranted;
HookText = !Recorded ? Strings.Games_Card_NotRecorded
: Excepted ? Strings.Games_Card_Exception
: AntiCheat ? Strings.Games_Card_AntiCheat
: HookOn ? Strings.Games_Card_HookOn : Strings.Games_Card_HookOff;
SessionCount = card.Summary?.SessionCount ?? 0;
@@ -63,6 +67,9 @@ public sealed class GameCardViewModel
/// </summary>
public bool AntiCheat { get; }
/// <summary>D33: the anti-cheat game carries a user-mode exception (<c>games.ac_exception_at</c>); the pill says "Exception".</summary>
public bool Excepted { get; }
public string HookText { get; }
public long SessionCount { get; }
@@ -0,0 +1,4 @@
namespace FrameLedger.App.ViewModels;
/// <summary>One line of the game page's Details card (beta.8): a label and what the game's files — or its store — say.</summary>
public sealed record GameDetailRow(string Label, string Value);
@@ -11,8 +11,10 @@ using FrameLedger.App.Services;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.Settings;
using FrameLedger.Application.TriState;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Sessions;
using FrameLedger.Infrastructure.Io;
using FrameLedger.Shared.Ipc;
using Wpf.Ui.Controls;
namespace FrameLedger.App.ViewModels;
@@ -34,13 +36,20 @@ public sealed partial class GameDetailViewModel : ObservableObject
private readonly IMessageStrip _strip;
private readonly ISessionSummaryOpener _summaries;
private readonly SessionSeriesLoader _loader;
private readonly IAgentLink? _agent;
private readonly UiThread _ui = new();
private bool _attached;
private readonly IHardwareSnapshotRepository _hardware;
private readonly SessionSelection _selection;
private readonly RegisteredSettings? _settings;
private readonly AntiCheatExceptions? _exceptions;
private readonly long? _gameId;
// ui.hide_anticheat_hooking (2026-09-25), read at each load; on until the settings say otherwise, as its default is.
private bool _hideAntiCheatHooking = true;
// hooking.usermode_ac_exceptions (D33, 2026-09-26), read at each load; off until the settings say otherwise.
private bool _exceptionsOn;
private GameDetail? _detail;
[ObservableProperty]
@@ -102,6 +111,39 @@ public sealed partial class GameDetailViewModel : ObservableObject
[ObservableProperty]
private bool _hookingSectionVisible = true;
/// <summary>
/// D33: the user-mode exception's card on a blocked game — shown while the option is on, and for an exception kept while
/// it is off; its state is the Agent's (<see cref="ExceptionView"/>).
/// </summary>
[ObservableProperty]
private bool _exceptionCardVisible;
[ObservableProperty]
private string? _exceptionText;
/// <summary>D33: what an exception in force means, on the page it applies to; null otherwise.</summary>
[ObservableProperty]
private string? _exceptionInForceText;
[ObservableProperty]
private string? _exceptionSuspendedText;
[ObservableProperty]
private string? _exceptionLapseText;
[ObservableProperty]
private bool _canGrantException;
[ObservableProperty]
private bool _canWithdrawException;
/// <summary>
/// Why the switch cannot be turned on when the executable cannot run as x64 (beta.8, <c>exe_machine</c>); null otherwise.
/// A switch that is on for such a game can still be turned off.
/// </summary>
[ObservableProperty]
private string? _notX64Text;
[ObservableProperty]
private string? _autoDisabledText;
@@ -132,6 +174,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
[ObservableProperty]
private bool _selectedHasSeries;
/// <summary>The Sensors tab's note: why nothing is drawn there, or empty.</summary>
[ObservableProperty]
private string _sensorsNote = Strings.Tabs_SelectASession;
[ObservableProperty]
private bool _selectedHasSensors;
[ObservableProperty]
private string _latencyText = string.Empty;
@@ -139,7 +188,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
private bool _hasLatency;
[ObservableProperty]
private TrendMetric _trendMetric = TrendMetric.Average;
private TrendMetric _trendMetric = TrendMetric.PresentedFps;
[ObservableProperty]
private bool _includeMidSession;
@@ -153,9 +202,11 @@ public sealed partial class GameDetailViewModel : ObservableObject
public GameDetailViewModel(GameLibrary library, GameSelection selection, HookingConsent consent, IPageNavigator navigator,
IConfirmations confirmations, IEditGamePrompt edit, IMessageStrip strip, ISessionSummaryOpener summaries,
SessionSeriesLoader loader, IHardwareSnapshotRepository hardware, SessionSelection sessionSelection, IGamePicker picker,
RegisteredSettings? settings = null)
RegisteredSettings? settings = null, IAgentLink? agent = null, AntiCheatExceptions? exceptions = null)
{
_exceptions = exceptions;
_settings = settings;
_agent = agent;
_picker = picker ?? throw new ArgumentNullException(nameof(picker));
_selection = sessionSelection ?? throw new ArgumentNullException(nameof(sessionSelection));
_library = library ?? throw new ArgumentNullException(nameof(library));
@@ -174,6 +225,12 @@ public sealed partial class GameDetailViewModel : ObservableObject
public static string BackText => Strings.GameDetail_Back;
public static string ExceptionHeader => Strings.GameDetail_Exception_Header;
public static string GrantExceptionText => Strings.GameDetail_Exception_Grant;
public static string WithdrawExceptionText => Strings.GameDetail_Exception_Withdraw;
public static string EditText => Strings.GameDetail_Edit;
public static string RemoveText => Strings.GameDetail_Remove;
@@ -182,6 +239,14 @@ public sealed partial class GameDetailViewModel : ObservableObject
public static string ExecutableMissingText => Strings.GameDetail_ExeMissing;
/// <summary>
/// The missing executable's bar (beta.8): the page's sentence, then whether the DRIVE is not connected or the file is gone
/// from its path — the two need different things of the user.
/// </summary>
public string ExecutableMissingMessage => Game is null
? ExecutableMissingText
: ExecutableMissingText + " " + Formats.ExecutableMissingText(Game.Fingerprint.ExePath);
public static string LifetimeLabel => Strings.GameDetail_LifetimeAvg;
public static string SupportsHeader => Strings.GameDetail_Supports_Header;
@@ -198,6 +263,11 @@ public sealed partial class GameDetailViewModel : ObservableObject
public static string AntiCheatHeader => Strings.GameDetail_AntiCheat_Header;
public static string DetailsHeader => Strings.GameDetail_Details_Header;
/// <summary>What the game's files and its store say about it (beta.8): what it runs as, its versions, what it ships.</summary>
public ObservableCollection<GameDetailRow> Details { get; } = [];
public static string HookingBody => Strings.GameDetail_Hooking_Body;
public static string ReEnableText => Strings.GameDetail_Hooking_ReEnable;
@@ -228,15 +298,26 @@ public sealed partial class GameDetailViewModel : ObservableObject
public static string TrendAverageNote => Strings.Trend_Average_Note;
public static string TrendPartialNote => Strings.Trend_Partial_Note;
/// <summary>Why the trend is empty FOR THIS METRIC (beta.8): "no hooked session yet" was wrong for a game whose sessions simply lack it.</summary>
[ObservableProperty]
private string _trendEmptyMessage = Strings.Trend_Empty;
public static string LatencyHeader => Strings.Latency_Header;
public static string LatencyEmptyText => Strings.Latency_Empty;
public static string SensorsEmptyText => Strings.Sensors_Empty;
public static IReadOnlyList<Choice<TrendMetric>> TrendMetrics { get; } =
/// <summary>
/// The selector's entries, built for each page in the language it opens in (beta.8: a static list kept the language the
/// App started in).
/// </summary>
public IReadOnlyList<Choice<TrendMetric>> TrendMetrics { get; } =
[
new(TrendMetric.Average, Strings.Trend_Metric_Average),
new(TrendMetric.PresentedFps, Strings.Trend_Metric_PresentedFps),
new(TrendMetric.NativeFps, Strings.Trend_Metric_NativeFps),
new(TrendMetric.Displayed, Strings.Trend_Metric_Displayed),
new(TrendMetric.P1Low, Strings.Trend_Metric_P1Low),
new(TrendMetric.P01Low, Strings.Trend_Metric_P01Low),
@@ -253,6 +334,12 @@ public sealed partial class GameDetailViewModel : ObservableObject
/// <summary>The selected session's decoded series (null: none selected, Tier 2, or swept).</summary>
public SessionSeries? SelectedSeries { get; private set; }
/// <summary>
/// What the Sensors tab draws: the selected session's series, or — for a session that was not hooked — its sensors alone
/// (beta.8: a Tier-2 row has kept them since 2026-09-22, and the tab said "not hooked" over them).
/// </summary>
public SessionSeries? SelectedSensors { get; private set; }
public IReadOnlyList<TrendPoint> TrendPoints { get; private set; } = [];
public IReadOnlyList<HardwareChange> HardwareChanges { get; private set; } = [];
@@ -296,9 +383,11 @@ public sealed partial class GameDetailViewModel : ObservableObject
if (_settings is not null)
{
_hideAntiCheatHooking = await _settings.GetBooleanAsync(SettingsRegistry.UiHideAntiCheatHooking, ct).ConfigureAwait(true);
_exceptionsOn = await _settings.GetBooleanAsync(SettingsRegistry.HookingUserModeExceptions, ct).ConfigureAwait(true);
}
Present(detail);
ChooseDefaultMetric(detail);
await RebuildTrendAsync(ct).ConfigureAwait(true);
}
@@ -308,13 +397,72 @@ public sealed partial class GameDetailViewModel : ObservableObject
Pending = LoadSelectedAsync(value);
}
partial void OnTrendMetricChanged(TrendMetric value) => RebuildTrendPoints();
partial void OnTrendMetricChanged(TrendMetric value)
{
_trendMetricChosen |= !_choosingDefaultMetric;
RebuildTrendPoints();
}
private bool _trendMetricChosen;
private bool _choosingDefaultMetric;
/// <summary>
/// The first metric a game's trend opens on (beta.8): Presented FPS, unless the game's newest measured session counted
/// generated frames — then Native FPS, the rate such sessions have. Kept once the user picks one.
/// </summary>
private void ChooseDefaultMetric(GameDetail detail)
{
if (_trendMetricChosen)
{
return;
}
SessionRow? newest = detail.Sessions.FirstOrDefault(static s => s.Tier == CaptureTier.Hooked && s.FrameCount > 0);
_choosingDefaultMetric = true;
TrendMetric = newest is not null && FpsPresentation.FromRow(newest).Kind == FpsReadoutKind.Generated ? TrendMetric.NativeFps : TrendMetric.PresentedFps;
_choosingDefaultMetric = false;
}
partial void OnIncludeMidSessionChanged(bool value) => RebuildTrendPoints();
/// <summary>
/// Listens to the Agent while the page is on screen (beta.8): a session of this game that finishes reloads the page, so
/// its sessions, trend and header include it — they were the ones the page opened with until it was left and reopened.
/// The page calls it on Loaded and <see cref="Detach"/> on Unloaded; the link is a singleton and must not hold the page.
/// </summary>
public void Attach()
{
if (_agent is not null && !_attached)
{
_agent.EventReceived += OnAgentEvent;
_attached = true;
}
}
public void Detach()
{
if (_agent is not null && _attached)
{
_agent.EventReceived -= OnAgentEvent;
_attached = false;
}
}
private void OnAgentEvent(object? sender, AgentEventArgs e) => _ui.Post(() =>
{
if (string.Equals(e.Envelope.Type, IpcMessageType.SessionCompleted, StringComparison.Ordinal)
&& IpcCodec.Payload<SessionCompletedEvent>(e.Envelope) is { SessionId: not null } completed
&& completed.GameId is long game && game == _gameId)
{
Pending = LoadAsync();
}
});
private async Task LoadSelectedAsync(SessionItemViewModel? session)
{
SelectedSeries = null;
SelectedSensors = null;
HasLatency = false;
LatencyText = string.Empty;
if (session is null)
@@ -324,11 +472,14 @@ public sealed partial class GameDetailViewModel : ObservableObject
else if (!session.IsHooked)
{
SelectedNote = Strings.Tabs_SelectedNotHooked;
IReadOnlyList<SensorSeries> sensors = await _loader.LoadSensorsAsync(session.Id).ConfigureAwait(true);
SelectedSensors = sensors.Count > 0 ? SessionSeries.SensorsOnly(sensors) : null;
}
else
{
SelectedSeries = await _loader.LoadAsync(session.Id).ConfigureAwait(true);
SelectedNote = SelectedSeries is null ? Strings.Tabs_SelectedNoFrames : string.Empty;
SelectedSensors = SelectedSeries;
HasLatency = SelectedSeries?.LatencyUs is { Length: > 0 } && session.Row.ReflexActive == true;
LatencyText = HasLatency && session.Row.LatencyAvgUs is long avg && session.Row.LatencyP95Us is long p95
? string.Format(CultureInfo.CurrentCulture, Strings.Latency_Stats_Format, avg / 1000.0, p95 / 1000.0)
@@ -336,6 +487,11 @@ public sealed partial class GameDetailViewModel : ObservableObject
}
SelectedHasSeries = SelectedSeries is not null;
SelectedHasSensors = SelectedSensors is { } shown && (shown.Sensors.Count > 0 || shown.VramProcMb is { Length: > 0 });
SensorsNote = session is null ? Strings.Tabs_SelectASession
: SelectedHasSensors ? string.Empty
: session.IsHooked && SelectedSeries is null ? Strings.Tabs_SelectedNoFrames
: Strings.Sensors_Empty;
SelectionPresented?.Invoke(this, EventArgs.Empty);
}
@@ -368,6 +524,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
int excluded = IncludeMidSession ? 0 : TrendSeriesBuilder.ExcludedCount(_detail.Sessions, TrendMetric);
TrendExcludedText = excluded > 0 ? string.Format(CultureInfo.CurrentCulture, Strings.Trend_Excluded_Format, excluded) : string.Empty;
TrendEmpty = TrendPoints.Count == 0;
TrendEmptyMessage = string.Format(CultureInfo.CurrentCulture, Strings.Trend_Empty_Format, TrendMetricText);
OnPropertyChanged(nameof(TrendMetricText));
TrendPresented?.Invoke(this, EventArgs.Empty);
}
@@ -391,6 +548,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
[RelayCommand]
private Task ToggleRecordingAsync() => RunAsync(ToggleRecordingCoreAsync);
/// <summary>D33: the exception's disclosure, then the request; the Agent gathers the facts and grants or refuses.</summary>
[RelayCommand]
private Task GrantExceptionAsync() => RunAsync(GrantExceptionCoreAsync);
[RelayCommand]
private Task WithdrawExceptionAsync() => RunAsync(WithdrawExceptionCoreAsync);
[RelayCommand]
private Task ReEnableHookingAsync() => RunAsync(EnableAsync);
@@ -552,6 +716,61 @@ public sealed partial class GameDetailViewModel : ObservableObject
_navigator.Navigate<GamesPage>();
}
private async Task GrantExceptionCoreAsync()
{
if (Game is null || ExceptionView.Of(Game) is not { CanGrant: true } view)
{
return;
}
Busy = true;
try
{
AntiCheatExceptionResult result = _exceptions is null
? AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable)
: await _exceptions.GrantAsync(Game.Id, new AntiCheatExceptionFacts(Game.Name, view.Family ?? string.Empty, view.Signal ?? string.Empty,
view.Sessions)).ConfigureAwait(true);
Notice(result, Game.Name);
}
finally
{
Busy = false;
}
await LoadAsync().ConfigureAwait(true);
}
private async Task WithdrawExceptionCoreAsync()
{
if (Game is null)
{
return;
}
Busy = true;
try
{
AntiCheatExceptionResult result = _exceptions is null
? AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable)
: await _exceptions.WithdrawAsync(Game.Id).ConfigureAwait(true);
Notice(result, Game.Name);
}
finally
{
Busy = false;
}
await LoadAsync().ConfigureAwait(true);
}
/// <summary>D33: an exception's outcome as this page's notice — a success is said, not only shown by the card changing.</summary>
private void Notice(AntiCheatExceptionResult result, string gameName)
{
NoticeText = result.MessageFor(gameName);
NoticeSeverity = result.Succeeded ? InfoBarSeverity.Success : InfoBarSeverity.Warning;
OnPropertyChanged(nameof(NoticeVisible));
}
/// <summary>A refusal, a mismatch or a failure is a persistent notice on the page; a success clears it.</summary>
private void Notice(HookingConsentResult result)
{
@@ -560,6 +779,9 @@ public sealed partial class GameDetailViewModel : ObservableObject
HookingConsentOutcome.Refused => (result.RefusalText(), InfoBarSeverity.Error),
HookingConsentOutcome.VersionMismatch => (Shared.Strings.Safety_Consent_VersionMismatch, InfoBarSeverity.Warning),
HookingConsentOutcome.AgentUnavailable => (Shared.Strings.Safety_Consent_AgentUnavailable, InfoBarSeverity.Warning),
// The Agent could not read the executable (beta.8): say whether its drive or the file is missing, not the IPC code.
HookingConsentOutcome.Failed when string.Equals(result.Detail, Shared.Ipc.IpcErrorCode.ExecutableUnreadable, StringComparison.Ordinal) && Game is not null
=> (Formats.ExecutableMissingText(Game.Fingerprint.ExePath), InfoBarSeverity.Warning),
HookingConsentOutcome.Failed => (result.Detail ?? Strings.Common_NotAvailable, InfoBarSeverity.Warning),
_ => (null, InfoBarSeverity.Informational),
};
@@ -570,9 +792,15 @@ public sealed partial class GameDetailViewModel : ObservableObject
{
GameRow row = detail.Row;
Name = row.Name;
Subtitle = string.Join(" · ", new[] { row.Publisher, row.GameVersion, Formats.Platform(row.Platform), EngineText(row) }.Where(static s => !string.IsNullOrWhiteSpace(s)));
// A store's version is said as one ("Steam build 20374416", beta.8), and then names the store itself.
bool storeVersion = EditGameViewModel.IsDetectedField(row.FieldProvenanceJson, "game_version") && row.Platform is "steam" or "gog" or "epic";
string?[] subtitle = storeVersion
? [row.Publisher, Formats.StoreVersion(row.Platform, row.GameVersion, detected: true) ?? Formats.Platform(row.Platform), EngineText(row)]
: [row.Publisher, row.GameVersion, Formats.Platform(row.Platform), EngineText(row)];
Subtitle = string.Join(" · ", subtitle.Where(static s => !string.IsNullOrWhiteSpace(s)));
ExecutableText = row.Fingerprint.ExePath;
ExecutableMissing = !GameLibrary.ExecutableExists(row.Fingerprint.ExePath);
OnPropertyChanged(nameof(ExecutableMissingMessage));
SessionRow? last = detail.Sessions.Count > 0 ? detail.Sessions[0] : null;
SessionRow? lastHooked = detail.Sessions.FirstOrDefault(static s => s.Tier == CaptureTier.Hooked && s.FrameCount > 0);
@@ -581,6 +809,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
PresentChips(detail, lastHooked);
PresentSupports(row);
PresentDetails(detail);
PresentMeasured(last, lastHooked);
PresentRecording(row);
PresentHooking(row);
@@ -616,6 +845,58 @@ public sealed partial class GameDetailViewModel : ObservableObject
SupportsEmpty = Supports.Count == 0;
}
private void PresentDetails(GameDetail detail)
{
GameRow row = detail.Row;
Details.Clear();
if (row.ExeMachine is null)
{
// Written by the Agent's detection sweep: a row it has not read under this build yet.
Details.Add(new GameDetailRow(Strings.GameDetail_Details_Architecture, Strings.GameDetail_Details_NotRead));
}
else
{
Details.Add(new GameDetailRow(Strings.GameDetail_Details_Architecture, Formats.Architecture(row.ExeMachine)));
AddDetail(Strings.GameDetail_Details_FileVersion, row.ExeFileVersion);
AddDetail(Strings.GameDetail_Details_ProductVersion, row.ExeProductVersion);
}
bool detected = EditGameViewModel.IsDetectedField(row.FieldProvenanceJson, "game_version");
AddDetail(detected ? Strings.GameDetail_Details_Store : Strings.GameDetail_Details_Version, Formats.StoreVersion(row.Platform, row.GameVersion, detected));
AddDetail(Strings.GameDetail_Details_Engine, EngineText(row));
if (row.ExeMachine is not null)
{
Details.Add(new GameDetailRow(Strings.GameDetail_Details_Libraries, row.Libraries.Count == 0
? Strings.GameDetail_Details_NoLibraries
: string.Join(Environment.NewLine, row.Libraries.Select(LibraryText))));
}
// beta.8: the NVIDIA App's overrides, as the driver profile stood at the newest session that read one (sessions
// come newest first). Nothing is shown where no session could ask — a machine without an NVIDIA driver.
if (detail.Sessions.Select(static s => Application.Recording.DriverProfileRecord.Parse(s.DriverProfileJson))
.FirstOrDefault(static p => p is not null && NvidiaOverrides.IsRead(p)) is { } profile)
{
Details.Add(new GameDetailRow(Strings.GameDetail_Details_NvidiaOverride, NvidiaOverrides.OverridesText(profile)));
}
}
private void AddDetail(string label, string? value)
{
if (!string.IsNullOrWhiteSpace(value))
{
Details.Add(new GameDetailRow(label, value));
}
}
/// <summary>"DLSS: nvngx_dlss.dll 3.7.10.0" — the product the rule names, the file, and what the file says it is.</summary>
private static string LibraryText(LibraryFile library)
{
string product = CapabilityName(library.CapabilityId) is { Length: > 0 } name ? name : library.CapabilityId;
return library.FileVersion is { } version
? string.Format(CultureInfo.CurrentCulture, Strings.GameDetail_Details_Library_Format, product, library.FileName, version)
: string.Format(CultureInfo.CurrentCulture, Strings.GameDetail_Details_LibraryNoVersion_Format, product, library.FileName);
}
private void PresentMeasured(SessionRow? last, SessionRow? lastHooked)
{
Measured.Clear();
@@ -642,7 +923,17 @@ public sealed partial class GameDetailViewModel : ObservableObject
// A blocked row's toggle is disabled because enabling it could only be refused (19_SAFETY §What a finding does
// to the game): the finding is on the page, and there is no switch that overrules it (2026-09-22).
HookToggleEnabled = !blocked && !Busy;
// An executable that cannot run as x64 (beta.8): turning hooking ON could only be refused; a switch that is on
// (enabled before this build read the file) can still be turned off.
bool notX64 = ExecutableArchitecture.IsKnownNotHookable(row.ExeMachine);
// D33: a blocked game whose user-mode exception is in force (the option on, a grant on the row) may be switched on —
// through FR-2.1's dialog as ever, and the Agent's pre-scan names the family; the finding stays on the page.
ExceptionView? exception = ExceptionView.Of(row);
bool exceptionInForce = _exceptionsOn && exception is { Kind: ExceptionViewKind.Granted };
HookToggleEnabled = (!blocked || exceptionInForce) && !Busy && (row.HookEnabled || !notX64);
NotX64Text = notX64 && !blocked
? string.Format(CultureInfo.CurrentCulture, Strings.Hooking_NotX64_Format, Formats.Architecture(row.ExeMachine))
: null;
HookStatusText = row.HookEnabled ? Strings.GameDetail_Hooking_On : Strings.GameDetail_Hooking_Off;
string? found = blocked ? BlockedReasonText.Describe(row.HookBlockedReason ?? row.HookPrescanState) : null;
BlockedText = found is null
@@ -651,17 +942,33 @@ public sealed partial class GameDetailViewModel : ObservableObject
// beta.8 (owner request 2026-09-25): for an anti-cheat game the card is a switch that can never be turned on, so
// by default it gives way to the finding alone. The setting off keeps the card, with the finding under it.
HookingSectionVisible = !(blocked && _hideAntiCheatHooking);
HookingSectionVisible = !(blocked && _hideAntiCheatHooking) || exceptionInForce;
PresentException(exception, exceptionInForce);
AntiCheatText = found is not null && !HookingSectionVisible
? string.Format(CultureInfo.CurrentCulture, Strings.GameDetail_AntiCheat_Format, found)
: null;
// Its "Turn hooking back on" could only be refused once anti-cheat was found, so a blocked row does not offer it.
AutoDisabledText = !blocked && row.HookAutoDisabledReason is { Length: > 0 } reason && !row.HookEnabled
// Its "Turn hooking back on" could only be refused once anti-cheat was found, or for an executable that cannot run
// as x64, so neither row offers it.
AutoDisabledText = !blocked && !notX64 && row.HookAutoDisabledReason is { Length: > 0 } reason && !row.HookEnabled
? string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_AutoDisabled_Format, reason)
: null;
UnverifiedText = string.Equals(row.HookPrescanState, "unverified", StringComparison.Ordinal) ? Strings.GameDetail_Hooking_Unverified : null;
}
/// <summary>D33: the exception card — its state from the Agent's columns, and the one action that state allows.</summary>
private void PresentException(ExceptionView? view, bool inForce)
{
ExceptionCardVisible = view is not null && (_exceptionsOn || view.Kind == ExceptionViewKind.Granted);
ExceptionText = view?.Text;
ExceptionLapseText = view?.LapseText;
ExceptionInForceText = inForce && view?.Family is { } family
? string.Format(CultureInfo.CurrentCulture, Strings.GameDetail_Exception_Granted_Format, family)
: null;
ExceptionSuspendedText = view is { Kind: ExceptionViewKind.Granted } && !_exceptionsOn ? Strings.GameDetail_Exception_Suspended : null;
CanGrantException = _exceptionsOn && view is { CanGrant: true } && !Busy;
CanWithdrawException = view is { CanWithdraw: true } && !Busy;
}
private void PresentSessions(GameDetail detail)
{
Sessions.Clear();
@@ -708,7 +1015,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
}
}
private static string CapabilityName(string token) => token switch
internal static string CapabilityName(string token) => token switch
{
"dlss" => "DLSS",
"dlssg" or "dlss_g" => "DLSS-G",
@@ -1,3 +1,4 @@
using System.Globalization;
using FrameLedger.App.Services;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.TriState;
@@ -10,6 +11,7 @@ namespace FrameLedger.App.ViewModels;
/// <see cref="FpsPresentation"/> (<c>—</c> for a measured none, <c>N/A</c> for not measured, never blank, never
/// zero — FR-4.9), the lows, resolution · upscaler, the chips resolved with the annotation and the game default.
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime")]
public sealed class SessionItemViewModel
{
public SessionItemViewModel(SessionRow row, SessionAnnotation? annotation, GameRow game)
@@ -21,8 +23,12 @@ public sealed class SessionItemViewModel
DateText = Formats.Date(row.StartedAt);
DurationText = Formats.Duration(row.DurationSeconds);
IsHooked = row.Tier == CaptureTier.Hooked;
TierText = IsHooked ? Strings.Tier_Hooked : Strings.Tier_NotHooked;
TierTooltip = IsHooked ? Strings.Tier_Hooked_Tooltip : Strings.Tier_NotHooked_Tooltip;
// D33: a hooked session under the game's user-mode exception is marked with it wherever its tier is said.
TierText = !IsHooked ? Strings.Tier_NotHooked : row.AcExceptionFamily is null ? Strings.Tier_Hooked : Strings.Tier_HookedException;
TierTooltip = !IsHooked ? Strings.Tier_NotHooked_Tooltip
: row.AcExceptionFamily is { } family
? Strings.Tier_Hooked_Tooltip + Environment.NewLine + string.Format(CultureInfo.CurrentCulture, Strings.Session_UnderException_Format, family)
: Strings.Tier_Hooked_Tooltip;
NativeText = FpsPresentation.NativeColumn(row);
DisplayedText = FpsPresentation.DisplayedColumn(row);
FgText = FpsPresentation.FactorColumn(row);
@@ -44,6 +44,24 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
[ObservableProperty]
private string _hardwareLine = string.Empty;
/// <summary>
/// The runtime libraries the hooked game had loaded (<c>sessions.runtime_modules</c>, written since P2 and shown nowhere
/// until beta.8), each against the copy the game ships where they differ; null when the row has none.
/// </summary>
[ObservableProperty]
private string? _librariesLine;
/// <summary>
/// The NVIDIA driver profile the game ran under and what it overrides (<c>sessions.driver_profile</c>, beta.8) — the
/// NVIDIA App's DLSS and frame-generation overrides; null where no NVIDIA driver was there to ask.
/// </summary>
[ObservableProperty]
private string? _driverProfileLine;
/// <summary>What the driver reported applying in the game's process (<c>sessions.ngx_driver_words</c>); null when it reported no override.</summary>
[ObservableProperty]
private string? _driverStateLine;
[ObservableProperty]
private FpsReadoutModel _readout = FpsReadoutModel.Unavailable;
@@ -56,6 +74,14 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
[ObservableProperty]
private bool _isUnhooked;
/// <summary>How the session ended (beta.8): a crash with its exception, End task's exit code said as what it is.</summary>
[ObservableProperty]
private string _exitLine = string.Empty;
/// <summary>D33: the session was hooked under the game's user-mode exception, and for which anti-cheat; null otherwise.</summary>
[ObservableProperty]
private string? _exceptionLine;
/// <summary>Tier 2's payload (2026-09-22): why this session measured nothing, from the row's notes; empty for a hooked row.</summary>
[ObservableProperty]
private string _tier2Reason = string.Empty;
@@ -69,9 +95,17 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
[ObservableProperty]
private bool _showDisplayed;
/// <summary>
/// The frametime chart can draw the sensors over the frames: they were recorded and the blob says where the first present
/// sits on their clock (schema 0013). A session recorded before keeps the overlay off rather than drawn out of step.
/// </summary>
[ObservableProperty]
private bool _hasSensors;
/// <summary>The Sensors section has something to draw — in either tier (beta.8).</summary>
[ObservableProperty]
private bool _hasSensorCharts;
[ObservableProperty]
private bool _showSensors;
@@ -113,6 +147,8 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
public static string DistributionHeader => Strings.Summary_Distribution_Header;
public static string SensorsHeader => Strings.GameDetail_Tab_Sensors;
public static string ShowDisplayedText => Strings.Summary_Show_Displayed;
public static string ShowSensorsText => Strings.Summary_Show_Sensors;
@@ -137,6 +173,9 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
public SessionSeries? Series { get; private set; }
/// <summary>What the Sensors section draws: <see cref="Series"/> for a hooked session, the sensors alone for one that was not.</summary>
public SessionSeries? SensorSeries { get; private set; }
public ObservableCollection<StatCardModel> Stats { get; } = [];
public ObservableCollection<TriStateChipModel> Chips { get; } = [];
@@ -162,6 +201,7 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
_segments = await _sessions.FindSegmentsAsync(sessionId, ct).ConfigureAwait(true);
_snapshot = await _hardware.FindAsync(Row.SnapshotId, ct).ConfigureAwait(true);
Series = Row.Tier == CaptureTier.Hooked ? await _loader.LoadAsync(sessionId, ct).ConfigureAwait(true) : null;
SensorSeries = Series ?? (await _loader.LoadSensorsAsync(sessionId, ct).ConfigureAwait(true) is { Count: > 0 } sensors ? SessionSeries.SensorsOnly(sensors) : null);
Present();
}
@@ -181,7 +221,7 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
public Task ExportPngAsync(Plot plot)
{
ArgumentNullException.ThrowIfNull(plot);
return Run(() => ExportAsync("png", "PNG|*.png", path => plot.SavePng(path, 1600, 700)));
return Run(() => ExportAsync("png", "PNG|*.png", path => ChartTheme.SavePng(plot, path, 1600, 700)));
}
private async Task Run(Func<Task> work)
@@ -283,6 +323,11 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
IsCrashed = row.ExitStatus == ExitStatus.Crashed;
IsUnhooked = row.ExitStatus == ExitStatus.UnhookedSafety;
Tier2Reason = IsHooked ? string.Empty : Formats.Tier2Reason(row.CaptureNotes);
ExitLine = string.Format(CultureInfo.CurrentCulture, Strings.Exit_Line_Format,
Formats.ExitText(row.ExitStatus, Application.Recording.CaptureNotes.Parse(row.CaptureNotes)));
ExceptionLine = row.AcExceptionFamily is { } family
? string.Format(CultureInfo.CurrentCulture, Strings.Session_UnderException_Format, family)
: null;
Readout = FpsPresentation.FromRow(row);
Line = string.Format(CultureInfo.CurrentCulture, Strings.Summary_Line_Format,
IsHooked ? Formats.Api(row.Api) : Strings.Tier_NotHooked, row.PresentMode ?? Strings.Common_NotAvailable,
@@ -290,10 +335,14 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
HardwareLine = _snapshot is null
? string.Empty
: string.Join(" · ", SystemInfoViewModel.Describe(_snapshot).Where(static l => !string.Equals(l.Value, Strings.Common_NotAvailable, StringComparison.Ordinal)).Select(static l => l.Value));
LibrariesLine = LoadedLibraries(row.RuntimeModulesJson, Game.Libraries);
DriverProfileLine = NvidiaOverrides.ProfileLine(row.DriverProfileJson);
DriverStateLine = NvidiaOverrides.DriverLine(row.NgxDriverWordsJson);
Tags = _annotation is null ? string.Empty : string.Join(", ", _annotation.Tags);
Notes = _annotation?.Notes ?? string.Empty;
HasDisplayed = Series?.HasGenerated == true;
HasSensors = Series?.Sensors.Count > 0;
HasSensors = Series is { SensorsAligned: true, Sensors.Count: > 0 };
HasSensorCharts = SensorSeries is { } shown && (shown.Sensors.Count > 0 || shown.VramProcMb is { Length: > 0 });
DecimationNote = Series is null ? string.Empty : string.Format(CultureInfo.CurrentCulture, Strings.Chart_Decimated_Format, Series.Presents, Math.Min(Series.Presents, Decimator.DefaultBuckets * 2));
PresentStats(row);
PresentChips();
@@ -319,6 +368,46 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
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))));
}
/// <summary>
/// <c>runtime_modules</c> ({file: version}) as one line, each module beside the version the game's own copy states when
/// the two differ: a DLSS the NVIDIA App or the driver substituted is loaded from elsewhere under the same name. Null
/// for a row with none — a Tier-2 session, or one written before the census existed.
/// </summary>
internal static string? LoadedLibraries(string? runtimeModulesJson, IReadOnlyList<Domain.Detection.LibraryFile> shipped)
{
if (string.IsNullOrWhiteSpace(runtimeModulesJson))
{
return null;
}
Dictionary<string, string>? modules;
try
{
modules = System.Text.Json.JsonSerializer.Deserialize(runtimeModulesJson, AppJsonContext.Default.DictionaryStringString);
}
catch (System.Text.Json.JsonException)
{
return null;
}
if (modules is null || modules.Count == 0)
{
return null;
}
IEnumerable<string> items = modules.OrderBy(static m => m.Key, StringComparer.OrdinalIgnoreCase).Select(m =>
{
// A module with no version resource is stored as null (RuntimeModuleSnapshot.Describe).
string? stated = m.Value;
string version = stated ?? Strings.Common_NotAvailable;
string? own = shipped.FirstOrDefault(l => string.Equals(l.FileName, m.Key, StringComparison.OrdinalIgnoreCase))?.FileVersion;
return Formats.SameVersion(stated, own) == false
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Library_Differs_Format, m.Key, version, own)
: m.Key + " " + version;
});
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Libraries_Format, string.Join(" · ", items));
}
private void PresentChips()
{
Chips.Clear();
@@ -39,6 +39,7 @@ public sealed partial class SettingsViewModel : ObservableObject
private readonly IAgentTool _tool;
private readonly WindowClosePolicy _closePolicy;
private readonly IFirstRunFlow _firstRun;
private readonly AntiCheatExceptions? _exceptions;
private bool _loading = true;
[ObservableProperty]
@@ -73,6 +74,22 @@ public sealed partial class SettingsViewModel : ObservableObject
[ObservableProperty]
private bool _hideAntiCheatHooking = true;
/// <summary>
/// <c>hooking.usermode_ac_exceptions</c> (D33, owner decision 2026-09-26): whether a game's user-mode anti-cheat exception
/// may apply at all. Off by default; off suspends every exception below without deleting any.
/// </summary>
[ObservableProperty]
[NotifyPropertyChangedFor(nameof(ExceptionsSuspended))]
private bool _userModeExceptions;
/// <summary>D33: the Agent has not answered about every blocked game yet (the option was just turned on).</summary>
[ObservableProperty]
private bool _exceptionsChecking;
/// <summary><c>ui.fps_decimals</c> (beta.8): every FPS figure with two decimals ("62.40") instead of a whole number.</summary>
[ObservableProperty]
private bool _fpsTwoDecimals;
[ObservableProperty]
private bool _onlineMetadata;
@@ -116,8 +133,11 @@ public sealed partial class SettingsViewModel : ObservableObject
IMaintenanceState maintenance,
IAgentTool tool,
WindowClosePolicy closePolicy,
IFirstRunFlow firstRun)
IFirstRunFlow firstRun,
AntiCheatExceptions? exceptions = null)
{
// D33: the user-mode exception's requests; a composition without it (a test) answers that the Agent is unavailable.
_exceptions = exceptions;
_firstRun = firstRun ?? throw new ArgumentNullException(nameof(firstRun));
_maintenance = maintenance ?? throw new ArgumentNullException(nameof(maintenance));
_tool = tool ?? throw new ArgumentNullException(nameof(tool));
@@ -178,6 +198,15 @@ public sealed partial class SettingsViewModel : ObservableObject
public ObservableCollection<HookedGameViewModel> HookedGames { get; } = [];
/// <summary>
/// D33: the games the user-mode exception concerns — in force, eligible, or held back only by the session count. The rest
/// of the blocked games say why not on their own pages.
/// </summary>
public ObservableCollection<ExceptionGameViewModel> ExceptionGames { get; } = [];
/// <summary>D33: the option is off and exceptions are kept below that do not apply.</summary>
public bool ExceptionsSuspended => !UserModeExceptions && ExceptionGames.Any(static g => g.CanWithdraw);
public string KillSwitchState => KillSwitch ? Strings.Settings_KillSwitch_On : Strings.Settings_KillSwitch_Off;
/// <summary>12_BUILD: the registration exists only while a hook-enabled game references the Vulkan loader (P4 PR-2) — the button follows the same rule as the Agent's reconciler.</summary>
@@ -230,6 +259,33 @@ public sealed partial class SettingsViewModel : ObservableObject
partial void OnHideAntiCheatHookingChanged(bool value) => Persist(SettingsRegistry.UiHideAntiCheatHooking, value);
/// <summary>D33: the option is one settings row the Agent reads at every session start and command; the list follows it.</summary>
partial void OnUserModeExceptionsChanged(bool value)
{
if (!_loading)
{
Pending = WriteThenRefreshAsync(SettingsRegistry.HookingUserModeExceptions, value ? "1" : "0");
}
}
private async Task WriteThenRefreshAsync(SettingDefinition definition, string value)
{
await WriteAsync(definition, value).ConfigureAwait(true);
await RefreshCoreAsync().ConfigureAwait(true);
}
partial void OnFpsTwoDecimalsChanged(bool value)
{
if (_loading)
{
return;
}
// Every formatter reads it from now on; a page shows it the next time it formats a number.
FpsDecimals.Two = value;
Persist(SettingsRegistry.UiFpsDecimals, value);
}
partial void OnMinimizeToTrayChanged(bool value)
{
if (!_loading)
@@ -340,6 +396,8 @@ public sealed partial class SettingsViewModel : ObservableObject
BackgroundCapture = await _settings.GetBooleanAsync(SettingsRegistry.CaptureBackground).ConfigureAwait(true);
MinimizeToTray = await _settings.GetBooleanAsync(SettingsRegistry.UiMinimizeToTray).ConfigureAwait(true);
HideAntiCheatHooking = await _settings.GetBooleanAsync(SettingsRegistry.UiHideAntiCheatHooking).ConfigureAwait(true);
UserModeExceptions = await _settings.GetBooleanAsync(SettingsRegistry.HookingUserModeExceptions).ConfigureAwait(true);
FpsTwoDecimals = await _settings.GetBooleanAsync(SettingsRegistry.UiFpsDecimals).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);
@@ -364,6 +422,8 @@ public sealed partial class SettingsViewModel : ObservableObject
HookedGames.Add(new HookedGameViewModel(card.Row.Id, card.Row.Name, RevokeAsync, CapabilityFlags.Contains(card.Row.CapabilityFlagsJson, "vulkan")));
}
PresentExceptions(cards);
Shared.Ipc.HelloAck? hello = _agent.Hello;
ElevationText = hello is null ? Strings.Settings_VkLayer_Unknown : hello.Elevated ? Strings.Settings_Agent_Elevated : Strings.Settings_Agent_NotElevated;
MaintenanceSnapshot = await _maintenance.ReadAsync().ConfigureAwait(true);
@@ -393,6 +453,71 @@ public sealed partial class SettingsViewModel : ObservableObject
}
}
/// <summary>D33: the exception list from the Agent's columns — the App reads them and never writes one.</summary>
private void PresentExceptions(IReadOnlyList<GameCard> cards)
{
ExceptionGames.Clear();
bool checking = false;
foreach (GameCard card in cards.Where(static c => c.Row.InLibrary).OrderBy(static c => c.Row.Name, StringComparer.CurrentCultureIgnoreCase))
{
if (ExceptionView.Of(card.Row) is not { } view)
{
continue;
}
checking |= view.Kind == ExceptionViewKind.Checking;
// With the option off only a kept grant is listed (suspended): nothing may be made while it is off.
bool listed = UserModeExceptions
? view.Kind is ExceptionViewKind.Granted or ExceptionViewKind.Eligible or ExceptionViewKind.TooFewSessions
: view.Kind == ExceptionViewKind.Granted;
if (listed)
{
ExceptionGames.Add(new ExceptionGameViewModel(card.Row.Id, card.Row.Name, view, GrantExceptionAsync, WithdrawExceptionAsync));
}
}
ExceptionsChecking = UserModeExceptions && checking;
OnPropertyChanged(nameof(ExceptionsSuspended));
}
/// <summary>D33: the disclosure, then the request; the Agent gathers the facts and grants or refuses.</summary>
private async Task GrantExceptionAsync(ExceptionGameViewModel game)
{
AntiCheatExceptionResult result = _exceptions is null
? AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable)
: await _exceptions.GrantAsync(game.GameId, new AntiCheatExceptionFacts(game.Name, game.View.Family ?? string.Empty,
game.View.Signal ?? string.Empty, game.View.Sessions)).ConfigureAwait(true);
await ReportExceptionAsync(game.Name, result).ConfigureAwait(true);
}
private async Task WithdrawExceptionAsync(ExceptionGameViewModel game)
{
AntiCheatExceptionResult result = _exceptions is null
? AntiCheatExceptionResult.Of(AntiCheatExceptionOutcome.AgentUnavailable)
: await _exceptions.WithdrawAsync(game.GameId).ConfigureAwait(true);
await ReportExceptionAsync(game.Name, result).ConfigureAwait(true);
}
private async Task ReportExceptionAsync(string name, AntiCheatExceptionResult result)
{
if (result.MessageFor(name) is { } message)
{
if (result.Succeeded)
{
_strip.Success(name, message);
}
else
{
_strip.Warn(name, message);
}
}
await RefreshCoreAsync().ConfigureAwait(true);
}
[RelayCommand]
private Task RefreshExceptionsAsync() => RefreshAsync();
private async Task RevokeAsync(HookedGameViewModel game)
{
HookingConsentResult result = await _consent.DisableAsync(game.GameId).ConfigureAwait(true);
@@ -37,7 +37,16 @@
<!-- header line + chips -->
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.Line}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.ExitLine}" />
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.ExceptionLine}"
Visibility="{Binding ViewModel.ExceptionLine, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.HardwareLine}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.LibrariesLine}"
Visibility="{Binding ViewModel.LibrariesLine, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.DriverProfileLine}"
Visibility="{Binding ViewModel.DriverProfileLine, Converter={StaticResource NullToCollapsed}}" />
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.DriverStateLine}"
Visibility="{Binding ViewModel.DriverStateLine, Converter={StaticResource NullToCollapsed}}" />
<ItemsControl Margin="0,8,0,0" ItemsSource="{Binding ViewModel.Chips}">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
@@ -102,6 +111,12 @@
<charts:DistributionChart x:Name="Distribution" Margin="0,6,0,0" Height="260" />
</StackPanel>
<!-- sensors, in either tier (beta.8): a session that was not hooked has nothing else to chart -->
<StackPanel Visibility="{Binding ViewModel.HasSensorCharts, Converter={StaticResource BoolToVis}}">
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.SensorsHeader}" />
<charts:SensorsChart x:Name="Sensors" Margin="0,6,0,0" />
</StackPanel>
<!-- annotations -->
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.AnnotationsHeader}" />
<ui:TextBox Margin="0,6,0,0" AutomationProperties.Name="{x:Static vm:SessionSummaryViewModel.TagsPlaceholder}" PlaceholderText="{x:Static vm:SessionSummaryViewModel.TagsPlaceholder}" Text="{Binding ViewModel.Tags, UpdateSourceTrigger=PropertyChanged}" />
@@ -60,6 +60,7 @@ public partial class SessionSummaryWindow : FluentWindow
{
Frametime.Show(ViewModel.Series, ViewModel.ShowDisplayed, ViewModel.ShowSensors);
Distribution.Show(ViewModel.Series);
Sensors.Show(ViewModel.SensorSeries);
}
private void OnExportPng(object sender, RoutedEventArgs e) => _ = ViewModel.ExportPngAsync(Frametime.ScottPlot);
@@ -10,5 +10,12 @@ public sealed record AntiCheatPreScanReport
public int Current { get; init; }
public int Unreadable { get; init; }
public bool RulesUnusable { get; init; }
/// <summary>D33: blocked entries whose user-mode exception eligibility the pass (re)wrote.</summary>
public int ExceptionsChecked { get; init; }
/// <summary>D33: exceptions the pass ended — an executable that changed, a game no longer eligible.</summary>
public int ExceptionsEnded { get; init; }
public int Scanned => Found + Clean + Unverified;
}
@@ -1,3 +1,4 @@
using FrameLedger.Application.Capture;
using FrameLedger.Application.Consent;
using FrameLedger.Application.Detection;
using FrameLedger.Application.Ipc;
@@ -34,6 +35,13 @@ namespace FrameLedger.Application.AntiCheat;
/// session start whatever this sweep wrote, exactly as it did before. It never opens a game's process — the scan
/// reads the executable's path, its install folder and the store's files.
/// </para>
/// <para>
/// <b>A blocked entry is never scanned for a new block, and since D33 (owner decision 2026-09-26) it is asked one other
/// question</b> — whether its user-mode exception may be granted (<see cref="ExceptionPassAsync"/>): while the option is
/// on, a tolerant pre-scan naming the block's family, keyed like the pre-scan so it re-runs only when the rules, the
/// executable or the block change, and a count of the successful Tier-1 sessions. With the option on or off, a grant
/// made on bytes that are no longer on disk ends. Nothing here grants anything or clears a block.
/// </para>
/// </remarks>
public sealed class AntiCheatPreScanSweep : IDisposable
{
@@ -44,12 +52,19 @@ public sealed class AntiCheatPreScanSweep : IDisposable
private readonly IExecutableIdentitySource _identity;
private readonly IIpcEventPublisher? _pipe;
private readonly Func<long, bool> _isRecording;
private readonly ISessionRepository? _sessions;
private readonly IUserModeExceptionSwitch? _exceptions;
private readonly Action<string> _log;
private readonly SemaphoreSlim _wake = new(0, 1);
public AntiCheatPreScanSweep(IGameRepository games, IGameConsentStore consent, IAntiCheatGuard guard, IDetectionRulesSource rules,
IExecutableIdentitySource identity, Action<string> log, IIpcEventPublisher? pipe = null, Func<long, bool>? isRecording = null)
IExecutableIdentitySource identity, Action<string> log, IIpcEventPublisher? pipe = null, Func<long, bool>? isRecording = null,
ISessionRepository? sessions = null, IUserModeExceptionSwitch? exceptions = null)
{
// D33: the evidence and the option the exception pass needs; a sweep composed without them asks no exception
// question at all (the unshipped host, the tests that are not about it).
_sessions = sessions;
_exceptions = exceptions;
_games = games ?? throw new ArgumentNullException(nameof(games));
_consent = consent ?? throw new ArgumentNullException(nameof(consent));
_guard = guard ?? throw new ArgumentNullException(nameof(guard));
@@ -98,8 +113,9 @@ public sealed class AntiCheatPreScanSweep : IDisposable
ct.ThrowIfCancellationRequested();
if (game.BlockedByGuard)
{
// A block is final: nothing scans it again, and nothing this sweep writes could read as clearing it.
report = report with { Blocked = report.Blocked + 1 };
// A block is final: nothing scans it for a new one, and nothing this sweep writes could read as clearing
// it. What is asked of it since D33 is whether its user-mode exception may be granted.
report = await ExceptionPassAsync(game, rulesVersion, report with { Blocked = report.Blocked + 1 }, ct).ConfigureAwait(false);
continue;
}
@@ -124,7 +140,7 @@ public sealed class AntiCheatPreScanSweep : IDisposable
private async ValueTask<AntiCheatPreScanReport> ScanAsync(GameRow game, ExecutableFingerprint onDisk, string rulesVersion,
AntiCheatPreScanReport report, CancellationToken ct)
{
AntiCheatVerdict verdict = await _guard.PreScanGameAsync(onDisk.ExePath, ct).ConfigureAwait(false);
AntiCheatVerdict verdict = await _guard.PreScanGameAsync(onDisk.ExePath, toleratedFamily: null, ct).ConfigureAwait(false);
if (await _consent.RecordPreScanAsync(onDisk, verdict, rulesVersion, ct).ConfigureAwait(false) != ConsentWriteOutcome.Written)
{
return report;
@@ -150,6 +166,78 @@ public sealed class AntiCheatPreScanSweep : IDisposable
: report with { Unverified = report.Unverified + 1 };
}
/// <summary>
/// D33: the exception question about one BLOCKED entry. A grant made on bytes that are no longer on disk ends whether
/// or not the option is on; the rest runs only while it is — a tolerant pre-scan naming the block's family when the
/// rules, the executable or the block changed since the last one, and the session count every pass — and ends a grant
/// the facts no longer support. A scan that could not answer ends nothing: the session start runs the full check anyway.
/// </summary>
private async ValueTask<AntiCheatPreScanReport> ExceptionPassAsync(GameRow game, string rulesVersion, AntiCheatPreScanReport report,
CancellationToken ct)
{
if (_sessions is null || game.HookBlockedReason is not { Length: > 0 } block || _isRecording(game.Id)
|| _identity.Read(game.Fingerprint.ExePath) is not { } onDisk)
{
return report;
}
AntiCheatExceptionState state = game.AcException;
bool granted = state.IsGranted;
if (granted && !state.GrantCovers(onDisk))
{
report = await EndAsync(game, UserModeExceptionLapse.ExecutableChanged, "its executable changed", report, ct).ConfigureAwait(false);
granted = false;
}
if (_exceptions is null || !await _exceptions.IsOnAsync(ct).ConfigureAwait(false))
{
return report;
}
StoredBlock? parsed = StoredBlock.Parse(block);
int sessions = await _sessions.CountSuccessfulHookedAsync(game.Id, ct).ConfigureAwait(false);
bool fresh = state.IsCheckedFor(onDisk, rulesVersion, block);
AntiCheatVerdict? verdict = parsed is not { IsExceptionable: true } b
? null
: fresh && StoredVerdict(state.Verdict) is { } stored
? stored
: await _guard.PreScanGameAsync(onDisk.ExePath, b.Family, ct).ConfigureAwait(false);
bool eligible = verdict is { } v && UserModeExceptionRules.IsEligible(parsed, v, sessions);
if (!fresh || eligible != state.Eligible || sessions != state.Sessions)
{
if (await _consent.RecordExceptionEligibilityAsync(onDisk, block, verdict, sessions, rulesVersion, ct).ConfigureAwait(false)
== ConsentWriteOutcome.Written)
{
report = report with { ExceptionsChecked = report.ExceptionsChecked + 1 };
_log($"prescan: {game.Name} — user-mode exception {(eligible ? "eligible" : "not eligible")} "
+ $"({(verdict is { } said ? Said(said) : "not a module, file or folder finding")}; {sessions} successful hooked sessions)");
}
}
bool couldNotVerify = verdict is { IsAllowed: false, IsFindingAboutTheGame: false };
return granted && !eligible && !couldNotVerify
? await EndAsync(game, UserModeExceptionLapse.NoLongerEligible, "the game is no longer eligible", report, ct).ConfigureAwait(false)
: report;
}
private async ValueTask<AntiCheatPreScanReport> EndAsync(GameRow game, string lapse, string why, AntiCheatPreScanReport report, CancellationToken ct)
{
if (await _consent.RevokeAntiCheatExceptionAsync(game.Fingerprint.ExePath, lapse, ct).ConfigureAwait(false) != ConsentWriteOutcome.Written)
{
return report;
}
_log($"prescan: {game.Name} — user-mode exception ended: {why} ({lapse})");
return report with { ExceptionsEnded = report.ExceptionsEnded + 1 };
}
/// <summary>A stored tolerant verdict (<c>Reason|Family|Signal</c>) back as the verdict it was; null when it cannot be read.</summary>
private static AntiCheatVerdict? StoredVerdict(string? stored) =>
StoredBlock.Parse(stored) is { } v ? AntiCheatVerdict.FromNative((int)v.Reason, v.Family, v.Signal) : null;
private static string Said(AntiCheatVerdict v) => $"{v.Reason} {v.Family} {v.Signal}".Trim();
/// <summary>The pre-scan's own key (schema 0010) against the rules and the file right now: any difference is a re-scan.</summary>
public static bool IsStale(GameRow game, ExecutableFingerprint onDisk, string rulesVersion)
{
@@ -23,10 +23,16 @@ namespace FrameLedger.Application.AntiCheat;
/// the far side of a returned verdict.
/// </para>
/// </remarks>
public sealed class GuardSupervisor(IAntiCheatGuard guard)
public sealed class GuardSupervisor(IAntiCheatGuard guard, string? toleratedFamily = null)
{
private readonly IAntiCheatGuard _guard = guard ?? throw new ArgumentNullException(nameof(guard));
/// <summary>
/// D33: the family the session's user-mode exception covers, named to every re-scan exactly as it was to the injection
/// — the guard still honours it only for a user-mode family and refuses on anything else. Null for every other session.
/// </summary>
public string? ToleratedFamily { get; } = toleratedFamily;
/// <summary>
/// Completed guard evaluations. Published to <c>FlControlBlock.guardTicks</c>.
/// </summary>
@@ -66,7 +72,7 @@ public sealed class GuardSupervisor(IAntiCheatGuard guard)
return false;
}
AntiCheatVerdict verdict = await _guard.EvaluateAsync(targetPid, ct).ConfigureAwait(false);
AntiCheatVerdict verdict = await _guard.EvaluateAsync(targetPid, ToleratedFamily, ct).ConfigureAwait(false);
// THE ONE SITE. Everything above can fail, throw or cancel; nothing
// below runs unless a verdict actually came back.
@@ -31,8 +31,9 @@ namespace FrameLedger.Application.AntiCheat;
public sealed class HookRequest
{
private HookRequest(int targetPid, string payloadPath, bool hookEnabled, DateTimeOffset? consentedAt,
string? blockedReason, int waitForPresentationRuntimeMs, bool killSwitchEngaged)
string? blockedReason, int waitForPresentationRuntimeMs, bool killSwitchEngaged, string? toleratedFamily = null)
{
ToleratedFamily = toleratedFamily;
TargetPid = targetPid;
PayloadPath = payloadPath;
HookEnabled = hookEnabled;
@@ -86,6 +87,17 @@ public sealed class HookRequest
/// <summary><c>games.hook_blocked_reason</c>; non-null means the toggle is disabled.</summary>
public string? BlockedReason { get; }
/// <summary>
/// D33 (owner decision 2026-09-26): the anti-cheat family the game's user-mode exception covers for THIS session, or
/// null — the NAME the gate hands the guard, which decides itself whether to honour it.
/// </summary>
/// <remarks>
/// Set only by <see cref="FromConsent"/>, from the stored grant, and only when the caller says the exception is in force
/// for this session — the option is on and the Overlay's channel exists (<see cref="UserModeExceptionRules.CoveredFamily"/>).
/// Without it a blocked game is refused before the guard is asked, exactly as before D33.
/// </remarks>
public string? ToleratedFamily { get; }
/// <summary>
/// Build the request the gate evaluates, from a stored record and the executable
/// as it is on disk right now.
@@ -96,9 +108,13 @@ public sealed class HookRequest
/// <param name="payloadPath">The Overlay, resolved beside the guard (§S22).</param>
/// <param name="waitForPresentationRuntimeMs">Launch mode's budget; zero is attach mode.</param>
/// <param name="killSwitchEngaged">FR-2.4's global switch as read from the settings store just now (decision D7).</param>
/// <param name="exceptionInForce">
/// D33: <c>hooking.usermode_ac_exceptions</c> is on AND the Overlay's tolerance channel was published for this pid. False
/// — the default, and every caller before D33 — asks the guard to tolerate nothing.
/// </param>
public static HookRequest FromConsent(
GameConsentRecord record, ExecutableFingerprint observed, int targetPid, string payloadPath,
int waitForPresentationRuntimeMs = 0, bool killSwitchEngaged = false)
int waitForPresentationRuntimeMs = 0, bool killSwitchEngaged = false, bool exceptionInForce = false)
{
ArgumentException.ThrowIfNullOrWhiteSpace(payloadPath);
ArgumentOutOfRangeException.ThrowIfNegative(waitForPresentationRuntimeMs);
@@ -129,7 +145,9 @@ public sealed class HookRequest
consentedAt = null;
}
// THE FAMILY COMES FROM THE STORED GRANT, never from a caller: the caller can only say whether the exception is in
// force this session, which can only turn it off.
return new HookRequest(targetPid, payloadPath, record.HookEnabled, consentedAt, record.BlockedReason,
waitForPresentationRuntimeMs, killSwitchEngaged);
waitForPresentationRuntimeMs, killSwitchEngaged, UserModeExceptionRules.CoveredFamily(record, observed, exceptionInForce));
}
}
@@ -78,7 +78,7 @@ public sealed class HookedCaptureGate(IAntiCheatGuard guard)
"the per-game consent dialog has not been accepted");
}
if (request.BlockedReason is { Length: > 0 } blocked)
if (request.BlockedReason is { Length: > 0 } blocked && request.ToleratedFamily is null)
{
// 19_SAFETY §A game already enabled can become blocked later: a
// patch adds anti-cheat, or updated rules newly match. hook_enabled
@@ -87,11 +87,15 @@ public sealed class HookedCaptureGate(IAntiCheatGuard guard)
return AntiCheatVerdict.Refused(AntiCheatRefusalReason.PreviouslyBlocked, "previously blocked", blocked);
}
// D33 (owner decision 2026-09-26): a blocked game reaches the guard only under its user-mode exception, and then
// with the family NAMED — the guard honours it only for a family that is user-mode throughout, runs every check
// and keeps scanning past what it lets through. Every other game names none, which is the strict guard of before.
//
// Launch mode is the same gate reached through the guard's WAITING entry: the consent checks
// above are identical, and what differs is only WHEN the guard's full scan runs (P1 item 2).
return request.WaitForPresentationRuntimeMs > 0
? await _guard.GuardedInjectWhenReadyAsync(request.TargetPid, request.PayloadPath,
request.WaitForPresentationRuntimeMs, ct).ConfigureAwait(false)
: await _guard.GuardedInjectAsync(request.TargetPid, request.PayloadPath, ct).ConfigureAwait(false);
request.WaitForPresentationRuntimeMs, request.ToleratedFamily, ct).ConfigureAwait(false)
: await _guard.GuardedInjectAsync(request.TargetPid, request.PayloadPath, request.ToleratedFamily, ct).ConfigureAwait(false);
}
}
@@ -19,6 +19,14 @@ namespace FrameLedger.Application.AntiCheat;
/// then passes to an injector. <see cref="GuardedInjectAsync"/> injects, or
/// refuses. The guard owns the chokepoint (§S13(b)).
/// </para>
/// <para>
/// <b>Every method takes <c>toleratedFamily</c> since D33 (owner decision 2026-09-26)</b> — the NAME of the one anti-cheat
/// family a game's user-mode exception covers, or null for none, and required rather than defaulted so every caller
/// states which it means. It is a name and never evidence: the guard resolves it against its own rules, honours it only
/// for a family whose every signal is user-mode, runs every check and keeps scanning past what it lets through
/// (<c>19_SAFETY</c> §The user-mode exception). A pass that let something through is
/// <see cref="AntiCheatRefusalReason.AllowedUnderUserModeException"/>.
/// </para>
/// </remarks>
public interface IAntiCheatGuard
{
@@ -27,14 +35,14 @@ public interface IAntiCheatGuard
/// in-session re-scan of <c>19_SAFETY</c> §During a session, which must
/// reach a verdict about a process we are already inside.
/// </summary>
ValueTask<AntiCheatVerdict> EvaluateAsync(int targetPid, CancellationToken ct = default);
ValueTask<AntiCheatVerdict> EvaluateAsync(int targetPid, string? toleratedFamily, CancellationToken ct = default);
/// <summary>
/// Run every check and, only on a pass, inject. There is no overload that
/// skips the checks and no way to supply evidence — the guard collects its
/// own, so a caller can ask but only the guard answers.
/// </summary>
ValueTask<AntiCheatVerdict> GuardedInjectAsync(int targetPid, string payloadPath, CancellationToken ct = default);
ValueTask<AntiCheatVerdict> GuardedInjectAsync(int targetPid, string payloadPath, string? toleratedFamily, CancellationToken ct = default);
/// <summary>
/// Launch mode (P1 item 2). Wait — up to <paramref name="timeoutMs"/> — until the target has mapped a
@@ -50,7 +58,7 @@ public interface IAntiCheatGuard
/// <see cref="AntiCheatRefusalReason.LaunchNoPresentationRuntime"/>. The caller launched and holds
/// the process; the guard creates and terminates nothing.
/// </remarks>
ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAsync(int targetPid, string payloadPath, int timeoutMs,
ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAsync(int targetPid, string payloadPath, int timeoutMs, string? toleratedFamily,
CancellationToken ct = default);
/// <summary>
@@ -79,5 +87,5 @@ public interface IAntiCheatGuard
/// on passing while the thing it guards grew somewhere else.
/// </para>
/// </remarks>
ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, CancellationToken ct = default);
ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, string? toleratedFamily, CancellationToken ct = default);
}
@@ -0,0 +1,29 @@
namespace FrameLedger.Application.AntiCheat;
/// <summary>
/// D33: why a user-mode exception ended — <c>games.ac_exception_lapsed_reason</c>, one of these words, which the App
/// says in the user's language (<c>19_SAFETY</c> §The user-mode exception, What ends it).
/// </summary>
public static class UserModeExceptionLapse
{
/// <summary>The user withdrew it.</summary>
public const string Withdrawn = "Withdrawn";
/// <summary>The executable is not the one the grant was made on: a game update, or <i>Change executable</i>.</summary>
public const string ExecutableChanged = "ExecutableChanged";
/// <summary>The guard no longer lets the game through under it: a new finding, a <c>.sys</c>, the family turned kernel-level, too few sessions.</summary>
public const string NoLongerEligible = "NoLongerEligible";
/// <summary>A finding about the game at a session's start, at the 30 s re-scan or when hooking was turned on.</summary>
public const string NewFinding = "NewFinding";
/// <summary>A session under it was unhooked for safety by the 30 s re-scan.</summary>
public const string SafetyUnhook = "SafetyUnhook";
/// <summary>The Overlay stopped observing on its own: another anti-cheat's module loaded in the game.</summary>
public const string OverlayStopped = "OverlayStopped";
/// <summary>A session under it ended in a crash.</summary>
public const string SessionCrashed = "SessionCrashed";
}
@@ -0,0 +1,61 @@
using FrameLedger.Domain.AntiCheat;
using FrameLedger.Domain.Consent;
namespace FrameLedger.Application.AntiCheat;
/// <summary>
/// D33 (owner decision 2026-09-26): the managed rules of the user-mode exception — what a grant needs before the guard is
/// even asked to tolerate a family, and the words its end is recorded in. The guard's own rules (which family is user-mode,
/// what is never excepted, scanning past what it lets through) are native and are not repeated here
/// (<c>19_SAFETY</c> §The user-mode exception).
/// </summary>
/// <remarks>
/// <para>
/// <b>Everything here can only narrow.</b> <see cref="CoveredFamily"/> answers null unless every managed condition holds,
/// and a non-null answer is a NAME the guard may still decline — it honours only a family whose every signal is
/// user-mode, and it refuses on anything else it finds. There is no path from this class to an injection that the
/// guard did not pass.
/// </para>
/// </remarks>
public static class UserModeExceptionRules
{
/// <summary>The owner's threshold: successful Tier-1 sessions of the game before its exception may be granted.</summary>
/// <remarks>
/// "Successful" is <c>ISessionRepository.CountSuccessfulHookedAsync</c>'s: hooked, frames recorded, <c>exit_status =
/// normal</c> — which since beta.8 includes End task's exit code 1 and a user's stop, and never a crash, a safety
/// unhook, a degraded or an interrupted session.
/// </remarks>
public const int RequiredSessions = 2;
/// <summary>
/// The family the game's exception covers for a session against <paramref name="observed"/>, or null: the option is
/// on, the row carries a grant, the grant was made on this executable, and the block on the row is a module, file or
/// folder finding naming that same family.
/// </summary>
/// <param name="record">What the store returned.</param>
/// <param name="observed">The executable as it is on disk right now.</param>
/// <param name="optionOn"><c>hooking.usermode_ac_exceptions</c> as read just now; off suspends every exception.</param>
public static string? CoveredFamily(GameConsentRecord record, ExecutableFingerprint observed, bool optionOn)
{
if (!optionOn || !record.IsFromStore || record.Exception is not { } grant || !grant.Covers(observed))
{
return null;
}
return StoredBlock.Parse(record.BlockedReason) is { IsExceptionable: true } block
&& string.Equals(block.Family, grant.Family, StringComparison.Ordinal)
? grant.Family
: null;
}
/// <summary>
/// Whether <paramref name="verdict"/> — a tolerant pre-scan asked about <paramref name="block"/>'s family — makes the
/// game eligible, given <paramref name="sessions"/> successful Tier-1 sessions: the guard passed and named that same
/// family as what it let through, and the evidence reaches <see cref="RequiredSessions"/>.
/// </summary>
public static bool IsEligible(StoredBlock? block, AntiCheatVerdict verdict, int sessions) =>
block is { IsExceptionable: true } b
&& verdict.RanUnderException
&& string.Equals(verdict.Family, b.Family, StringComparison.Ordinal)
&& sessions >= RequiredSessions;
}
@@ -17,6 +17,13 @@ public sealed record CaptureOutcome
/// </summary>
public bool HookingTurnedOff { 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
/// recorder marks a HOOKED session with it, and ends the exception when a session under it ends badly.
/// </summary>
public string? ExceptionFamily { get; init; }
public ShmAttachRefusal AttachRefusal { get; init; }
public IReadOnlyList<FlFrameRecord> Records { get; init; } = [];
@@ -91,6 +98,9 @@ public sealed record CaptureOutcome
/// <summary>The target's exit code, when it had exited by the time the session let go; null otherwise.</summary>
public int? ExitCode { get; init; }
/// <summary>The Win32 error a launch failed with (<see cref="SessionEndReason.LaunchCannotStart"/>, beta.8); null otherwise or when the launcher cannot tell.</summary>
public int? LaunchError { get; init; }
/// <summary>
/// True when the loop held the session open unhooked until the target left (Tier 2, 2026-09-22): the duration is the
/// game's, so the crash witness applies even where no pid was ever held.
@@ -44,7 +44,9 @@ public sealed class CaptureSession(
IProcessLauncher? launcher = null,
ICaptureObserver? observer = null,
IKillSwitch? killSwitch = null,
ICapturePauseSource? pause = null)
ICapturePauseSource? pause = null,
IUserModeExceptionSwitch? exceptions = null,
IOverlayToleranceChannel? tolerance = null)
{
/// <summary>Start one session, or say why not.</summary>
/// <remarks>
@@ -88,8 +90,12 @@ public sealed class CaptureSession(
// blocked by a finding, or auto-disabled — gets a Tier-2 session and nothing else: no OpenProcess, no resolver,
// no gate. Until this line existed the resolver ran first, and a hooking-off utility that runs elevated
// (Borderless Gaming, on the owner's machine) was reported as a process an anti-cheat driver protects.
//
// A BLOCKED row is hooking-off too unless its user-mode exception applies to this executable with the option on
// (D33): hook_enabled can be 1 on a blocked row only because the exception once applied, and without it the gate
// would refuse the row anyway — after the resolver had opened the process for nothing.
GameConsentRecord record = await store.FindAsync(normalisedExePath, ct).ConfigureAwait(false);
if (!record.HookEnabled)
if (!record.HookEnabled || await IsBlockedWithoutExceptionAsync(record, observed, ct).ConfigureAwait(false))
{
return await HoldUnhookedAsync(HookingOff(record), normalisedExePath, alive: null, pid: null, ct, stop).ConfigureAwait(false);
}
@@ -119,6 +125,11 @@ public sealed class CaptureSession(
.ConfigureAwait(false);
}
/// <summary>D33: a block on the row that no user-mode exception covers for <paramref name="observed"/> right now.</summary>
private async ValueTask<bool> IsBlockedWithoutExceptionAsync(GameConsentRecord record, ExecutableFingerprint? observed, CancellationToken ct) =>
record.BlockedReason is { Length: > 0 }
&& (observed is not { } exe || UserModeExceptionRules.CoveredFamily(record, exe, await IsExceptionOptionOnAsync(ct).ConfigureAwait(false)) is null);
/// <summary>The verdict a hooking-off row's Tier-2 session carries: the row's block when it has one, else "not enabled".</summary>
private static CaptureOutcome HookingOff(GameConsentRecord record) => new()
{
@@ -190,10 +201,10 @@ public sealed class CaptureSession(
}
var started = Stopwatch.StartNew();
(int Pid, ITargetLiveness Alive)? launched = launcher.Start(normalisedExePath, arguments ?? string.Empty);
(int Pid, ITargetLiveness Alive)? launched = launcher.Start(normalisedExePath, arguments ?? string.Empty, out int? launchError);
if (launched is null)
{
return new CaptureOutcome { Reason = SessionEndReason.LaunchCannotStart };
return new CaptureOutcome { Reason = SessionEndReason.LaunchCannotStart, LaunchError = launchError };
}
using ITargetLiveness alive = launched.Value.Alive;
@@ -227,7 +238,12 @@ public sealed class CaptureSession(
// THE FOURTH INPUT (FR-2.4, decision D7) is read here and handed to the request, so the refusal is
// the gate's — a check upstream of it would make the gate's own "ONLY managed logic" remark false.
bool engaged = await IsKillSwitchEngagedAsync(ct).ConfigureAwait(false);
HookRequest request = HookRequest.FromConsent(record, observed, pid, payloadPath, waitMs, engaged);
// D33: the Overlay's channel is published BEFORE the request is built and the guard asked — the Overlay reads it
// once, before its loader detour exists — and a channel that could not be published is no exception at all: the
// request then names no family and the gate refuses the blocked game as before.
string? covered = UserModeExceptionRules.CoveredFamily(record, observed, await IsExceptionOptionOnAsync(ct).ConfigureAwait(false));
using IDisposable? channel = covered is null ? null : tolerance?.TryPublish(pid, covered);
HookRequest request = HookRequest.FromConsent(record, observed, pid, payloadPath, waitMs, engaged, exceptionInForce: channel is not null);
AntiCheatVerdict verdict = await gate.StartAsync(request, ct).ConfigureAwait(false);
TimeSpan? launchWait = started?.Elapsed;
// THE ONE VERDICT THAT IS NEITHER: the guard passed and injected nothing because the target
@@ -240,7 +256,15 @@ public sealed class CaptureSession(
// A finding about the game turns its hooking off here and now (owner decision 2026-09-22), not only at
// the pre-scan: the guard's start-time scan sees the process and the drivers the pre-scan cannot.
bool turnedOff = await TurnHookingOffAsync(observed, verdict, ct).ConfigureAwait(false);
var refused = new CaptureOutcome { Reason = RefusalOf(verdict.Reason), Verdict = verdict, LaunchWait = launchWait, HookingTurnedOff = turnedOff };
var refused = new CaptureOutcome
{
Reason = RefusalOf(verdict.Reason),
Verdict = verdict,
LaunchWait = launchWait,
HookingTurnedOff = turnedOff,
ExceptionFamily = request.ToleratedFamily,
};
channel?.Dispose();
// Launch mode's two guard refusals are the orchestrator's cue to elect a descendant (04_CAPTURE §Launch
// mode); holding the launcher's session open would delay that. Every other refusal is Tier 2 from here.
return refused.Reason is SessionEndReason.LaunchTargetExited or SessionEndReason.LaunchNoPresentationRuntime
@@ -258,13 +282,14 @@ public sealed class CaptureSession(
Verdict = verdict,
AttachRefusal = refusal,
LaunchWait = launchWait,
ExceptionFamily = request.ToleratedFamily,
}, observedPath, alive, pid, ct, stop).ConfigureAwait(false);
}
using (sink)
{
observer?.Attached(pid, sink.Handshake);
CaptureOutcome result = await DrainAsync(pid, alive, sink, verdict, observed, ct, stop).ConfigureAwait(false);
CaptureOutcome result = await DrainAsync(pid, alive, sink, verdict, observed, request.ToleratedFamily, ct, stop).ConfigureAwait(false);
return result with { LaunchWait = launchWait, TargetPid = pid, ExitCode = alive.ExitCode };
}
}
@@ -297,6 +322,10 @@ public sealed class CaptureSession(
_ => SessionEndReason.RefusedByGuard,
};
/// <summary>D33's option as this session reads it; a loop built without one reads "off", which applies no exception.</summary>
private async ValueTask<bool> IsExceptionOptionOnAsync(CancellationToken ct) =>
exceptions is not null && await exceptions.IsOnAsync(ct).ConfigureAwait(false);
/// <summary>FR-2.4 as this session reads it; a loop built without a switch reads "off".</summary>
private async ValueTask<bool> IsKillSwitchEngagedAsync(CancellationToken ct) =>
killSwitch is not null && await killSwitch.IsEngagedAsync(ct).ConfigureAwait(false);
@@ -331,9 +360,10 @@ public sealed class CaptureSession(
}
private async Task<CaptureOutcome> DrainAsync(int pid, ITargetLiveness alive, ICaptureSink sink,
AntiCheatVerdict verdict, ExecutableFingerprint observed, CancellationToken ct, CancellationToken stop)
AntiCheatVerdict verdict, ExecutableFingerprint observed, string? toleratedFamily, CancellationToken ct, CancellationToken stop)
{
var supervisor = new GuardSupervisor(guard);
// D33: every re-scan names the family the injection named, and nothing else.
var supervisor = new GuardSupervisor(guard, toleratedFamily);
var state = new DrainState(new ModuleTally(modules, ngx));
SessionEndReason end = await SuperviseAsync(pid, alive, sink, supervisor, state, ct, stop).ConfigureAwait(false);
@@ -351,6 +381,7 @@ public sealed class CaptureSession(
Reason = end,
Verdict = final,
HookingTurnedOff = turnedOff,
ExceptionFamily = toleratedFamily,
AttachRefusal = ShmAttachRefusal.Ok,
Records = state.Records,
GapBefore = state.GapBefore,
@@ -567,6 +598,14 @@ public sealed class CaptureSession(
bool paused = pause?.IsPaused ?? false;
if (paused != state.Paused)
{
// The resume's instant is read BEFORE the ring is told (beta.8): the Overlay records nothing until it reads the
// cleared flag, so a record stamped at or after this QPC was presented after the pause — and the first of them
// follows a gap (MarkResume). The clock is the Overlay's own: Stopwatch is QueryPerformanceCounter.
if (!paused)
{
state.ResumedAtQpc = Stopwatch.GetTimestamp();
}
sink.SetPaused(paused);
state.Paused = paused;
}
@@ -581,6 +620,9 @@ public sealed class CaptureSession(
/// <summary>What the ring was last told about FR-3.9's pause (P3 PR-1b).</summary>
public bool Paused { get; set; }
/// <summary>The QPC read as the ring was told to resume, until the first record presented after it is marked (beta.8).</summary>
public long? ResumedAtQpc { get; set; }
public List<FlFrameRecord> Records { get; } = [];
public List<ulong> Gaps { get; } = [];
@@ -647,13 +689,45 @@ public sealed class CaptureSession(
do
{
int gapsBefore = state.Gaps.Count;
int recordsBefore = state.Records.Count;
r = sink.Drain(buffer, state.Gaps);
MarkGaps(state, r, gapsBefore);
state.Records.AddRange(buffer.AsSpan(0, r.Copied).ToArray());
MarkResume(state, recordsBefore);
}
while (r.Copied == buffer.Length);
}
/// <summary>
/// FR-3.9's pause as a gap (beta.8): the Overlay records nothing while paused, so the first record presented after the
/// resume is QPC-apart from the last one before the pause by the whole pause. Counted, that interval is a fabricated
/// long frame in every statistic and paused time in every average; it follows a gap instead, as a torn slot's survivor
/// does. A record drained after the resume but stamped before it is a straggler the pause had not reached yet.
/// </summary>
private static void MarkResume(DrainState state, int from)
{
if (state.ResumedAtQpc is not long resumed)
{
return;
}
for (int i = from; i < state.Records.Count; i++)
{
if ((long)state.Records[i].Qpc < resumed)
{
continue;
}
if (!state.GapBefore.Contains(i))
{
state.GapBefore.Add(i);
}
state.ResumedAtQpc = null;
return;
}
}
/// <summary>
/// Which copied record each torn slot (and an overwrite skip) preceded: walk the slots this call
/// examined in order, and the first record after a bad slot carries the gap
@@ -0,0 +1,17 @@
namespace FrameLedger.Application.Capture;
/// <summary>Which branch a driver-profile read took (<c>FL_NV_PROFILE_*</c>).</summary>
public enum DriverProfileOutcome
{
/// <summary>Nothing was asked.</summary>
NotRead,
/// <summary>An application profile names the executable; its values are what the driver gives it.</summary>
Application,
/// <summary>No profile names it: the current global profile's values are what it gets.</summary>
Global,
/// <summary>No usable NVIDIA driver, or its settings store refused.</summary>
Degraded,
}
@@ -0,0 +1,19 @@
namespace FrameLedger.Application.Capture;
/// <summary>What <see cref="IDriverProfileSource"/> read for one executable.</summary>
public sealed record DriverProfileReading
{
/// <summary>Nothing was asked: no source composed.</summary>
public static readonly DriverProfileReading NotRead = new() { Outcome = DriverProfileOutcome.NotRead };
public required DriverProfileOutcome Outcome { get; init; }
/// <summary>The profile the driver applies, as the driver names it; null when none was read.</summary>
public string? ProfileName { get; init; }
/// <summary>The NvAPI status behind a degraded answer (or the lookup's, for the global branch).</summary>
public int? NvapiStatus { get; init; }
/// <summary>One entry per id asked, in that order; empty unless the outcome is <see cref="DriverProfileOutcome.Application"/> or <see cref="DriverProfileOutcome.Global"/>.</summary>
public IReadOnlyList<DriverSettingReading> Settings { get; init; } = [];
}
@@ -0,0 +1,20 @@
namespace FrameLedger.Application.Capture;
/// <summary>Where a driver setting's value comes from (<c>NVDRS_SETTING_LOCATION</c>, plus "set nowhere").</summary>
public enum DriverSettingLocation
{
/// <summary>Set in no profile (<c>NVAPI_SETTING_NOT_FOUND</c>): the driver's own behaviour applies.</summary>
NotSet,
/// <summary>The profile the driver applies to this executable.</summary>
Profile,
/// <summary>The global profile.</summary>
Global,
/// <summary>The base profile.</summary>
Base,
/// <summary>The driver's default.</summary>
Default,
}
@@ -0,0 +1,7 @@
namespace FrameLedger.Application.Capture;
/// <summary>
/// One driver setting as the profile gives it: its value (null when it is set in no profile, so the driver behaves as it
/// ships), where that value comes from, and whether it is the driver's shipped value or one someone set.
/// </summary>
public sealed record DriverSettingReading(uint Id, uint? Value, DriverSettingLocation Location, bool Predefined);
@@ -0,0 +1,16 @@
namespace FrameLedger.Application.Capture;
/// <summary>
/// The NVIDIA driver profile an executable runs under (beta.8, 2026-09-25): which profile the driver applies to it, and
/// the values that profile gives the DLSS and frame-generation override settings the NVIDIA App writes
/// (<see cref="NvidiaDriverSettings"/>).
/// </summary>
/// <remarks>
/// Read from the driver's own settings store, by the executable's path, through the NVAPI bridge's read-only DRS entry
/// point — never from the game's process or memory (CLAUDE.md rule 4), and nothing is ever written back. A machine
/// without an NVIDIA driver answers <see cref="DriverProfileOutcome.Degraded"/>; the call never throws.
/// </remarks>
public interface IDriverProfileSource
{
DriverProfileReading Read(string exePath);
}
@@ -0,0 +1,28 @@
namespace FrameLedger.Application.Capture;
/// <summary>
/// D33 (owner decision 2026-09-26): the Agent's channel to the Overlay it is about to inject —
/// <c>Local\FrameLedger.Tolerate.&lt;pid&gt;</c> (<c>fl_tolerance.h</c>, <c>07_IPC</c> §D) — naming the family the game's
/// user-mode exception covers, so a module of that family loading AFTER the injection does not stop the Overlay.
/// </summary>
/// <remarks>
/// <para>
/// <b>Published before the guard is asked, held for the session.</b> The Overlay reads it once, on its init thread, before
/// its loader detour exists; a channel published after the injection would be read by nobody.
/// </para>
/// <para>
/// <b>A channel that could not be published is no exception.</b> <see cref="TryPublish"/> answers null — a name another
/// process already holds, a failed call — and the session then asks the guard to tolerate nothing, so the game is refused
/// as blocked. Injecting under a guard that tolerates the family while the Overlay does not would end in the Overlay's
/// own stop, which reads as the exception failing.
/// </para>
/// <para>
/// It carries a NAME and nothing else. The Overlay resolves it against its own compiled floor and honours only a
/// user-mode family; the 30 s re-scan keeps judging every signal.
/// </para>
/// </remarks>
public interface IOverlayToleranceChannel
{
/// <summary>Publish <paramref name="family"/> for <paramref name="pid"/>; dispose the result when the session ends. Null when it could not be published.</summary>
IDisposable? TryPublish(int pid, string family);
}
@@ -8,4 +8,14 @@ public interface IProcessLauncher
{
/// <summary>The new pid and its held liveness — the caller owns the liveness — or null when it could not be started or pinned.</summary>
(int Pid, ITargetLiveness Alive)? Start(string exePath, string arguments);
/// <summary>
/// The same, saying why a start failed: the Win32 error (2 file not found, 5 access denied, 740 elevation required…).
/// A launcher that cannot tell answers null, which is what this default does (beta.8).
/// </summary>
(int Pid, ITargetLiveness Alive)? Start(string exePath, string arguments, out int? win32Error)
{
win32Error = null;
return Start(exePath, arguments);
}
}
@@ -0,0 +1,22 @@
namespace FrameLedger.Application.Capture;
/// <summary>
/// D33 (owner decision 2026-09-26): Settings ▸ Capture's option that lets a game's user-mode anti-cheat exception apply at
/// all — <c>hooking.usermode_ac_exceptions</c>, off by default — as the capture path and the Agent's commands read it.
/// </summary>
/// <remarks>
/// <para>
/// <b>Off suspends every exception and deletes none.</b> A grant stays on its row, and the next session with the option on
/// uses it again; with it off, a blocked game is the blocked game of before D33 — no tolerance named to the guard, no
/// channel to the Overlay, a Tier-2 session (<c>19_SAFETY</c> §The user-mode exception).
/// </para>
/// <para>
/// Read fresh on every ask, like <see cref="IKillSwitch"/>: the App flips one row in <c>settings</c>, and the next session
/// start and the next command take it.
/// </para>
/// </remarks>
public interface IUserModeExceptionSwitch
{
/// <summary>True while the option is on and a game's exception may apply.</summary>
ValueTask<bool> IsOnAsync(CancellationToken ct = default);
}
@@ -0,0 +1,82 @@
namespace FrameLedger.Application.Capture;
/// <summary>
/// The NVIDIA driver (DRS) setting ids behind the NVIDIA App's per-game DLSS and frame-generation overrides, which
/// <see cref="IDriverProfileSource"/> reads (beta.8, 2026-09-25). The ids and the meanings of their values are NVIDIA's own
/// <c>NvApiDriverSettings.h</c> (github.com/NVIDIA/nvapi, MIT) — except <see cref="SmoothMotion"/>, which NVIDIA has not
/// published and which community profile tools (nvidiaProfileInspector) document; every surface that shows it says so.
/// </summary>
public static class NvidiaDriverSettings
{
/// <summary><c>NGX_DLSS_SR_OVERRIDE</c>: 0 off, 1 on — the NVIDIA App's DLSS Super Resolution override.</summary>
public const uint DlssSrOverride = 0x10E41E01;
/// <summary><c>NGX_DLSS_RR_OVERRIDE</c>: 0 off, 1 on — its Ray Reconstruction override.</summary>
public const uint DlssRrOverride = 0x10E41E02;
/// <summary><c>NGX_DLSS_FG_OVERRIDE</c>: 0 off, 1 on — its Frame Generation override.</summary>
public const uint DlssFgOverride = 0x10E41E03;
/// <summary><c>SL_DLSS_OVERRIDE</c>: 0 off, 1 on — the override for a title that reaches DLSS through Streamline.</summary>
public const uint StreamlineDlssOverride = 0x10E41E06;
/// <summary><c>NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION</c>: 0 off, 1–15 preset A–O, <see cref="PresetLatest"/>.</summary>
public const uint DlssSrPreset = 0x10E41DF3;
/// <summary><c>NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION</c>: 0 off, 1–15 preset A–O, <see cref="PresetLatest"/>.</summary>
public const uint DlssRrPreset = 0x10E41DF7;
/// <summary><c>NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION</c>: 0 off, 1–26 preset A–Z, <see cref="PresetDefault"/>, <see cref="PresetLatest"/>.</summary>
public const uint DlssFgPreset = 0x10E41DF1;
/// <summary><c>NGX_DLSS_SR_MODE</c>: 0 Performance, 1 Balanced, 2 Quality, 3 the game's own (the default), 4 DLAA, 5 Ultra Performance, 6 custom.</summary>
public const uint DlssSrMode = 0x10AFB768;
/// <summary><c>NGX_DLSS_RR_MODE</c>: as <see cref="DlssSrMode"/>.</summary>
public const uint DlssRrMode = 0x10BD9423;
/// <summary><c>NGX_DLSS_SR_OVERRIDE_SCALING_RATIO</c>: 33–100 (percent, the custom mode's), 0 the default.</summary>
public const uint DlssSrScalingRatio = 0x10E41DF5;
/// <summary><c>NGX_DLSS_RR_OVERRIDE_SCALING_RATIO</c>: as <see cref="DlssSrScalingRatio"/>.</summary>
public const uint DlssRrScalingRatio = 0x10C7D4A2;
/// <summary><c>NGX_DLAA_OVERRIDE</c>: 0 the default, 1 DLAA on.</summary>
public const uint DlaaOverride = 0x10E41DF4;
/// <summary><c>NGX_DLSSG_MULTI_FRAME_COUNT</c>: 0 off, 1–15 frames generated per rendered frame.</summary>
public const uint DlssgMultiFrameCount = 0x104D6667;
/// <summary><c>NGX_DLSSG_MODE</c>: 0 not set (the default), 1 off, 2 on, 3 auto, 4 dynamic.</summary>
public const uint DlssgMode = 0x10308298;
/// <summary><c>NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX</c>: 0 off, else the dynamic mode's ceiling.</summary>
public const uint DlssgDynamicMultiFrameCountMax = 0x10562D0F;
/// <summary><c>NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE</c>: 0 disabled, 1–0xFFFFFF frames per second, <see cref="DynamicTargetAuto"/>.</summary>
public const uint DlssgDynamicTargetFrameRate = 0x10CF4125;
/// <summary><c>NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS</c>: 0 none, 1 <c>PERF_TO_9X</c>.</summary>
public const uint DlssOptimalSettingsOverride = 0x10AFB76C;
/// <summary>NVIDIA Smooth Motion, 0 off / 1 on — NOT in NVIDIA's header: documented by community profile tools only.</summary>
public const uint SmoothMotion = 0xB0D384C0;
/// <summary>The presets' "latest" value (<c>RENDER_PRESET_Latest</c>).</summary>
public const uint PresetLatest = 0x00FF_FFFF;
/// <summary>The frame-generation preset's "default" value (<c>RENDER_PRESET_Default</c>).</summary>
public const uint PresetDefault = 0x00FF_FFFE;
/// <summary><c>NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_AUTO</c>.</summary>
public const uint DynamicTargetAuto = 0x0100_0000;
/// <summary>What <see cref="IDriverProfileSource"/> asks for, in the order the summary names them.</summary>
public static IReadOnlyList<uint> All { get; } =
[
DlssSrOverride, DlssSrPreset, DlssSrMode, DlssSrScalingRatio, DlaaOverride,
DlssRrOverride, DlssRrPreset, DlssRrMode, DlssRrScalingRatio,
DlssFgOverride, DlssFgPreset, DlssgMultiFrameCount, DlssgMode, DlssgDynamicMultiFrameCountMax, DlssgDynamicTargetFrameRate,
StreamlineDlssOverride, DlssOptimalSettingsOverride, SmoothMotion,
];
}
Loaded 100 of 252 files, more files were not shown because too many files have changed in this diff. Show more