Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8f4c5f90f1 |
No files matched your search
@@ -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
@@ -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
@@ -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
@@ -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.)* |
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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}"
|
||||
|
||||
@@ -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
|
||||
|
||||
Generated
+78
@@ -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);
|
||||
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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.
@@ -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")
|
||||
|
||||
Reference in new issue
Block a user