Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 8f4c5f90f1 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
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 22:05:18 +07:00
53 changed files with 1658 additions and 43 deletions

No files matched your search

+15
View File
@@ -40,6 +40,19 @@ 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)").
- **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 +83,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
+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.
+16 -1
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. **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)
@@ -76,6 +76,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
@@ -479,6 +487,13 @@ 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`.
> **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
+1 -1
View File
@@ -327,7 +327,7 @@ Unchanged in spirit from v1, bumped to `v2` for the new message set.
| `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). |
| `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.)* |
+19
View File
@@ -223,6 +223,18 @@ 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`.
>
> **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`.
- 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).
@@ -270,6 +282,13 @@ 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.
### 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.
+8
View File
@@ -1601,6 +1601,14 @@ 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.
- **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.
## Owner-only — no PR can close these
+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" ] }
],
@@ -209,7 +209,9 @@ internal static class AgentServices
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>()));
sp.GetRequiredService<ExecutableRelocator>(),
// beta.8: an executable that cannot run as x64 is refused before anything is scanned or stamped.
new PeArchitectureSource()));
services.AddSingleton<IIpcRequestHandler>(static sp => new AgentRequestHandler(
AgentIdentityFactory.OfThisProcess(sp.GetRequiredService<AgentPaths>().VkLayerDirectory),
TelemetryDescriptor(),
@@ -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">
@@ -145,6 +164,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}"
+88
View File
@@ -1,5 +1,6 @@
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Metrics;
using FrameLedger.Domain.Sessions;
@@ -151,6 +152,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
{
@@ -21,6 +21,12 @@ public sealed record HookingConsentResult(HookingConsentOutcome Outcome, string?
return Shared.Strings.Safety_Refused_CouldNotVerify;
}
// 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));
}
string? family = Refusal.Family ?? Refusal.Signal;
return family is null
? Shared.Strings.Safety_Refused_Unnamed
+78
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),
@@ -256,6 +264,18 @@ 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_ProductVersion),
nameof(GameDetail_Details_Store),
nameof(GameDetail_Details_Version),
nameof(GameDetail_Edit),
nameof(GameDetail_ExeMissing),
nameof(GameDetail_Hooking_Body),
@@ -304,6 +324,7 @@ public static class Strings
nameof(Games_Sort_LastPlayed),
nameof(Games_Sort_Name),
nameof(Games_Sort_Playtime),
nameof(Hooking_NotX64_Format),
nameof(Import_Add),
nameof(Import_Column_Exe),
nameof(Import_Column_Name),
@@ -524,6 +545,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 +559,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),
@@ -694,6 +720,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);
@@ -1114,6 +1156,30 @@ 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_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_ExeMissing => ResourceManager.GetString(nameof(GameDetail_ExeMissing), Culture) ?? nameof(GameDetail_ExeMissing);
@@ -1210,6 +1276,8 @@ public static class Strings
public static string Games_Sort_Playtime => ResourceManager.GetString(nameof(Games_Sort_Playtime), Culture) ?? nameof(Games_Sort_Playtime);
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);
@@ -1650,6 +1718,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 +1746,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);
+104
View File
@@ -2537,4 +2537,108 @@
<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>
</root>
+78
View File
@@ -1913,4 +1913,82 @@ The documents below are the full terms; this summary does not replace them.</val
<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>
</root>
+78
View File
@@ -1908,4 +1908,82 @@ Các tài liệu bên dưới là điều khoản đầy đủ; phần tóm tắ
<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>
</root>
@@ -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,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,6 +11,7 @@ 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 Wpf.Ui.Controls;
@@ -102,6 +103,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
[ObservableProperty]
private bool _hookingSectionVisible = true;
/// <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;
@@ -198,6 +206,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;
@@ -570,7 +583,12 @@ 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);
@@ -581,6 +599,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
PresentChips(detail, lastHooked);
PresentSupports(row);
PresentDetails(row);
PresentMeasured(last, lastHooked);
PresentRecording(row);
PresentHooking(row);
@@ -616,6 +635,49 @@ public sealed partial class GameDetailViewModel : ObservableObject
SupportsEmpty = Supports.Count == 0;
}
private void PresentDetails(GameRow 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))));
}
}
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 +704,13 @@ 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);
HookToggleEnabled = !blocked && !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
@@ -655,8 +723,9 @@ public sealed partial class GameDetailViewModel : ObservableObject
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;
@@ -708,7 +777,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",
@@ -44,6 +44,13 @@ 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;
[ObservableProperty]
private FpsReadoutModel _readout = FpsReadoutModel.Unavailable;
@@ -290,6 +297,7 @@ 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);
Tags = _annotation is null ? string.Empty : string.Join(", ", _annotation.Tags);
Notes = _annotation?.Notes ?? string.Empty;
HasDisplayed = Series?.HasGenerated == true;
@@ -319,6 +327,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();
@@ -38,6 +38,8 @@
<!-- header line + chips -->
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.Line}" />
<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}}" />
<ItemsControl Margin="0,8,0,0" ItemsSource="{Binding ViewModel.Chips}">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
@@ -143,6 +143,12 @@ public sealed class DetectionSweep : IDisposable
return new DetectionSweepReport { Scanned = scanned, Current = current, Unreadable = unreadable, Relocated = relocated };
}
/// <summary>
/// What <c>hook_autodisabled_reason</c> says when the sweep turns off hooking on an executable that cannot run as x64
/// (beta.8). The page says it in the user's language from <c>exe_machine</c>; this is the row's and the log's record.
/// </summary>
public static string NotX64Reason(string architecture) => $"executable is {architecture}: the hook runs in x64 processes only";
/// <summary>One game through the detector and into the row; true when the row took the write.</summary>
private async ValueTask<bool> ScanAsync(GameRow game, ExecutableFingerprint onDisk, CancellationToken ct)
{
@@ -161,15 +167,30 @@ public sealed class DetectionSweep : IDisposable
RulesVersion = r.RulesVersion,
ExeSizeBytes = onDisk.SizeBytes,
ExeMtimeMs = onDisk.MtimeUnixMs,
ExeArchitecture = r.ExeArchitecture,
ExeFileVersion = r.ExeFileVersion,
ExeProductVersion = r.ExeProductVersion,
Libraries = r.Libraries,
};
if (!await _games.ApplyDetectionAsync(game.Id, write, ct).ConfigureAwait(false))
{
return false;
}
// A hooking switch that can never work (beta.8): an x86, ARM or 32-bit-preferring executable is a process the x64
// hook cannot enter. Enabling it is refused up front since this build; a row enabled before it is turned off here
// rather than refused at every launch. The consent stays: the same row with a 64-bit executable can be re-enabled.
if (game.HookEnabled && ExecutableArchitecture.IsKnownNotHookable(r.ExeArchitecture))
{
string reason = NotX64Reason(r.ExeArchitecture);
_ = await _games.AutoDisableHookAsync(game.Id, reason, DateTimeOffset.UtcNow, ct).ConfigureAwait(false);
_log($"detect: {game.Name} — {reason}; hooking turned off");
}
_log($"detect: {game.Name} — engine={r.EngineId ?? (r.EngineUndetermined ? "undetermined" : "none")}"
+ $"{(r.EngineVersion is null ? string.Empty : " " + r.EngineVersion)} platform={r.PlatformId ?? (r.PlatformUndetermined ? "undetermined" : "none")}"
+ $" capabilities=[{string.Join(",", capabilities)}] vulkan={(r.UsesVulkan is { } v ? (v ? "yes" : "no") : "unknown")} rules={r.RulesVersion}");
+ $" capabilities=[{string.Join(",", capabilities)}] vulkan={(r.UsesVulkan is { } v ? (v ? "yes" : "no") : "unknown")} rules={r.RulesVersion}"
+ $" arch={r.ExeArchitecture} libraries={r.Libraries.Count}");
return true;
}
@@ -196,11 +217,15 @@ public sealed class DetectionSweep : IDisposable
return (game, null, gone, gone);
}
/// <summary><c>DetectionCacheKey</c> compared field by field against the row: any difference is a re-run.</summary>
/// <summary>
/// <c>DetectionCacheKey</c> compared field by field against the row: any difference is a re-run — and a row this build
/// has not read the executable's facts for (schema 0011, <c>exe_machine</c> NULL) is one too, once.
/// </summary>
public static bool IsStale(GameRow game, ExecutableFingerprint onDisk, string rulesVersion)
{
ArgumentNullException.ThrowIfNull(game);
return !string.Equals(game.DetectionRulesVersion, rulesVersion, StringComparison.Ordinal)
return game.ExeMachine is null
|| !string.Equals(game.DetectionRulesVersion, rulesVersion, StringComparison.Ordinal)
|| game.DetectionExeSizeBytes != onDisk.SizeBytes
|| game.DetectionExeMtimeMs != onDisk.MtimeUnixMs;
}
@@ -0,0 +1,13 @@
using FrameLedger.Domain.Detection;
namespace FrameLedger.Application.Detection;
/// <summary>
/// What an executable runs as, read from its PE headers (beta.8): an <see cref="ExecutableArchitecture"/> id. Read-only
/// file I/O on the executable — never its process (CLAUDE.md rule 4).
/// </summary>
public interface IExecutableArchitectureSource
{
/// <summary>The id; <see cref="ExecutableArchitecture.Unknown"/> when the file cannot be read as a PE.</summary>
string Read(string exePath);
}
@@ -46,6 +46,10 @@ public sealed class StaticGameDetector(IDetectionRulesSource rulesSource, IGameF
CapabilityIds = [.. evaluator.MatchCapabilities(snapshot).Select(c => c.Id)],
RulesVersion = rules.RulesVersion,
UsesVulkan = snapshot.VulkanLoaderReferenced,
ExeArchitecture = snapshot.ExeArchitecture,
ExeFileVersion = snapshot.PeFileVersion,
ExeProductVersion = snapshot.PeProductVersion,
Libraries = snapshot.Libraries,
};
}
}
@@ -1,11 +1,13 @@
using FrameLedger.Application.AntiCheat;
using FrameLedger.Application.Capture;
using FrameLedger.Application.Consent;
using FrameLedger.Application.Detection;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.Vulkan;
using FrameLedger.Application.Watch;
using FrameLedger.Domain.AntiCheat;
using FrameLedger.Domain.Consent;
using FrameLedger.Domain.Detection;
using FrameLedger.Shared.Ipc;
using FrameLedger.Shared.Safety;
@@ -36,6 +38,13 @@ public sealed class AgentCommandHandler
private readonly VkLayerReconciler? _layer;
private readonly Func<CancellationToken, ValueTask<SweepRetentionAck>>? _sweepRetention;
private readonly ExecutableRelocator? _relocator;
private readonly IExecutableArchitectureSource? _architecture;
/// <summary>
/// <c>Refused.reason</c> for an executable that cannot run as x64 (beta.8); <c>signal</c> carries its
/// <see cref="ExecutableArchitecture"/> id. Not a guard reason — nothing was scanned — so not one of its names.
/// </summary>
public const string NotX64Reason = "ExecutableNotX64";
/// <summary>
/// <c>disclosureVersion</c> is the version of FR-2.1's reviewed disclosure this Agent carries
@@ -45,8 +54,12 @@ public sealed class AgentCommandHandler
public AgentCommandHandler(IGameRepository games, IGameConsentStore consent, IAntiCheatGuard guard, IExecutableIdentitySource identity,
CaptureOrchestrator orchestrator, CapturePause pause, IAgentLifetime lifetime, Func<CancellationToken, ValueTask<string>> updateRules,
string? disclosureVersion = null, TimeProvider? clock = null, VkLayerReconciler? layer = null,
Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweepRetention = null, ExecutableRelocator? relocator = null)
Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweepRetention = null, ExecutableRelocator? relocator = null,
IExecutableArchitectureSource? architecture = null)
{
// beta.8: an executable that cannot run as x64 is refused before anything is scanned or stamped; null skips the
// question (the guard's TargetIsWow64 at a session's start stays the check either way).
_architecture = architecture;
// A drive that changed its letter (2026-09-22): the click that enables hooking looks for the file under another root
// before it says the executable cannot be read.
_relocator = relocator;
@@ -175,6 +188,13 @@ public sealed class AgentCommandHandler
return Error(request, IpcErrorCode.ExecutableUnreadable, $"{path} could not be read, so nothing can be scanned or stamped");
}
// An executable known not to run as x64 (beta.8): the hook can never enter its process, so nothing is scanned or
// stamped and nothing is written — the consent dialog would promise a measurement the capture cannot make.
if (_architecture?.Read(path) is { } architecture && ExecutableArchitecture.IsKnownNotHookable(architecture))
{
return IpcCodec.Encode(IpcMessageType.Refused, request.Id, new RefusedAck(game.Id, NotX64Reason, Family: null, Signal: architecture));
}
// The EXECUTABLE, not its folder (2026-09-25): the guard resolves the install root and runs check 3 on the
// name and the store identity as well as check 4 on the tree.
AntiCheatVerdict verdict = await _guard.PreScanGameAsync(path, ct).ConfigureAwait(false);
@@ -34,4 +34,16 @@ public sealed record DetectionWrite
/// <summary>The exe mtime, unix ms, the run saw.</summary>
public required long ExeMtimeMs { get; init; }
/// <summary>What the executable runs as (schema 0011); written whole, like the capability flags — a fact about a file has no user override.</summary>
public string ExeArchitecture { get; init; } = Domain.Detection.ExecutableArchitecture.Unknown;
/// <summary>The executable's PE <c>FileVersion</c>, or null (written as read: a file that lost its version clears the column).</summary>
public string? ExeFileVersion { get; init; }
/// <summary>The executable's PE <c>ProductVersion</c>, or null.</summary>
public string? ExeProductVersion { get; init; }
/// <summary>The capability files the game ships, with their versions; written whole.</summary>
public IReadOnlyList<Domain.Detection.LibraryFile> Libraries { get; init; } = [];
}
@@ -1,4 +1,5 @@
using FrameLedger.Domain.Consent;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Metrics;
namespace FrameLedger.Application.Persistence;
@@ -97,6 +98,21 @@ public sealed record GameRow
/// <summary>The executable's mtime (unix ms) when the pre-scan last scanned it (schema 0010).</summary>
public long? HookPrescanExeMtimeMs { get; init; }
/// <summary>
/// What the executable runs as (schema 0011, 2026-09-25; <see cref="ExecutableArchitecture"/>): written by the detection
/// sweep from its PE headers. Null when this build has not looked yet; <c>unknown</c> when it looked and could not tell.
/// </summary>
public string? ExeMachine { get; init; }
/// <summary>The executable's PE <c>FileVersion</c> (schema 0011) — the file's word, not the store's (<see cref="GameVersion"/>).</summary>
public string? ExeFileVersion { get; init; }
/// <summary>The executable's PE <c>ProductVersion</c> (schema 0011).</summary>
public string? ExeProductVersion { get; init; }
/// <summary>The capability files the game ships, with their versions (schema 0011, <c>library_versions</c>); empty when none or never looked.</summary>
public IReadOnlyList<LibraryFile> Libraries { get; init; } = [];
public bool InLibrary => RemovedAt is null;
/// <summary>
@@ -0,0 +1,82 @@
namespace FrameLedger.Domain.Detection;
/// <summary>
/// What an executable runs as (beta.8, <c>games.exe_machine</c>), from its PE headers: the COFF machine, and for a .NET
/// executable its CLR header's flags. The ids are stored, so they never change meaning.
/// </summary>
/// <remarks>
/// <para>
/// A .NET executable built "AnyCPU" carries an x86 COFF machine and runs as whatever process the OS starts — a 64-bit one
/// on 64-bit Windows — unless it prefers 32-bit (<c>COMIMAGE_FLAGS_32BITPREFERRED</c>) or requires it
/// (<c>COMIMAGE_FLAGS_32BITREQUIRED</c>, which is plain x86). Reading only the machine would call every FNA or MonoGame
/// title 32-bit.
/// </para>
/// <para>
/// FrameLedger's hook is an x64 DLL loaded with <c>LoadLibraryW</c> (CLAUDE.md rule 3): it can run in an x64 process and in
/// nothing else. <see cref="IsKnownNotHookable"/> names the ids for which that is known before the game ever runs; an id
/// this build could not establish is not one of them — the guard's own <c>TargetIsWow64</c> at a session's start stays
/// the check.
/// </para>
/// </remarks>
public static class ExecutableArchitecture
{
/// <summary>AMD64: the one architecture the hook runs in.</summary>
public const string X64 = "x64";
/// <summary>I386, native (or .NET requiring 32-bit): a WOW64 process on 64-bit Windows.</summary>
public const string X86 = "x86";
/// <summary>ARM64: a native ARM process, which an x64 DLL cannot enter.</summary>
public const string Arm64 = "arm64";
/// <summary>ARMv7 (Thumb-2).</summary>
public const string Arm = "arm";
/// <summary>.NET, IL only: runs as a 64-bit process on 64-bit Windows.</summary>
public const string AnyCpu = "anycpu";
/// <summary>.NET, IL only, 32-bit preferred: runs as a 32-bit process.</summary>
public const string AnyCpu32 = "anycpu32";
/// <summary>A PE whose machine this build does not name.</summary>
public const string Other = "other";
/// <summary>Looked at, and not a PE this build could read: stored so the sweep does not look again every pass.</summary>
public const string Unknown = "unknown";
public const ushort MachineI386 = 0x014C;
public const ushort MachineAmd64 = 0x8664;
public const ushort MachineArm64 = 0xAA64;
public const ushort MachineArmNt = 0x01C4;
/// <summary><c>COMIMAGE_FLAGS_ILONLY</c>.</summary>
public const uint ClrIlOnly = 0x0000_0001;
/// <summary><c>COMIMAGE_FLAGS_32BITREQUIRED</c>.</summary>
public const uint Clr32BitRequired = 0x0000_0002;
/// <summary><c>COMIMAGE_FLAGS_32BITPREFERRED</c> (with 32BITREQUIRED clear it means "AnyCPU, prefer 32-bit").</summary>
public const uint Clr32BitPreferred = 0x0002_0000;
/// <summary>The id for a COFF machine and, when the PE carries a CLR header, its flags (null for a native PE).</summary>
public static string Of(ushort machine, uint? clrFlags) => machine switch
{
MachineAmd64 => X64,
MachineArm64 => Arm64,
MachineArmNt => Arm,
MachineI386 when clrFlags is { } f && (f & ClrIlOnly) != 0 && (f & Clr32BitRequired) == 0
=> (f & Clr32BitPreferred) != 0 ? AnyCpu32 : AnyCpu,
MachineI386 => X86,
_ => Other,
};
/// <summary>Known, before the game runs, to be a process the x64 hook cannot enter.</summary>
public static bool IsKnownNotHookable(string? id) =>
string.Equals(id, X86, StringComparison.Ordinal)
|| string.Equals(id, AnyCpu32, StringComparison.Ordinal)
|| string.Equals(id, Arm64, StringComparison.Ordinal)
|| string.Equals(id, Arm, StringComparison.Ordinal);
}
@@ -118,4 +118,16 @@ public sealed record GameFileSnapshot
/// (<c>17_HOOK_ENGINE</c> §Vulkan).
/// </summary>
public bool? VulkanLoaderReferenced { get; init; }
/// <summary>
/// What the executable runs as (<see cref="ExecutableArchitecture"/>), from its PE headers; <see cref="ExecutableArchitecture.Unknown"/>
/// when they could not be read (beta.8). A fact about the file, not a rule signal.
/// </summary>
public string ExeArchitecture { get; init; } = ExecutableArchitecture.Unknown;
/// <summary>
/// The files a capability rule names that the walk listed, with the versions their PE resources state (beta.8): what
/// the game ships, never what it loaded. Empty when none matched or no rule names a file.
/// </summary>
public IReadOnlyList<LibraryFile> Libraries { get; init; } = [];
}
@@ -0,0 +1,17 @@
namespace FrameLedger.Domain.Detection;
/// <summary>
/// One file a game ships that a capability rule names — <c>nvngx_dlss.dll</c>, <c>sl.interposer.dll</c>,
/// <c>ffx_fsr2_api_x64.dll</c>, <c>libxess.dll</c> — with the version its PE resource states (beta.8,
/// <c>games.library_versions</c>). What the game SHIPS, read from disk: a driver or the NVIDIA App can load another copy
/// at run time, which is <c>sessions.runtime_modules</c>' to say.
/// </summary>
/// <param name="CapabilityId">The capability rule that named the file (<c>dlss</c>, <c>fsr</c>, …).</param>
/// <param name="RelativePath">The file under the install root, forward-slashed.</param>
/// <param name="FileVersion">The numeric file version (<c>3.7.10.0</c>), or null when the file carries none or could not be read.</param>
/// <param name="ProductVersion">The product version string as the file states it, or null.</param>
public sealed record LibraryFile(string CapabilityId, string RelativePath, string? FileVersion, string? ProductVersion)
{
/// <summary>The file's name without its folders.</summary>
public string FileName => RelativePath[(RelativePath.LastIndexOf('/') + 1)..];
}
@@ -272,7 +272,7 @@ public sealed class RuleEvaluator
{
foreach (string e in entries)
{
if (GlobMatch(pattern, e) || GlobMatch(pattern, LeafOf(e)))
if (NamesFile(pattern, e))
{
return SignalOutcome.Match;
}
@@ -283,6 +283,18 @@ public sealed class RuleEvaluator
return listingComplete ? SignalOutcome.NoMatch : SignalOutcome.Unknown;
}
/// <summary>
/// Whether a file signal's glob names <paramref name="relativeFile"/> — its whole relative path or its file name, as
/// a <c>file_exists</c> signal matches. The probe asks it which shipped files a capability rule names, to read their
/// versions (beta.8, <see cref="LibraryFile"/>).
/// </summary>
public static bool NamesFile(string pattern, string relativeFile)
{
ArgumentNullException.ThrowIfNull(pattern);
ArgumentNullException.ThrowIfNull(relativeFile);
return GlobMatch(pattern, relativeFile) || GlobMatch(pattern, LeafOf(relativeFile));
}
private static string LeafOf(string path)
{
int slash = path.LastIndexOf('/');
@@ -50,6 +50,18 @@ public sealed record StaticDetectionResult
/// <summary>The capability id the sweep stores for <see cref="UsesVulkan"/>; not a rule id, and not in the rules file.</summary>
public const string VulkanCapabilityId = "vulkan";
/// <summary>What the executable runs as (<see cref="ExecutableArchitecture"/>) — a fact about the file (beta.8).</summary>
public string ExeArchitecture { get; init; } = ExecutableArchitecture.Unknown;
/// <summary>The executable's PE <c>FileVersion</c>, or null. For an Unreal title it is often the ENGINE's version.</summary>
public string? ExeFileVersion { get; init; }
/// <summary>The executable's PE <c>ProductVersion</c>, or null.</summary>
public string? ExeProductVersion { get; init; }
/// <summary>The capability files the game ships, with their versions (<see cref="GameFileSnapshot.Libraries"/>).</summary>
public IReadOnlyList<LibraryFile> Libraries { get; init; } = [];
/// <summary>
/// Whether a re-run may write <paramref name="detected"/> over a field whose
/// current provenance is <paramref name="existing"/>.
@@ -42,6 +42,12 @@ public sealed class GameFileProbe : IGameFileProbe
/// </remarks>
public const int MaxEntries = 200_000;
/// <summary>
/// How many capability files have their versions read (beta.8). A title ships a handful — DLSS, Streamline's plugins,
/// the FidelityFX DLLs — and each read opens a file; a tree that matches more is named up to here, in walk order.
/// </summary>
public const int MaxLibraryFiles = 48;
private static readonly TimeSpan _regexBudget = TimeSpan.FromMilliseconds(250);
/// <inheritdoc />
@@ -102,9 +108,48 @@ public sealed class GameFileProbe : IGameFileProbe
ManifestFields = new Dictionary<string, string>(StringComparer.Ordinal),
UncollectedFacts = uncollected,
VulkanLoaderReferenced = ReferencesVulkanLoader(exePath, text),
ExeArchitecture = PeImports.ReadArchitecture(exePath),
Libraries = ReadLibraries(dir, files, rules),
});
}
/// <summary>
/// The files the capability rules name, among those the walk listed, with the versions their PE resources state
/// (beta.8): <c>nvngx_dlss.dll 3.7.10.0</c>, <c>sl.interposer.dll 2.4.0.0</c>. A file the rules name twice is listed
/// once, under the first rule; a file whose version cannot be read is listed with none — it is shipped either way.
/// </summary>
private static List<LibraryFile> ReadLibraries(string dir, List<string> files, DetectionRuleSet rules)
{
List<LibraryFile> found = [];
if (string.IsNullOrEmpty(dir) || files.Count == 0)
{
return found;
}
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (CapabilityRule rule in rules.Capabilities)
{
foreach (string pattern in rule.Signals.Signals.Select(static sig => sig.Value))
{
foreach (string file in files.Where(f => RuleEvaluator.NamesFile(pattern, f)))
{
if (found.Count >= MaxLibraryFiles)
{
return found;
}
if (seen.Add(file))
{
VersionInfo v = ReadVersionInfo(Path.Combine(dir, file));
found.Add(new LibraryFile(rule.Id, file, v.NumericFileVersion, string.IsNullOrWhiteSpace(v.ProductVersion) ? null : v.ProductVersion.Trim()));
}
}
}
}
return found;
}
/// <summary>Breadth-first, bounded. Returns false if the walk did not complete.</summary>
private static bool TryWalk(string root, List<string> files, List<string> dirs)
{
@@ -239,14 +284,18 @@ public sealed class GameFileProbe : IGameFileProbe
try
{
FileVersionInfo v = FileVersionInfo.GetVersionInfo(exePath);
return new VersionInfo(v.CompanyName, v.ProductName, v.FileVersion, v.ProductVersion);
// The numeric form from VS_FIXEDFILEINFO: the FileVersion STRING may carry text ("3.7.10.0 built by …").
string? numeric = v.FileMajorPart == 0 && v.FileMinorPart == 0 && v.FileBuildPart == 0 && v.FilePrivatePart == 0
? null
: string.Create(System.Globalization.CultureInfo.InvariantCulture, $"{v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}");
return new VersionInfo(v.CompanyName, v.ProductName, v.FileVersion, v.ProductVersion, numeric);
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
{
// Null everywhere, so every pe_* signal evaluates Unknown. A PE we
// could not read must not make "does the company contain Valve"
// answer no.
return new VersionInfo(null, null, null, null);
return new VersionInfo(null, null, null, null, null);
}
}
@@ -379,7 +428,7 @@ public sealed class GameFileProbe : IGameFileProbe
}
private readonly record struct VersionInfo(string? Company, string? Product, string? FileVersion,
string? ProductVersion)
string? ProductVersion, string? NumericFileVersion)
{
public bool IsEmpty => Company is null && Product is null && FileVersion is null && ProductVersion is null;
}
@@ -0,0 +1,9 @@
using FrameLedger.Application.Detection;
namespace FrameLedger.Infrastructure.Detection;
/// <summary><see cref="IExecutableArchitectureSource"/> over <see cref="PeImports.ReadArchitecture(string)"/>: bounded, read-only, never throws for a bad file.</summary>
public sealed class PeArchitectureSource : IExecutableArchitectureSource
{
public string Read(string exePath) => PeImports.ReadArchitecture(exePath);
}
@@ -1,6 +1,7 @@
using System.Buffers.Binary;
using System.Runtime.InteropServices;
using System.Text;
using FrameLedger.Domain.Detection;
namespace FrameLedger.Infrastructure.Detection;
@@ -8,7 +9,8 @@ namespace FrameLedger.Infrastructure.Detection;
/// The module names an executable imports — its import directory and its delay-load directory — read from the
/// file with bounded, read-only I/O (P4 PR-2). Null when the file is not a PE this reader understands or could not
/// be read; an empty set when it is a PE that imports nothing. Names are returned as the file spells them, in a
/// case-insensitive set.
/// case-insensitive set. Since beta.8 (2026-09-25) the same headers also say what the file runs as
/// (<see cref="ReadArchitecture(string)"/>).
/// </summary>
/// <remarks>
/// <para>
@@ -53,7 +55,7 @@ public static class PeImports
}
byte[] directories = new byte[16 * 8];
List<Section>? sections = ReadHeaders(file, directories);
List<Section>? sections = ReadHeaders(file, directories, out _);
if (sections is null)
{
return null;
@@ -71,9 +73,64 @@ public static class PeImports
return names;
}
/// <summary>DOS header → PE signature → optional header (PE32 or PE32+) → the 16 data directories and the section table. Null when any step does not read as a PE.</summary>
private static List<Section>? ReadHeaders(Stream file, Span<byte> directories)
/// <summary>
/// What the executable runs as (beta.8): the COFF machine and, for a .NET executable, its CLR header's flags, as an
/// <see cref="ExecutableArchitecture"/> id — <see cref="ExecutableArchitecture.Unknown"/> when the file is not a PE
/// this reader understands or could not be read. Never throws for a malformed or missing file.
/// </summary>
public static string ReadArchitecture(string path)
{
ArgumentException.ThrowIfNullOrWhiteSpace(path);
try
{
using FileStream fs = File.OpenRead(path);
return ReadArchitecture(fs);
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or NotSupportedException)
{
return ExecutableArchitecture.Unknown;
}
}
/// <summary>The same over an open stream (tests hand in a synthetic PE).</summary>
public static string ReadArchitecture(Stream file)
{
ArgumentNullException.ThrowIfNull(file);
if (!file.CanSeek || !file.CanRead)
{
return ExecutableArchitecture.Unknown;
}
byte[] directories = new byte[16 * 8];
if (ReadHeaders(file, directories, out ushort machine) is not { } sections)
{
return ExecutableArchitecture.Unknown;
}
// Directory 14: the CLR runtime header (IMAGE_COR20_HEADER, Flags at +16). Present = a .NET executable, whose
// flags decide between AnyCPU and x86 on an I386 machine; one we cannot read is unknown, never "native".
uint rva = BinaryPrimitives.ReadUInt32LittleEndian(directories.AsSpan(14 * 8));
uint size = BinaryPrimitives.ReadUInt32LittleEndian(directories.AsSpan((14 * 8) + 4));
uint? clrFlags = null;
if (rva != 0 && size != 0)
{
Span<byte> cor = stackalloc byte[20];
long at = ToOffset(sections, rva);
if (size < cor.Length || at < 0 || !ReadAt(file, at, cor))
{
return ExecutableArchitecture.Unknown;
}
clrFlags = BinaryPrimitives.ReadUInt32LittleEndian(cor[16..]);
}
return ExecutableArchitecture.Of(machine, clrFlags);
}
/// <summary>DOS header → PE signature → optional header (PE32 or PE32+) → the 16 data directories and the section table. Null when any step does not read as a PE.</summary>
private static List<Section>? ReadHeaders(Stream file, Span<byte> directories, out ushort machine)
{
machine = 0;
Span<byte> dos = stackalloc byte[64];
if (!ReadAt(file, 0, dos) || dos[0] != (byte)'M' || dos[1] != (byte)'Z')
{
@@ -87,6 +144,7 @@ public static class PeImports
return null;
}
machine = BinaryPrimitives.ReadUInt16LittleEndian(sig[4..]);
int sectionCount = BinaryPrimitives.ReadUInt16LittleEndian(sig[6..]);
int optionalSize = BinaryPrimitives.ReadUInt16LittleEndian(sig[20..]);
long optionalOffset = peOffset + 24;
@@ -2,10 +2,11 @@ using System.Text.Json.Serialization;
namespace FrameLedger.Infrastructure.Persistence;
/// <summary>Source-generated JSON for the two JSON columns the UI writes: <c>session_annotations.tags</c> (a string array) and <c>games.field_provenance</c> (field → provenance).</summary>
/// <summary>Source-generated JSON for the two JSON columns the UI writes: <c>session_annotations.tags</c> (a string array) and <c>games.field_provenance</c> (field → provenance) — and, since schema 0011, the Agent's <c>games.library_versions</c>.</summary>
[JsonSourceGenerationOptions(WriteIndented = false)]
[JsonSerializable(typeof(string[]))]
[JsonSerializable(typeof(Dictionary<string, string>))]
[JsonSerializable(typeof(LibraryVersionsJson.Dto[]), TypeInfoPropertyName = "LibraryFileArray")]
internal sealed partial class LedgerJsonContext : JsonSerializerContext
{
}
@@ -0,0 +1,49 @@
using System.Text.Json;
using System.Text.Json.Serialization;
using FrameLedger.Domain.Detection;
namespace FrameLedger.Infrastructure.Persistence;
/// <summary>
/// <c>games.library_versions</c> (schema 0011): the capability files a game ships, as a JSON array of
/// <c>{"capability","path","fileVersion","productVersion"}</c>. The names are the column's, not the Domain record's, so
/// renaming a property cannot silently change what is stored.
/// </summary>
public static class LibraryVersionsJson
{
public static string Serialize(IReadOnlyList<LibraryFile> libraries)
{
ArgumentNullException.ThrowIfNull(libraries);
Dto[] dtos = [.. libraries.Select(static l => new Dto(l.CapabilityId, l.RelativePath, l.FileVersion, l.ProductVersion))];
return JsonSerializer.Serialize(dtos, LedgerJsonContext.Default.LibraryFileArray);
}
/// <summary>What the column holds; empty for NULL and for a value this build cannot read (the next scan rewrites it).</summary>
public static IReadOnlyList<LibraryFile> Parse(string? json)
{
if (string.IsNullOrWhiteSpace(json))
{
return [];
}
try
{
Dto[]? dtos = JsonSerializer.Deserialize(json, LedgerJsonContext.Default.LibraryFileArray);
return dtos is null
? []
: [.. dtos.Where(static d => !string.IsNullOrWhiteSpace(d.Capability) && !string.IsNullOrWhiteSpace(d.Path))
.Select(static d => new LibraryFile(d.Capability!, d.Path!, d.FileVersion, d.ProductVersion))];
}
catch (JsonException)
{
return [];
}
}
/// <summary>One element of the column, as stored.</summary>
internal sealed record Dto(
[property: JsonPropertyName("capability")] string? Capability,
[property: JsonPropertyName("path")] string? Path,
[property: JsonPropertyName("fileVersion")] string? FileVersion,
[property: JsonPropertyName("productVersion")] string? ProductVersion);
}
@@ -0,0 +1,22 @@
-- 0011 (2026-09-25): what a game's files say about themselves (beta.8, owner request: game version, DLSS/FSR versions,
-- 32-bit or 64-bit).
--
-- The detection sweep already read the executable's PE version resource and walked the install tree for the files the
-- capability rules name, and kept neither: games.game_version is the STORE's word (a Steam build id, a GOG or Epic
-- version string) or the user's, under field_provenance, so the file's own versions get columns of their own.
--
-- exe_machine what the executable runs as, from its PE headers: x64 | x86 | arm64 | arm | anycpu |
-- anycpu32 | other | unknown (Domain.Detection.ExecutableArchitecture). NULL = not looked at by
-- this build yet, which the sweep reads as stale; 'unknown' = looked at and unreadable.
-- exe_file_version the executable's PE FileVersion string (for an Unreal title, often the ENGINE's version)
-- exe_product_version its PE ProductVersion string
-- library_versions JSON array: the capability files the game SHIPS, one object per file —
-- {"capability","path","fileVersion","productVersion"}. What the driver or the NVIDIA App loads
-- at run time can differ; that is sessions.runtime_modules.
--
-- Written by the Agent's detection sweep only, whole, like capability_flags: facts about files have no user override.
ALTER TABLE games ADD COLUMN exe_machine TEXT;
ALTER TABLE games ADD COLUMN exe_file_version TEXT;
ALTER TABLE games ADD COLUMN exe_product_version TEXT;
ALTER TABLE games ADD COLUMN library_versions TEXT;
@@ -25,7 +25,8 @@ public sealed class SqliteGameRepository : IGameRepository
+ "platform, store_id, engine, engine_version, publisher, game_version, cover_path, notes, field_provenance, capability_flags, "
+ "rt_default, pt_default, rr_default, hook_consent_at, hook_prescan_state, removed_at, "
+ "detection_rules_version, detection_exe_size_bytes, detection_exe_mtime_ms, record_sessions, "
+ "hook_prescan_rules_version, hook_prescan_exe_size_bytes, hook_prescan_exe_mtime_ms";
+ "hook_prescan_rules_version, hook_prescan_exe_size_bytes, hook_prescan_exe_mtime_ms, "
+ "exe_machine, exe_file_version, exe_product_version, library_versions";
private const string _selectByPath = $"SELECT {_columns} FROM games WHERE exe_path = @path";
@@ -83,6 +84,7 @@ public sealed class SqliteGameRepository : IGameRepository
private const string _applyDetection =
"UPDATE games SET engine = @engine, engine_version = @engineVersion, platform = @platform, capability_flags = @flags, "
+ "field_provenance = @provenance, detection_rules_version = @rules, detection_exe_size_bytes = @size, detection_exe_mtime_ms = @mtime, "
+ "exe_machine = @machine, exe_file_version = @fileVersion, exe_product_version = @productVersion, library_versions = @libraries, "
+ "updated_at = @now WHERE id = @id";
private readonly LedgerDatabase _db;
@@ -253,6 +255,10 @@ public sealed class SqliteGameRepository : IGameRepository
rules = detection.RulesVersion,
size = detection.ExeSizeBytes,
mtime = detection.ExeMtimeMs,
machine = detection.ExeArchitecture,
fileVersion = detection.ExeFileVersion,
productVersion = detection.ExeProductVersion,
libraries = LibraryVersionsJson.Serialize(detection.Libraries),
now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
};
return await c.ExecuteAsync(new CommandDefinition(_applyDetection, p, tx, cancellationToken: token)).ConfigureAwait(false) == 1;
@@ -341,6 +347,10 @@ public sealed class SqliteGameRepository : IGameRepository
HookPrescanRulesVersion = SqliteReaders.String(r, 32),
HookPrescanExeSizeBytes = SqliteReaders.Int64(r, 33),
HookPrescanExeMtimeMs = SqliteReaders.Int64(r, 34),
ExeMachine = SqliteReaders.String(r, 35),
ExeFileVersion = SqliteReaders.String(r, 36),
ExeProductVersion = SqliteReaders.String(r, 37),
Libraries = LibraryVersionsJson.Parse(SqliteReaders.String(r, 38)),
};
private static DateTimeOffset? At(long? unixMs) => unixMs is { } ms ? DateTimeOffset.FromUnixTimeMilliseconds(ms) : null;
@@ -2,6 +2,7 @@ using System.Globalization;
using System.IO;
using FluentAssertions;
using FrameLedger.App.Services;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Sessions;
namespace FrameLedger.App.Tests;
@@ -90,6 +91,46 @@ public sealed class FormatsTests
}
/// <summary>The engine ids as names (2026-09-23): proper nouns in every language; an id this table does not know passes through.</summary>
/// <summary>beta.8: what an executable runs as, in words — an id this build does not know reads as "could not be read".</summary>
[Fact]
public void ArchitecturesAreSaidInWords() => InEnglish(() =>
{
Formats.Architecture(ExecutableArchitecture.X64).Should().Be("64-bit (x64)");
Formats.Architecture(ExecutableArchitecture.X86).Should().Be("32-bit (x86)");
Formats.Architecture(ExecutableArchitecture.AnyCpu).Should().Be(".NET, any CPU (runs as 64-bit)");
Formats.Architecture(ExecutableArchitecture.AnyCpu32).Should().Contain("runs as 32-bit");
Formats.Architecture(ExecutableArchitecture.Arm64).Should().Be("ARM64");
Formats.Architecture(ExecutableArchitecture.Other).Should().Be("another architecture");
Formats.Architecture(ExecutableArchitecture.Unknown).Should().Be("could not be read");
Formats.Architecture("mips").Should().Be("could not be read");
return 0;
});
/// <summary>beta.8: a store's version is said as one; a version the user typed is shown as typed; none is none.</summary>
[Fact]
public void AStoreVersionIsLabelledWithItsStore() => InEnglish(() =>
{
Formats.StoreVersion("steam", "20374416", detected: true).Should().Be("Steam build 20374416");
Formats.StoreVersion("gog", "1.2.3", detected: true).Should().Be("GOG version 1.2.3");
Formats.StoreVersion("epic", "++Fortnite+Release-31.10", detected: true).Should().Be("Epic version ++Fortnite+Release-31.10");
Formats.StoreVersion("itch", "0.9", detected: true).Should().Be("0.9", "itch has no store version to label");
Formats.StoreVersion("steam", "1.04 (my patch)", detected: false).Should().Be("1.04 (my patch)", "the user's words are theirs");
Formats.StoreVersion("steam", " ", detected: true).Should().BeNull();
return 0;
});
[Theory]
[InlineData("3.7.10.0", "3.7.10.0", true)]
[InlineData("2,8,0,0", "2.8.0.0", true)]
[InlineData("3.7.10.0 built by: dlss-release", "3.7.10.0", true)]
[InlineData("3.7.10", "3.7.10.0", true)]
[InlineData("310.2.1.0", "3.7.10.0", false)]
[InlineData(null, "3.7.10.0", null)]
[InlineData("3.7.10.0", null, null)]
[InlineData("n/a", "3.7.10.0", null)]
public void TwoFileVersionsAreTheSameFourNumbers(string? a, string? b, bool? expected) =>
Formats.SameVersion(a, b).Should().Be(expected);
[Fact]
public void EnginesAreNamedAndAnUnknownIdPassesThrough()
{
@@ -401,6 +401,73 @@ public sealed class GameDetailViewModelTests
new GameCardViewModel(new GameCard(game with { HookPrescanState = "clean" }, null)).AntiCheat.Should().BeFalse();
}
/// <summary>
/// beta.8 (schema 0011): the Details card says what the files say — what the executable runs as, its versions, the
/// store's build labelled as one, the engine, and what it ships — and the subtitle labels the store's version too. An
/// x86 executable's switch cannot be turned on, and the page says why; one already on can still be turned off.
/// </summary>
[Fact]
public async Task TheDetailsCardSaysWhatTheFilesSayAndAnX86SwitchCannotBeTurnedOn()
{
CultureInfo? previous = Strings.Culture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
try
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow game = await s.GameAsync("Alpha");
GameRow fresh = await s.GameAsync("Beta");
await s.Db.WriteAsync((c, tx, ct) => Dapper.SqlMapper.ExecuteAsync(c, new Dapper.CommandDefinition(
"UPDATE games SET platform = 'steam', game_version = '20374416', field_provenance = '{\"game_version\":\"detected\",\"platform\":\"detected\"}', "
+ "engine = 'unreal', engine_version = '5.3', exe_machine = 'x86', exe_file_version = '1.0.2.0', exe_product_version = '1.0.2', "
+ "library_versions = '[{\"capability\":\"dlss\",\"path\":\"bin/nvngx_dlss.dll\",\"fileVersion\":\"3.7.10.0\"},{\"capability\":\"xess\",\"path\":\"libxess.dll\"}]' "
+ "WHERE id = @id", new { id = game.Id }, tx, cancellationToken: ct)), Ct);
(GameDetailViewModel vm, _, _, _, _) = await BuildAsync(s, game.Id);
vm.Subtitle.Should().Be("Steam build 20374416 · Unreal Engine 5.3", "the store names itself in its version");
vm.Details.Should().Equal(
new GameDetailRow("Runs as", "32-bit (x86)"),
new GameDetailRow("File version", "1.0.2.0"),
new GameDetailRow("Product version", "1.0.2"),
new GameDetailRow("Store", "Steam build 20374416"),
new GameDetailRow("Engine", "Unreal Engine 5.3"),
new GameDetailRow("Ships with", "DLSS: nvngx_dlss.dll 3.7.10.0" + Environment.NewLine + "XeSS: libxess.dll (no version)"));
vm.HookToggleEnabled.Should().BeFalse("turning hooking on could only be refused");
vm.NotX64Text.Should().Contain("32-bit (x86)");
await s.Db.WriteAsync((c, tx, ct) => Dapper.SqlMapper.ExecuteAsync(c, new Dapper.CommandDefinition(
"UPDATE games SET hook_enabled = 1, hook_autodisabled_reason = 'crashed twice' WHERE id = @id", new { id = game.Id }, tx, cancellationToken: ct)), Ct);
await vm.LoadAsync(Ct);
vm.HookToggleEnabled.Should().BeTrue("a switch that is on can be turned off whatever the file is");
(GameDetailViewModel unread, _, _, _, _) = await BuildAsync(s, fresh.Id);
unread.Details.Should().ContainSingle().Which.Should().Be(new GameDetailRow("Runs as", Strings.GameDetail_Details_NotRead));
unread.NotX64Text.Should().BeNull("not read is not known 32-bit");
unread.HookToggleEnabled.Should().BeTrue();
}
finally
{
Strings.Culture = previous;
}
}
/// <summary>The Agent's refusal for such an executable (beta.8, <c>ExecutableNotX64</c>) is said in words, with the architecture.</summary>
[Fact]
public void ANotX64RefusalNamesTheArchitecture()
{
CultureInfo? previous = Strings.Culture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
try
{
new HookingConsentResult(HookingConsentOutcome.Refused, Refusal: new RefusedAck(1, "ExecutableNotX64", null, "anycpu32")).RefusalText()
.Should().Contain(Formats.Architecture("anycpu32")).And.Contain("64-bit (x64) games only");
}
finally
{
Strings.Culture = previous;
}
}
[Fact]
public async Task RemovingRevokesOverThePipeFirstAndGoesBackToTheGrid()
{
@@ -151,4 +151,39 @@ public sealed class SessionSummaryViewModelTests
System.IO.Directory.Delete(dir, recursive: true);
}
}
/// <summary>
/// beta.8: the runtime libraries a hooked session loaded (<c>runtime_modules</c>, written since P2 and shown nowhere) as
/// one line, sorted — each beside the copy the game ships when the two differ, the shape a DLSS the NVIDIA App or the
/// driver substituted has. A row with none has no line.
/// </summary>
[Fact]
public void TheLoadedLibrariesNameAnotherCopyWhereTheGameShipsADifferentOne()
{
CultureInfo? previous = Strings.Culture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
try
{
IReadOnlyList<Domain.Detection.LibraryFile> shipped =
[
new("dlss", "Engine/Plugins/nvngx_dlss.dll", "3.7.10.0", null),
new("streamline", "sl.interposer.dll", "2.8.0.0", null),
];
string? line = SessionSummaryViewModel.LoadedLibraries(
"{\"sl.interposer.dll\":\"2,8,0,0\",\"nvngx_dlss.dll\":\"310.2.1.0\",\"ffx_fsr3_x64.dll\":null}", shipped);
line.Should().StartWith("Loaded: ");
line.Should().Contain("nvngx_dlss.dll 310.2.1.0 (the game ships 3.7.10.0: another copy was loaded");
line.Should().Contain("sl.interposer.dll 2,8,0,0").And.NotContain("sl.interposer.dll 2,8,0,0 (", "the same four numbers");
line.Should().Contain("ffx_fsr3_x64.dll " + Strings.Common_NotAvailable, "a module with no version resource");
line!.IndexOf("ffx_fsr3", StringComparison.Ordinal).Should().BeLessThan(line.IndexOf("nvngx", StringComparison.Ordinal), "sorted by name");
SessionSummaryViewModel.LoadedLibraries(null, shipped).Should().BeNull();
SessionSummaryViewModel.LoadedLibraries("{}", shipped).Should().BeNull();
SessionSummaryViewModel.LoadedLibraries("not json", shipped).Should().BeNull();
}
finally
{
Strings.Culture = previous;
}
}
}
@@ -44,6 +44,10 @@ public sealed class DetectionSweepTests
public bool? VulkanLoaderReferenced { get; set; }
public string Architecture { get; set; } = ExecutableArchitecture.X64;
public IReadOnlyList<LibraryFile> Libraries { get; set; } = [];
public ValueTask<GameFileSnapshot> SnapshotAsync(string exePath, DetectionRuleSet rules, CancellationToken ct = default)
{
Calls++;
@@ -61,6 +65,10 @@ public sealed class DetectionSweepTests
StringsRegexCaptures = new Dictionary<string, string>(StringComparer.Ordinal),
ManifestFields = new Dictionary<string, string>(StringComparer.Ordinal),
UncollectedFacts = new HashSet<DetectionSignalType>(),
ExeArchitecture = Architecture,
PeFileVersion = "1.0.2.0",
PeProductVersion = "1.0.2",
Libraries = Libraries,
});
}
}
@@ -112,6 +120,80 @@ public sealed class DetectionSweepTests
probe.Calls.Should().Be(1, "a current game is not walked again");
}
/// <summary>beta.8 (schema 0011): the executable's own facts ride the same write — what it runs as, its versions, what it ships.</summary>
[Fact]
public async Task TheExecutablesOwnFactsAreWrittenWithTheDetection()
{
(DetectionSweep sweep, FakeGameRepository games, _, ScriptedProbe probe, _, List<string> log) = await BuildAsync();
probe.Libraries = [new LibraryFile("dlss", "Engine/Plugins/DLSS/nvngx_dlss.dll", "3.7.10.0", "3.7.10")];
await sweep.SweepOnceAsync(Ct);
DetectionWrite w = games.Detections.Single().Write;
w.ExeArchitecture.Should().Be(ExecutableArchitecture.X64);
(w.ExeFileVersion, w.ExeProductVersion).Should().Be(("1.0.2.0", "1.0.2"));
w.Libraries.Should().ContainSingle().Which.FileName.Should().Be("nvngx_dlss.dll");
games.Rows[_exe].ExeMachine.Should().Be("x64");
log.Should().Contain(static l => l.Contains("arch=x64 libraries=1", StringComparison.Ordinal));
games.Disabled.Should().BeEmpty("nothing about an x64 executable turns hooking off");
}
/// <summary>A row this build has not read the executable's facts for is stale once, whatever its key says (schema 0011).</summary>
[Fact]
public void ARowWithoutTheExecutablesFactsIsStaleOnce()
{
var onDisk = new ExecutableFingerprint { ExePath = _exe, SizeBytes = 5, MtimeUnixMs = 5 };
var row = new GameRow
{
Id = 1,
Name = "T",
Fingerprint = onDisk,
DetectionRulesVersion = "2026.09.1",
DetectionExeSizeBytes = 5,
DetectionExeMtimeMs = 5,
HookEnabled = false,
HookCrashCount = 0,
AddedAt = DateTimeOffset.UnixEpoch,
UpdatedAt = DateTimeOffset.UnixEpoch,
};
DetectionSweep.IsStale(row, onDisk, "2026.09.1").Should().BeTrue("exe_machine is NULL: read under an older build");
DetectionSweep.IsStale(row with { ExeMachine = ExecutableArchitecture.Unknown }, onDisk, "2026.09.1").Should().BeFalse(
"looked at and unreadable is an answer, stored so the file is not read again every pass");
}
/// <summary>
/// beta.8: an executable the x64 hook cannot enter has its hooking turned off by the sweep when a row enabled before this
/// build still has it on — rather than a refusal at every launch — with the architecture in the row's reason.
/// </summary>
[Theory]
[InlineData(ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.AnyCpu32)]
[InlineData(ExecutableArchitecture.Arm64)]
public async Task AHookEnabledRowWhoseExecutableCannotRunAsX64IsTurnedOff(string architecture)
{
(DetectionSweep sweep, FakeGameRepository games, _, ScriptedProbe probe, _, List<string> log) = await BuildAsync();
games.Rows[_exe] = games.Rows[_exe] with { HookEnabled = true };
probe.Architecture = architecture;
await sweep.SweepOnceAsync(Ct);
games.Disabled.Should().ContainSingle().Which.Reason.Should().Be(DetectionSweep.NotX64Reason(architecture));
log.Should().Contain(l => l.Contains("hooking turned off", StringComparison.Ordinal));
}
[Fact]
public async Task ARowWhoseHookingIsOffIsNotTouchedWhateverItsArchitecture()
{
(DetectionSweep sweep, FakeGameRepository games, _, ScriptedProbe probe, _, _) = await BuildAsync();
probe.Architecture = ExecutableArchitecture.X86;
await sweep.SweepOnceAsync(Ct);
games.Disabled.Should().BeEmpty("nothing to turn off; the page says why it cannot be turned on");
games.Rows[_exe].ExeMachine.Should().Be(ExecutableArchitecture.X86);
}
[Fact]
public async Task AChangedExeOrANewRulesVersionRescans()
{
@@ -209,8 +291,9 @@ public sealed class DetectionSweepTests
public void StalenessIsTheCacheKeyFieldByField()
{
var onDisk = new ExecutableFingerprint { ExePath = _exe, SizeBytes = 5, MtimeUnixMs = 7 };
GameRow current = new() { Id = 1, Name = "T", Fingerprint = onDisk, HookEnabled = false, HookCrashCount = 0, AddedAt = DateTimeOffset.UnixEpoch, UpdatedAt = DateTimeOffset.UnixEpoch, DetectionRulesVersion = "v", DetectionExeSizeBytes = 5, DetectionExeMtimeMs = 7 };
GameRow current = new() { Id = 1, Name = "T", Fingerprint = onDisk, HookEnabled = false, HookCrashCount = 0, AddedAt = DateTimeOffset.UnixEpoch, UpdatedAt = DateTimeOffset.UnixEpoch, DetectionRulesVersion = "v", DetectionExeSizeBytes = 5, DetectionExeMtimeMs = 7, ExeMachine = "x64" };
DetectionSweep.IsStale(current, onDisk, "v").Should().BeFalse();
DetectionSweep.IsStale(current with { ExeMachine = null }, onDisk, "v").Should().BeTrue("the executable's facts were never read (schema 0011)");
DetectionSweep.IsStale(current with { DetectionRulesVersion = null }, onDisk, "v").Should().BeTrue("never scanned");
DetectionSweep.IsStale(current, onDisk, "w").Should().BeTrue("rules moved");
DetectionSweep.IsStale(current with { DetectionExeSizeBytes = 4 }, onDisk, "v").Should().BeTrue("size changed");
@@ -3,6 +3,7 @@ using FluentAssertions;
using FrameLedger.Application.AntiCheat;
using FrameLedger.Application.Capture;
using FrameLedger.Application.Consent;
using FrameLedger.Application.Detection;
using FrameLedger.Application.Ipc;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.Recording;
@@ -10,6 +11,7 @@ using FrameLedger.Application.Tests.Recording;
using FrameLedger.Application.Watch;
using FrameLedger.Domain.AntiCheat;
using FrameLedger.Domain.Consent;
using FrameLedger.Domain.Detection;
using FrameLedger.Infrastructure.Persistence;
using FrameLedger.Shared.Ipc;
@@ -128,7 +130,20 @@ public sealed class AgentCommandHandlerTests : IAsyncDisposable
public int RulesUpdates { get; set; }
}
private async Task<Harness> BuildAsync(bool consented = true, string? disclosureVersion = null, Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweep = null)
/// <summary>What the executable runs as, scripted (beta.8).</summary>
private sealed class ScriptedArchitecture(string answer) : IExecutableArchitectureSource
{
public List<string> Read { get; } = [];
string IExecutableArchitectureSource.Read(string exePath)
{
Read.Add(exePath);
return answer;
}
}
private async Task<Harness> BuildAsync(bool consented = true, string? disclosureVersion = null, Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweep = null,
IExecutableArchitectureSource? architecture = null)
{
_db ??= await LedgerDatabase.OpenAsync(Path.Combine(_dir, LedgerPaths.DatabaseFileName), ct: Ct).ConfigureAwait(false);
var consent = new SqliteGameConsentStore(_db);
@@ -153,7 +168,7 @@ public sealed class AgentCommandHandlerTests : IAsyncDisposable
Harness h = null!;
var handler = new AgentCommandHandler(games, consent, guard, identity, orchestrator, pause, lifetime,
_ => { h.RulesUpdates++; return ValueTask.FromResult("AlreadyCurrent"); },
disclosureVersion, new FakeClock(), sweepRetention: sweep);
disclosureVersion, new FakeClock(), sweepRetention: sweep, architecture: architecture);
h = new Harness
{
Handler = handler,
@@ -275,6 +290,33 @@ public sealed class AgentCommandHandlerTests : IAsyncDisposable
record.ConsentedAt.Should().BeNull("nothing was stamped");
}
/// <summary>
/// beta.8: an executable that cannot run as x64 is refused before anything is scanned or stamped — the dialog would
/// promise a measurement the hook cannot make — and the refusal names the architecture. An x64 one goes on as before.
/// </summary>
[Fact]
public async Task SetHookEnabledTrueForAnExecutableThatCannotRunAsX64IsRefusedBeforeTheScan()
{
var x86 = new ScriptedArchitecture(ExecutableArchitecture.X86);
Harness h = await BuildAsync(consented: false, disclosureVersion: "consent-dialog/1", architecture: x86).ConfigureAwait(true);
long gameId = h.Games.Rows[_exe].Id;
IpcEnvelope ack = await AskAsync(h.Handler, IpcMessageType.SetHookEnabled, new SetHookEnabledRequest(gameId, Enabled: true, "consent-dialog/1")).ConfigureAwait(true);
ack.Type.Should().Be(IpcMessageType.Refused);
RefusedAck refused = IpcCodec.Payload<RefusedAck>(ack)!;
(refused.Reason, refused.Family, refused.Signal).Should().Be((AgentCommandHandler.NotX64Reason, (string?)null, ExecutableArchitecture.X86));
x86.Read.Should().ContainSingle().Which.Should().Be(_exe);
h.Guard.Scanned.Should().BeEmpty("nothing is scanned for a process the hook can never enter");
GameConsentRecord record = await h.Consent.FindAsync(_exe, Ct).ConfigureAwait(true);
(record.HookEnabled, record.ConsentedAt, record.BlockedReason).Should().Be((false, (DateTimeOffset?)null, (string?)null),
"nothing is written: this is not a block, and a 64-bit build of the game could be hooked");
Harness x64 = await BuildAsync(consented: false, architecture: new ScriptedArchitecture(ExecutableArchitecture.X64)).ConfigureAwait(true);
_ = await AskAsync(x64.Handler, IpcMessageType.SetHookEnabled, new SetHookEnabledRequest(x64.Games.Rows[_exe].Id, Enabled: true, "v")).ConfigureAwait(true);
x64.Guard.Scanned.Should().ContainSingle("an x64 executable is scanned as before");
}
[Fact]
public async Task SetHookEnabledTrueWithACleanScanStampsNothingWhenTheAgentCarriesNoDisclosure()
{
@@ -180,6 +180,10 @@ internal sealed class FakeGameRepository : IGameRepository
DetectionRulesVersion = detection.RulesVersion,
DetectionExeSizeBytes = detection.ExeSizeBytes,
DetectionExeMtimeMs = detection.ExeMtimeMs,
ExeMachine = detection.ExeArchitecture,
ExeFileVersion = detection.ExeFileVersion,
ExeProductVersion = detection.ExeProductVersion,
Libraries = detection.Libraries,
};
return ValueTask.FromResult(true);
}
@@ -0,0 +1,54 @@
using FluentAssertions;
using FrameLedger.Domain.Detection;
namespace FrameLedger.Domain.Tests;
/// <summary>
/// What an executable runs as (beta.8, <c>games.exe_machine</c>): the COFF machine, and for .NET the CLR flags; and which
/// ids are known before a launch to be processes the x64 hook cannot enter — never an id this build could not establish.
/// </summary>
public sealed class ExecutableArchitectureTests
{
[Theory]
[InlineData(ExecutableArchitecture.MachineAmd64, null, ExecutableArchitecture.X64)]
[InlineData(ExecutableArchitecture.MachineI386, null, ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.MachineArm64, null, ExecutableArchitecture.Arm64)]
[InlineData(ExecutableArchitecture.MachineArmNt, null, ExecutableArchitecture.Arm)]
[InlineData((ushort)0x0200, null, ExecutableArchitecture.Other)]
[InlineData(ExecutableArchitecture.MachineI386, ExecutableArchitecture.ClrIlOnly, ExecutableArchitecture.AnyCpu)]
[InlineData(ExecutableArchitecture.MachineI386, ExecutableArchitecture.ClrIlOnly | ExecutableArchitecture.Clr32BitPreferred, ExecutableArchitecture.AnyCpu32)]
[InlineData(ExecutableArchitecture.MachineI386, ExecutableArchitecture.ClrIlOnly | ExecutableArchitecture.Clr32BitRequired, ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.MachineI386, 0u, ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.MachineAmd64, ExecutableArchitecture.ClrIlOnly, ExecutableArchitecture.X64)]
public void TheIdIsTheMachineAndForDotNetTheClrFlags(ushort machine, uint? clrFlags, string expected) =>
ExecutableArchitecture.Of(machine, clrFlags).Should().Be(expected);
[Theory]
[InlineData(ExecutableArchitecture.X86, true)]
[InlineData(ExecutableArchitecture.AnyCpu32, true)]
[InlineData(ExecutableArchitecture.Arm64, true)]
[InlineData(ExecutableArchitecture.Arm, true)]
[InlineData(ExecutableArchitecture.X64, false)]
[InlineData(ExecutableArchitecture.AnyCpu, false)]
[InlineData(ExecutableArchitecture.Other, false)]
[InlineData(ExecutableArchitecture.Unknown, false)]
[InlineData(null, false)]
public void OnlyAnEstablishedNonX64IdIsKnownNotHookable(string? id, bool expected) =>
ExecutableArchitecture.IsKnownNotHookable(id).Should().Be(expected, "an id this build could not establish is the guard's to decide at launch");
[Theory]
[InlineData("nvngx_dlss.dll", "nvngx_dlss.dll", true)]
[InlineData("nvngx_dlss.dll", "Engine/Plugins/DLSS/Binaries/nvngx_dlss.dll", true)]
[InlineData("ffx_fsr3*.dll", "bin/FFX_FSR3UPSCALER_X64.DLL", true)]
[InlineData("libxess.dll", "libxess_dx11.dll", false)]
[InlineData("ffx_fsr2_*.dll", "ffx_fsr3_x64.dll", false)]
public void AFileGlobNamesTheWholePathOrTheFileName(string pattern, string file, bool expected) =>
RuleEvaluator.NamesFile(pattern, file).Should().Be(expected);
[Fact]
public void ALibraryFilesNameIsItsLastSegment()
{
new LibraryFile("dlss", "Engine/Plugins/nvngx_dlss.dll", "3.7.10.0", null).FileName.Should().Be("nvngx_dlss.dll");
new LibraryFile("xess", "libxess.dll", null, null).FileName.Should().Be("libxess.dll");
}
}
@@ -80,9 +80,98 @@ public sealed class PeImportsTests
}
/// <summary>The smallest PE32+ this reader accepts: one section holding the import and delay-load directories and their names.</summary>
/// <summary>
/// beta.8: what the file runs as, from the COFF machine and — for a .NET executable — the CLR header's flags. An
/// "AnyCPU" assembly carries an x86 machine and runs as 64-bit unless it prefers or requires 32-bit.
/// </summary>
[Theory]
[InlineData(ExecutableArchitecture.MachineAmd64, false, null, ExecutableArchitecture.X64)]
[InlineData(ExecutableArchitecture.MachineI386, true, null, ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.MachineArm64, false, null, ExecutableArchitecture.Arm64)]
[InlineData(ExecutableArchitecture.MachineArmNt, true, null, ExecutableArchitecture.Arm)]
[InlineData((ushort)0x0200, false, null, ExecutableArchitecture.Other)]
[InlineData(ExecutableArchitecture.MachineI386, true, 0x1u, ExecutableArchitecture.AnyCpu)]
[InlineData(ExecutableArchitecture.MachineI386, true, 0x2_0001u, ExecutableArchitecture.AnyCpu32)]
[InlineData(ExecutableArchitecture.MachineI386, true, 0x3u, ExecutableArchitecture.X86)]
[InlineData(ExecutableArchitecture.MachineAmd64, false, 0x1u, ExecutableArchitecture.X64)]
public void TheArchitectureIsTheMachineAndForDotNetTheClrFlags(ushort machine, bool pe32, uint? clrFlags, string expected)
{
using var pe = new MemoryStream(SyntheticPe.Build(imports: ["KERNEL32.dll"], delayImports: [], machine: machine, pe32: pe32, clrFlags: clrFlags));
PeImports.ReadArchitecture(pe).Should().Be(expected);
}
[Fact]
public void AFileThatIsNotAPeOrIsCutShortIsUnknownNeverAnException()
{
using var text = new MemoryStream(Encoding.ASCII.GetBytes("this is not a portable executable"));
PeImports.ReadArchitecture(text).Should().Be(ExecutableArchitecture.Unknown);
byte[] dotnet = SyntheticPe.Build(imports: ["mscoree.dll"], delayImports: [], machine: ExecutableArchitecture.MachineI386, pe32: true, clrFlags: 0x1);
using var cut = new MemoryStream(dotnet[..^60]);
PeImports.ReadArchitecture(cut).Should().Be(ExecutableArchitecture.Unknown, "a CLR header that cannot be read is not \"native x86\"");
PeImports.ReadArchitecture(Path.Combine(Path.GetTempPath(), "fl-no-such-" + Guid.NewGuid().ToString("N") + ".exe"))
.Should().Be(ExecutableArchitecture.Unknown);
}
/// <summary>
/// beta.8: the probe names the capability files the walk listed with the versions their resources state — a file with
/// no version resource is still shipped — and reads what the executable runs as.
/// </summary>
[Fact]
public async Task TheProbeReadsTheShippedCapabilityFilesVersionsAndTheArchitecture()
{
string dir = Path.Combine(Path.GetTempPath(), "fl-libs-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(Path.Combine(dir, "bin"));
try
{
string exe = Path.Combine(dir, "game.exe");
await File.WriteAllBytesAsync(exe, SyntheticPe.Build(imports: ["KERNEL32.dll"], delayImports: []), Ct);
// A real DLL with a version resource under a capability's name, and an empty one with none.
string system = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "version.dll");
string copy = Path.Combine(dir, "bin", "nvngx_dlss.dll");
File.Copy(system, copy);
await File.WriteAllBytesAsync(Path.Combine(dir, "libxess.dll"), [], Ct);
// The copy's own resource: System32's file reads through its .mui, which a copy elsewhere does not have.
System.Diagnostics.FileVersionInfo v = System.Diagnostics.FileVersionInfo.GetVersionInfo(copy);
var rules = new DetectionRuleSet
{
SchemaVersion = 2,
RulesVersion = "t",
Engines = [],
Platforms = [],
Capabilities =
[
new CapabilityRule { Id = "dlss", Name = "DLSS", Signals = Glob("nvngx_dlss.dll") },
new CapabilityRule { Id = "xess", Name = "XeSS", Signals = Glob("libxess.dll", "libxess_dx11.dll") },
],
};
GameFileSnapshot snapshot = await new GameFileProbe().SnapshotAsync(exe, rules, Ct);
snapshot.ExeArchitecture.Should().Be(ExecutableArchitecture.X64);
snapshot.Libraries.Should().HaveCount(2);
LibraryFile dlss = snapshot.Libraries.Single(static l => string.Equals(l.CapabilityId, "dlss", StringComparison.Ordinal));
dlss.RelativePath.Should().Be("bin/nvngx_dlss.dll");
dlss.FileVersion.Should().Be($"{v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}", "the fixed part, not the string");
snapshot.Libraries.Single(static l => string.Equals(l.CapabilityId, "xess", StringComparison.Ordinal)).FileVersion.Should().BeNull("no version resource: shipped, version unknown");
}
finally
{
Directory.Delete(dir, recursive: true);
}
}
private static SignalGroup Glob(params string[] patterns) => new()
{
Combinator = SignalCombinator.Any,
Signals = [.. patterns.Select(static p => new DetectionSignal { Type = DetectionSignalType.SiblingGlob, Value = p })],
};
private static class SyntheticPe
{
public static byte[] Build(IReadOnlyList<string> imports, IReadOnlyList<string> delayImports, byte[]? trailing = null)
public static byte[] Build(IReadOnlyList<string> imports, IReadOnlyList<string> delayImports, byte[]? trailing = null,
ushort machine = ExecutableArchitecture.MachineAmd64, bool pe32 = false, uint? clrFlags = null)
{
const uint sectionRva = 0x1000;
const uint sectionRaw = 0x400;
@@ -101,8 +190,16 @@ public sealed class PeImportsTests
}
int trailingAt = cursor;
int sectionSize = cursor + (trailing?.Length ?? 0);
// A .NET executable: IMAGE_COR20_HEADER (72 bytes, Flags at +16) after everything else, 4-byte aligned.
int corAt = (trailingAt + (trailing?.Length ?? 0) + 3) & ~3;
int sectionSize = clrFlags is null ? cursor + (trailing?.Length ?? 0) : corAt + 72;
byte[] section = new byte[sectionSize];
if (clrFlags is { } flags)
{
BinaryPrimitives.WriteUInt32LittleEndian(section.AsSpan(corAt), 72);
BinaryPrimitives.WriteUInt32LittleEndian(section.AsSpan(corAt + 16), flags);
}
for (int i = 0; i < imports.Count; i++)
{
BinaryPrimitives.WriteUInt32LittleEndian(section.AsSpan(i * importDescriptorSize + 12), sectionRva + (uint)names[i].Offset);
@@ -121,26 +218,35 @@ public sealed class PeImportsTests
trailing?.CopyTo(section, trailingAt);
byte[] file = new byte[sectionRaw + sectionSize];
WriteHeaders(file, sectionRva, sectionRaw, sectionSize, importsBytes, delayImports.Count > 0 ? delayBytes : 0);
WriteHeaders(file, sectionRva, sectionRaw, sectionSize, importsBytes, delayImports.Count > 0 ? delayBytes : 0, machine, pe32,
clrFlags is null ? 0u : sectionRva + (uint)corAt);
section.CopyTo(file, (int)sectionRaw);
return file;
}
/// <summary>DOS header, PE signature, a PE32+ optional header whose directories 1 and 13 point into the one section, and that section's header.</summary>
private static void WriteHeaders(byte[] file, uint sectionRva, uint sectionRaw, int sectionSize, int importsBytes, int delayBytes)
/// <summary>DOS header, PE signature, a PE32+ (or PE32) optional header whose directories 1, 13 and 14 point into the one section, and that section's header.</summary>
private static void WriteHeaders(byte[] file, uint sectionRva, uint sectionRaw, int sectionSize, int importsBytes, int delayBytes,
ushort machine, bool pe32, uint corRva)
{
int optionalSize = pe32 ? 224 : 240;
// DOS header: "MZ", e_lfanew at 60 → 0x80.
file[0] = (byte)'M';
file[1] = (byte)'Z';
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(60), 0x80);
// PE signature + file header: 1 section, optional header size 240 (PE32+).
// PE signature + file header: the machine, 1 section, optional header size 240 (PE32+) or 224 (PE32).
file[0x80] = (byte)'P';
file[0x81] = (byte)'E';
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(0x84), machine);
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(0x84 + 2), 1);
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(0x84 + 16), 240);
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(0x84 + 16), (ushort)optionalSize);
int optional = 0x84 + 20;
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(optional), 0x20B);
int directories = optional + 112;
BinaryPrimitives.WriteUInt16LittleEndian(file.AsSpan(optional), pe32 ? (ushort)0x10B : (ushort)0x20B);
int directories = optional + (pe32 ? 96 : 112);
if (corRva != 0)
{
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(directories + 14 * 8), corRva);
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(directories + 14 * 8 + 4), 72);
}
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(directories + 1 * 8), sectionRva);
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(directories + 1 * 8 + 4), (uint)importsBytes);
if (delayBytes > 0)
@@ -150,7 +256,7 @@ public sealed class PeImportsTests
}
// One section header right after the optional header.
int sectionHeader = optional + 240;
int sectionHeader = optional + optionalSize;
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(sectionHeader + 8), (uint)sectionSize);
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(sectionHeader + 12), sectionRva);
BinaryPrimitives.WriteUInt32LittleEndian(file.AsSpan(sectionHeader + 16), (uint)sectionSize);
@@ -133,6 +133,39 @@ public sealed class LedgerDatabaseTests
cancellationToken: Ct)).ConfigureAwait(false);
}
/// <summary>
/// Schema 0011 (2026-09-25): what a game's files say about themselves — what the executable runs as, its two PE versions,
/// the capability files it ships. Applied from schema 10 to a ledger holding a row: the four columns exist and read NULL,
/// and a NULL <c>exe_machine</c> is what makes the detection sweep read the row once more.
/// </summary>
[Fact]
public async Task ScriptElevenAddsTheExecutableFactsEmptyForExistingRows()
{
await using LedgerFixture f = await LedgerFixture.OpenAsync();
MigrationRunner.LatestVersion.Should().BeGreaterThanOrEqualTo(11);
string path = f.Path;
await f.Db.WriteAsync((c, tx, ct) => c.ExecuteAsync(new CommandDefinition(
"INSERT INTO games (name, exe_path, added_at, updated_at) VALUES ('A game', 'D:\\g\\game.exe', 1, 1)",
transaction: tx, cancellationToken: ct)), Ct).ConfigureAwait(true);
await f.Db.DisposeAsync().ConfigureAwait(true);
var c10 = new SqliteConnection(new SqliteConnectionStringBuilder { DataSource = path, Pooling = false }.ToString());
await using (c10.ConfigureAwait(true))
{
await c10.OpenAsync(Ct).ConfigureAwait(true);
await RewindToAsync(c10, 10).ConfigureAwait(true);
}
LedgerDatabase migrated = await LedgerDatabase.OpenAsync(path, ct: Ct).ConfigureAwait(true);
await using (migrated.ConfigureAwait(true))
{
migrated.SchemaVersion.Should().Be(MigrationRunner.LatestVersion);
(string? Machine, string? File, string? Product, string? Libraries) facts = await migrated.ReadAsync((c, ct) =>
c.QuerySingleAsync<(string?, string?, string?, string?)>(new CommandDefinition(
"SELECT exe_machine, exe_file_version, exe_product_version, library_versions FROM games", cancellationToken: ct)), Ct).ConfigureAwait(true);
facts.Should().Be(((string?)null, (string?)null, (string?)null, (string?)null));
}
}
/// <summary>
/// Schema 0010 (2026-09-25): the Agent's pre-scan of the library keeps its own key — the rules version and the
/// executable's size and mtime it last scanned under. Applied from schema 9 to a ledger holding a row: the three
@@ -4,6 +4,7 @@ using FluentAssertions;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.TriState;
using FrameLedger.Domain.Consent;
using FrameLedger.Domain.Detection;
using FrameLedger.Domain.Metrics;
using FrameLedger.Domain.Sessions;
using FrameLedger.Infrastructure.Persistence;
@@ -88,6 +89,61 @@ public sealed class SqliteGameRepositoryTests
(await repo.ApplyDetectionAsync(row.Id + 99, new DetectionWrite { CapabilityIds = [], RulesVersion = "v", ExeSizeBytes = 0, ExeMtimeMs = 0 }, Ct)).Should().BeFalse();
}
/// <summary>
/// Schema 0011 (beta.8): the executable's own facts ride the detection write, whole — what it runs as, its two
/// versions, the capability files it ships — and read back as written; a later write that found no version clears it.
/// </summary>
[Fact]
public async Task TheExecutablesFactsRoundTripAndAreWrittenWhole()
{
await using LedgerFixture f = await LedgerFixture.OpenAsync();
var repo = new SqliteGameRepository(f.Db);
GameRow row = await repo.EnsureAsync(_exe, "Title", Ct);
row.ExeMachine.Should().BeNull("never read: the sweep reads that as stale");
row.Libraries.Should().BeEmpty();
await repo.ApplyDetectionAsync(row.Id, new DetectionWrite
{
CapabilityIds = ["dlss", "xess"],
RulesVersion = "2026.09.5",
ExeSizeBytes = 1,
ExeMtimeMs = 2,
ExeArchitecture = ExecutableArchitecture.X64,
ExeFileVersion = "4.27.2.0",
ExeProductVersion = "++UE4+Release-4.27",
Libraries =
[
new LibraryFile("dlss", "Engine/Plugins/DLSS/nvngx_dlss.dll", "3.7.10.0", "3.7.10"),
new LibraryFile("xess", "libxess.dll", null, null),
],
}, Ct);
GameRow read = (await repo.FindByIdAsync(row.Id, Ct))!;
read.ExeMachine.Should().Be("x64");
(read.ExeFileVersion, read.ExeProductVersion).Should().Be(("4.27.2.0", "++UE4+Release-4.27"));
read.Libraries.Should().Equal(
new LibraryFile("dlss", "Engine/Plugins/DLSS/nvngx_dlss.dll", "3.7.10.0", "3.7.10"),
new LibraryFile("xess", "libxess.dll", null, null));
string? stored = await f.Db.ReadAsync((c, ct) => c.ExecuteScalarAsync<string?>(new CommandDefinition(
"SELECT library_versions FROM games WHERE id = @id", new { id = row.Id }, cancellationToken: ct)), Ct);
stored.Should().Contain("\"capability\":\"dlss\"").And.Contain("\"fileVersion\":\"3.7.10.0\"", "the column's names, not the record's");
await repo.ApplyDetectionAsync(row.Id, new DetectionWrite { CapabilityIds = [], RulesVersion = "2026.09.6", ExeSizeBytes = 1, ExeMtimeMs = 2 }, Ct);
GameRow again = (await repo.FindByIdAsync(row.Id, Ct))!;
again.ExeMachine.Should().Be(ExecutableArchitecture.Unknown, "a write says what it found, and it found nothing");
again.ExeFileVersion.Should().BeNull();
again.Libraries.Should().BeEmpty();
}
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData("not json")]
[InlineData("{\"capability\":\"dlss\"}")]
[InlineData("[{\"capability\":\"dlss\"}]")]
public void ALibraryColumnThisBuildCannotReadIsEmptyNeverAnException(string? json) =>
LibraryVersionsJson.Parse(json).Should().BeEmpty();
/// <summary>The import's write (P4 PR-4) under the same provenance rule: a store fills empty fields and badges them; a user's platform stays; a null store value erases nothing; the hook columns are untouched.</summary>
[Fact]
public async Task AStoreWriteFillsAndBadgesButNeverOverwritesTheUser()
Whitespace-only changes.
@@ -0,0 +1 @@
{ "engine": null, "platform": null, "capabilities": ["fsr", "xess"], "$why": "FSR 3's upscaler DLL and XeSS's DX11 build (rules 2026.09.5): until then no rule named either, so a game shipping only these showed no Supports chip." }
Whitespace-only changes.
Whitespace-only changes.
+3 -2
View File
@@ -561,9 +561,10 @@ foreach ($section in 'engines', 'platforms', 'capabilities') {
if (Test-Member $rules $section) { $liveIds += @($rules.$section | ForEach-Object { $_.id }) }
}
# Directories that are deliberately not rule ids: the ordering case and the two
# canaries are named for what they PROVE, not for a rule.
# canaries are named for what they PROVE, not for a rule — and since rules
# 2026.09.5 the globs FSR 3 and XeSS DX11 added to two existing ids.
$nonRuleFixtures = @('unity_markers_with_ue_structure', 'no_engine', 'every_engine_marker',
'dlss_stack', 'fsr_globs')
'dlss_stack', 'fsr_globs', 'fsr3_xess_dx11')
foreach ($name in $fixtureNames) {
if ($name -notin $liveIds -and $name -notin $nonRuleFixtures) {
$errors.Add("fixture '$name' matches no live rule id and is not a named special case — stale fixtures report green forever")