Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 61f229e1df fix: a frame-generation window is read only with eight application frames and a ratio up to x8 - the x1336.0 Silent Hill 2 state; the owner's runs of 2026-10-19 recorded (beta.26 PR-1)
The owner's Silent Hill 2 session (0.1.0-beta.25, NVIDIA App Dynamic multi frame generation) listed a
x1336.0 state (0.20 -> 267.20 FPS, 10 s) and the DLSS line cited it. Its two windows held one
application-frame token each against 1,336 presents: a window needed eight presents and one token.

- FgSlices.Slice.IsReadable: eight presents AND eight application frames; IsActive also caps the ratio
  at FgWindow.GenerationCeiling (x8 - no shipping technology generates more than x6). The mix and the
  steady state read the same windows.
- FgWindow refuses a ratio that held above x8 as BeyondGeneration ("beyond_generation"), after
  uniformity; its words in the capture host and the App (en/vi/ja).
- FgMixRecord.Parse reads a stored mix by today's rule: a stored state above x8 or under eight
  application frames a window joins the not-classified time. That session now reads x2.0, x3.0, x6.1,
  none and 30 s not classified; its DLSS line cites x6.1.
- Docs: 03_METRICS (the mix's amendment), 06_DATA_MODEL, LIMITATIONS, 05_DETECTION (the override's
  library names), spike-notes section 22 (the owner's runs: the Dynamic line confirmed, Lies of P read
  no FSR mode with the query hooked), HANDOFF items 20 and 21 annotated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 22:08:06 +07:00
28 changed files with 399 additions and 17 deletions

No files matched your search

+16
View File
@@ -35,6 +35,22 @@ numeric core and does not move; the heading is the full version — corrected 20
## [Unreleased]
### Fixed
- **A frame-generation "state" of ×1336.0.** The owner's Silent Hill 2 session (0.1.0-beta.25, the NVIDIA App's
*Dynamic* multi frame generation) listed a ×1336.0 state — 0.20 → 267.20 FPS for ten seconds — under *Frame
generation in this session*, and the DLSS line cited it: *DLSS 4.5 (a ×1336.0 frame-generation state)*. Those ten
seconds were presented with one application frame counted per five-second window (a loading screen), and a window
needed eight presents but only one counted frame to be read. A window now needs eight application frames and a
ratio no higher than ×8 — more than any frame generation produces (DLSS 4.5's ×6 is the most); every other window is
*Not classified*, and the steady state reads the same windows. A session-wide or live ratio that held above ×8 is
refused and says why (*the ratio is beyond what any frame generation produces*), in en/vi/ja. Sessions already
recorded are read by the same rule, so that session now lists ×2.0, ×3.0, ×6.1, no frame generation and 30 seconds
not classified, and its DLSS line cites ×6.1. The owner's runs of beta.24 and beta.25 are recorded in
`docs/spike-notes/22-owner-runs-2026-10-19.md`: the *Dynamic* settings line matched the NVIDIA App's own words, the
override's two library names are written down, and Lies of P read no FSR mode with the query hooked — the title
rounds its own render size and asked nothing the hook kept.
## Releases
Newest first. Each file holds that release's section exactly as it stood here.
+6 -4
View File
@@ -67,10 +67,12 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
([Metrics](docs/03_METRICS.md))
- **The mix of frame-generation states** in a session's summary (since 0.1.0-beta.24) is read over five-second
windows: frame generation that changes faster than that — the NVIDIA App's *Dynamic* mode can — reads partly as
*Not classified*, and a state shorter than 10 seconds is not listed. The multiplier chosen in a game's own menu is
not read; the measured factor is its evidence. How the NVIDIA App's *Dynamic* ceiling and *Max refresh rate* target
are stored by the driver is read from NVIDIA's own setting names and not yet checked against the App on a real
game. Sessions recorded before 0.1.0-beta.24 have no mix. ([Metrics](docs/03_METRICS.md))
*Not classified*, and a state shorter than 10 seconds is not listed. A stretch the game presents with almost no frame
count of its own — a loading screen or a menu drawn outside frame generation — reads as *Not classified* too. The
multiplier chosen in a game's own menu is not read; the measured factor is its evidence. How the NVIDIA App's
*Dynamic* ceiling and *Max refresh rate* target are stored by the driver is read from NVIDIA's own setting names,
and has been checked against the App on one game. Sessions recorded before 0.1.0-beta.24 have no mix.
([Metrics](docs/03_METRICS.md))
- **Time below 30, 60 FPS and below the refresh rate** (since 0.1.0-beta.14) leaves out the small wobble of a game
held at its limit: a frame counts as below 60 when it took 10 % longer than 1/60 s, or when the frames around it ran
2 % slower. So a game running steadily just under the line — 59 FPS against 60 — reads partly as at it. Time below
+14 -1
View File
@@ -488,10 +488,23 @@ F_app = Σ fgEvaluations (APPLICATION frames, counted at the
> session has one. Rows: the states by rising factor, then *no frame generation*, then *not classified*. **Never an
> average across states** (CLAUDE.md rule 6), and ×5 and ×6 are 20 % apart and never pool.
>
> **Amended 2026-10-19 (beta.26): a window needs application frames, and a ratio frame generation can produce.**
> "≥ 8 samples and tokens" was built as eight presents and ONE token, and the owner's Silent Hill 2 session listed a
> ×1336.0 state — ten seconds the title presented through with one token per window (`spike-notes` §22); the DLSS line
> cited it. A window is now read only with ≥ 8 presents AND ≥ 8 application frames (`FgSlices.Slice.IsReadable`, both
> active and *no frame generation*), and is active only up to **×8** (`FgWindow.GenerationCeiling`: no shipping
> technology generates more than five frames per application frame, DLSS 4.5's ×6); every other window is *not
> classified*. The steady state reads the same windows, so it can no longer pick such a stretch either. A session-wide
> or live ratio that held above ×8 is refused as **`beyond_generation`** (after uniformity: a session that changed
> state stays `non_uniform` and keeps its steady state and its mix). **A stored mix is read by today's rule**
> (`FgMixRecord.Parse`): a row above ×8, or whose windows averaged fewer than eight application frames, joins the
> not-classified time — so the session stored with the ×1336.0 row reads ×2.0, ×3.0, ×6.1, no frame generation and
> 30 s not classified, and its shares still add up.
>
> **When there is a mix.** Only where the session's frame generation was named (`Named` / `ActiveUnidentified`) and the
> session-wide count either stood or was refused as `NonUniform` / `AmbiguousBand` — a change of state is exactly what a
> mix describes. Every other refusal (not counted, unattributed, interleaved streams, either saturation, no
> evaluations, too short, no batches) gets none — slicing does not make a refused record set trustworthy, the steady
> evaluations, too short, no batches, and since beta.26 a ratio beyond any frame generation) gets none — slicing does not make a refused record set trustworthy, the steady
> state's rule — and so does a session in which no state formed.
>
> **Stored, never replayed.** `sessions.fg_mix` (schema 0020) holds the rows as JSON (`FgMixRecord`), written by the
+3 -1
View File
@@ -445,7 +445,9 @@ App's DLSS override loads the driver's `nvngx_dlss.dll` from the driver store un
2026-10-19: unmeasured, and the one measurement says otherwise — the owner's Silent Hill 2 session ran ×6 frame
generation through the NVIDIA App's override and no module with a census name was loaded. Since beta.24 every module
under `%ProgramData%\NVIDIA\NGX` is recorded whatever its name, with its folder class — §DLSS generation below —, and
owner-only item 20(c) records what the override loads.)* The session summary prints the loaded list and names such a
owner-only item 20(c) records what the override loads.)* *(Measured 2026-10-19, `spike-notes` §22: under the
override, Silent Hill 2 loaded `160_E658700.bin` 310.9.16.0 and `1B0_E658703.dll` 2.14.16.0 from the NGX folder —
names no census lists; which feature each serves is not established.)* The session summary prints the loaded list and names such a
difference ("the game ships 3.7.10.0: another copy was loaded"); since beta.24 the DLSS line says where each DLSS
library was loaded from (the game, the graphics driver, Windows) — by folder, never who put it there.
+5 -2
View File
@@ -252,7 +252,8 @@ CREATE TABLE sessions (
fg_source TEXT, -- api|cadence|manual (`etw` removed 2026-08-28: no producer, no tier)
fg_factor REAL,
-- schema 0003 (2026-09-14): why fg_factor is NULL while fg_mode names a technology — FgRefusalKind as
-- Vocabulary.FgRefusal spells it (not_counted, no_evaluations, non_uniform, dxgi_saturated, …). NULL when a
-- Vocabulary.FgRefusal spells it (not_counted, no_evaluations, non_uniform, dxgi_saturated, …; beyond_generation
-- since beta.26: a ratio above FgWindow.GenerationCeiling that held throughout). NULL when a
-- factor stands or the writer predates the column. A REASON for the UI, never an input to fg_mode or a number.
fg_refusal TEXT,
-- FlWriterState.runtimeCensus, raw (FlRuntimeCensus bits). Which vendor runtime modules
@@ -688,7 +689,9 @@ Sequential embedded SQL (`Migrations/0001_init.sql`, `0002_*.sql`, …), applied
> frame generation was named and whose count stood or was refused only as `non_uniform` / `ambiguous_band`; NULL
> otherwise. A session before it has none and is **never rebuilt** from its `frame_blobs` (one Generated bit per frame,
> the DXGI-counted presents lost). The `.partial` needs no change: a recovered session is aggregated from its records
> like any other. `LatestVersion` is 20; `LedgerDatabaseTests.ScriptTwentyAddsTheFgMixColumnAndAnEarlierSessionHasNone`,
> like any other. **Read by today's rule since beta.26:** `FgMixRecord.Parse` folds a stored state no window of the build
> would form (above ×8, or under eight application frames a window) into the not-classified time — beta.24 and beta.25
> stored one (`spike-notes` §22). `LatestVersion` is 20; `LedgerDatabaseTests.ScriptTwentyAddsTheFgMixColumnAndAnEarlierSessionHasNone`,
> `SqliteSessionRepositoryTests.ASessionRoundTripsColumnForColumn`. **A beta.23 cannot open a ledger beta.24 migrated.**
> **`0021_runtime_module_sources.sql` (beta.24, 2026-10-19, owner decision D64) — where each loaded module lived.** One
+7 -2
View File
@@ -216,7 +216,10 @@ case): 7.6–8.2 ns per UPSCALE dispatch, 1.6 ns per query beside the trampoline
loads (*Loaded:* line); `nvngx_dlssnr.dll` is then corrected in `CensusNames` and `05_DETECTION`.
(e) **SonarCloud (D67):** bulk-mark per `13_CI_CD` §SonarCloud; optionally its *Ignore issues on multiple criteria*
rows; close PR #315. (f) The Legal Gate shows **Disclaimer 2.11** and **Privacy Policy 2.12** once. (g) The `ja`
strings marked `review`.
strings marked `review`. *(2026-10-19, the owner's first runs — `spike-notes` §22: (a) the Dynamic context line
reads the App's own words, and the mix found ×2.0 / ×3.0 / ×6.1 — plus a ×1336.0 row that was a defect, fixed in
beta.26; (c) the override loads `160_E658700.bin` 310.9.16.0 and `1B0_E658703.dll` 2.14.16.0 from the NGX folder.
The rest is not run yet.)*
21. **beta.25 on real hardware — FSR's quality mode (D65), decision table written before the run.** Lies of P (FSR
through AMD's FidelityFX libraries) launched by FrameLedger, not attached, with the game's own *FSR* at *Quality*,
then a second session at *Performance* → the summary's header reads *FSR 3 Quality*, then *FSR 3 Performance* (or
@@ -226,7 +229,9 @@ case): 7.6–8.2 ns per UPSCALE dispatch, 1.6 ns per query beside the trampoline
and silent for that title. **A wrong mode** (the Quality session reading Balanced) → the answers this title receives
are not the vendor's documented ratios: record the stored `upscaler_quality` and the render size in `spike-notes`,
and the match is withdrawn until it is explained. **With the game's dynamic resolution on** (if it offers one) → no
mode.
mode. *(2026-10-19, `spike-notes` §22: the Quality session read **no mode** with the query hooked — the first
branch; 1707×961 is the engine's own rounding of 66.67 %, not the size answer, so the title asked before the hook
was in or never asked. D65 stays built and silent for Lies of P. The Performance session is not run.)*
**Answered 2026-08-05, do not re-ask:** remove `gameguard` and keep `guard` (approved
over a red `Rules` gate, with the reasoning recorded in the merge commit); vendor NVAPI
headers **and** `amd64/nvapi64.lib`; Windows 11 is the **measurement scope** only —
+1
View File
@@ -45,3 +45,4 @@ Each section below lives in its own file under `docs/spike-notes/`, moved verbat
| §19 | Anti-cheat beside the executable — Wuthering Waves (2026-10-13, beta.21, owner decision D58) | [`spike-notes/19-wuthering-waves.md`](spike-notes/19-wuthering-waves.md) |
| §20 | The launcher in front of four itch installs is malware (2026-10-13, beta.21, owner decision D57) | [`spike-notes/20-itch-malware.md`](spike-notes/20-itch-malware.md) |
| §21 | Opening pages and switching tabs in the App (2026-10-14, beta.23) | [`spike-notes/21-app-pages-and-tabs.md`](spike-notes/21-app-pages-and-tabs.md) |
| §22 | The owner's runs of beta.24 and beta.25 on real hardware (2026-10-19) | [`spike-notes/22-owner-runs-2026-10-19.md`](spike-notes/22-owner-runs-2026-10-19.md) |
@@ -0,0 +1,54 @@
## 22 · The owner's runs of beta.24 and beta.25 on real hardware *(2026-10-19)*
The owner ran the installed 0.1.0-beta.25 the evening it shipped and sent five screenshots: Silent Hill 2's session
summary and game page (21:33 local time) and Lies of P's summary (21:47). The numbers below are read from those and from a
read-only SQLite backup copy of the ledger (sessions 60 and 61) — never the data folder. Dev PC: i7-14700KF, RTX 5080,
NVIDIA driver 32.0.16.1742, 2560×1440 at 240 Hz.
### Silent Hill 2 — owner-only items 20(a) and 20(c)
Unreal Engine 5.1, Streamline 2.4.0. The NVIDIA App's profile for the game: DLSS override (preset L, Ultra
Performance); Frame Generation override (×6, preset B, *Dynamic*, target max refresh rate); Streamline DLSS override.
- **20(a), how frame generation was set:** *Set in the NVIDIA App: Dynamic, up to ×6, target: max refresh rate* — the
App's own words. `NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX` 5 read as "up to ×6" and the automatic target as "max
refresh rate" stand on one title.
- **The mix** under Dynamic multi frame generation: ×2.0 17.70 % (111.83 → 225.83 FPS, 35 s), ×3.0 21.60 % (95.75 →
287.18, 42.7 s, the steady state), ×6.1 7.59 % (23.20 → 140.53, 15 s), no frame generation 37.94 % (80.08 FPS, 75 s),
not classified 10.12 % (20 s) — and **×1336.0, 5.06 %, 0.20 → 267.20 FPS, 10 s: a defect.** Its two windows held one
application-frame token each against 1,336 presents each: a stretch the title presented through outside DLSS-G's frame
count (the frame-time chart has a 14-second frame the same minute — a loading screen). A window needed eight presents
and one token, so the ratio of one token was the presents themselves, and the steady state's own rule would have
picked it had it lasted longest. The DLSS line then cited it: *DLSS 4.5 (a ×1336.0 frame-generation state)*. Fixed in
beta.26 (`03_METRICS` §The mix): a window is read only with eight application frames and a ratio up to ×8
(`FgWindow.GenerationCeiling`), a session or live ratio that held above it is refused as `beyond_generation`, and a
stored mix is read by the same rule — this session's ten seconds join *not classified* and the DLSS line cites ×6.1.
Of the 60 sessions in the ledger copy, this row was the only stored value above ×8.
- **20(c), what the override loads:** the summary's *Loaded* line lists `160_E658700.bin` 310.9.16.0 and
`1B0_E658703.dll` 2.14.16.0 from the NVIDIA driver's NGX folder — no census name, which is why the DLSS line names no
library. Which feature each serves is not established: 310.9.16 is a DLSS build number of the 4.5 generation, and
2.14.16 reads as a Streamline version beside the profile's *Streamline DLSS override*.
- The driver line: *DLSS DLL chosen by the driver · preset L · Ultra Performance · Frame Generation override (×6)* —
Ultra Performance from the report's 3, NGX's numbering (beta.24's correction, now on a second session). The header
reads *Upscaler not identified · N/A*: the driver's super-resolution word has no `CREATED | EVALUATE`, as on
2026-10-13, so no quality mode is claimed (D63's rule).
### Lies of P — owner-only item 21
Unreal Engine 4; `amd_fidelityfx_dx12.dll` 1.0.1.37507 (the SDK 1.1.x monolith) and `nvngx_dlss.dll` 3.7.0 loaded; FSR
chosen in the game's menu, its frame generation on.
- **The header reads *FSR 3 · 1707×961 → 2560×1440* — no mode.** The decision table's first branch. The query WAS
hooked: `hooks_installed_mask` 0x83F carries `FL_HOOK_UPSCALER_QUALITY` (bit 11). 1707×961 is 2560×1440 at 66.67 %
rounded up, not the vendor's answer to the size query (1706×960, truncated), so the title did not render at a size it
asked for; at a ratio it asked for (1.5) it would have matched within the pixel the ratio path allows. So it either
asked before the hook was in — a plugin's first query can follow the module's load on the loading thread before the
watchdog installs — or never asked (its own table). Nothing recorded tells the two apart, and either way the honest
answer is no mode: D65 stays built and silent for this title, as the table said. The Performance session was not run.
- Frame generation: ×2.0 for 87.93 % (54.64 → 109.62 FPS), not classified 12.07 % — FSR's own frame generation, named
from its dispatches.
- The DLSS line: *DLSS 3 (library 3.7.0) · Super Resolution 3.7.0, from the game* — the engine's DLSS plugin loads the
library while FSR upscales; D64 names DLSS 3 from its major version, and the line says the library is the evidence.
Not run yet: 20(a)'s ×2/×3/×4 chosen in a game's menu and the App's *Fixed ×6*, 20(b) (Expedition 33), 20(d) (the DLSS 5
title), 20(f)–(g), and item 21's Performance session.
@@ -193,6 +193,7 @@ public static class FpsPresentation
"multiple_streams" => string.Format(culture, Strings.Fg_RefusalDetail_MultipleStreams_Format, detail.Count),
"too_short" => string.Format(culture, Strings.Fg_RefusalDetail_TooShort_Format, detail.Count, FgWindow.MinSamplesToCheck),
"ambiguous_band" => string.Format(culture, Strings.Fg_RefusalDetail_AmbiguousBand_Format, Ratio(detail.Overall), Ratio(FgWindow.NoneCeiling), Ratio(FgWindow.ActiveThreshold)),
"beyond_generation" => string.Format(culture, Strings.Fg_RefusalDetail_BeyondGeneration_Format, Ratio(detail.Overall), Ratio(FgWindow.GenerationCeiling)),
"unattributed" or "count_saturated" or "dxgi_saturated" => string.Format(culture, Strings.Fg_RefusalDetail_Records_Format, detail.Count),
_ => null,
};
@@ -213,6 +214,7 @@ public static class FpsPresentation
"non_uniform" => Strings.Fg_Refusal_NonUniform,
"ambiguous_band" => Strings.Fg_Refusal_AmbiguousBand,
"no_batches" => Strings.Fg_Refusal_NoBatches,
"beyond_generation" => Strings.Fg_Refusal_BeyondGeneration,
_ => Strings.Fg_Refusal_Unknown,
};
+6
View File
@@ -374,6 +374,7 @@ public static class Strings
nameof(Fg_Factor_NotCounted),
nameof(Fg_None),
nameof(Fg_Refusal_AmbiguousBand),
nameof(Fg_Refusal_BeyondGeneration),
nameof(Fg_Refusal_CountSaturated),
nameof(Fg_Refusal_DxgiSaturated),
nameof(Fg_Refusal_MultipleStreams),
@@ -385,6 +386,7 @@ public static class Strings
nameof(Fg_Refusal_Unattributed),
nameof(Fg_Refusal_Unknown),
nameof(Fg_RefusalDetail_AmbiguousBand_Format),
nameof(Fg_RefusalDetail_BeyondGeneration_Format),
nameof(Fg_RefusalDetail_MultipleStreams_Format),
nameof(Fg_RefusalDetail_NonUniform_Format),
nameof(Fg_RefusalDetail_NoTokens),
@@ -1857,6 +1859,8 @@ public static class Strings
public static string Fg_Refusal_AmbiguousBand => ResourceManager.GetString(nameof(Fg_Refusal_AmbiguousBand), Culture) ?? nameof(Fg_Refusal_AmbiguousBand);
public static string Fg_Refusal_BeyondGeneration => ResourceManager.GetString(nameof(Fg_Refusal_BeyondGeneration), Culture) ?? nameof(Fg_Refusal_BeyondGeneration);
public static string Fg_Refusal_CountSaturated => ResourceManager.GetString(nameof(Fg_Refusal_CountSaturated), Culture) ?? nameof(Fg_Refusal_CountSaturated);
public static string Fg_Refusal_DxgiSaturated => ResourceManager.GetString(nameof(Fg_Refusal_DxgiSaturated), Culture) ?? nameof(Fg_Refusal_DxgiSaturated);
@@ -1879,6 +1883,8 @@ public static class Strings
public static string Fg_RefusalDetail_AmbiguousBand_Format => ResourceManager.GetString(nameof(Fg_RefusalDetail_AmbiguousBand_Format), Culture) ?? nameof(Fg_RefusalDetail_AmbiguousBand_Format);
public static string Fg_RefusalDetail_BeyondGeneration_Format => ResourceManager.GetString(nameof(Fg_RefusalDetail_BeyondGeneration_Format), Culture) ?? nameof(Fg_RefusalDetail_BeyondGeneration_Format);
public static string Fg_RefusalDetail_MultipleStreams_Format => ResourceManager.GetString(nameof(Fg_RefusalDetail_MultipleStreams_Format), Culture) ?? nameof(Fg_RefusalDetail_MultipleStreams_Format);
public static string Fg_RefusalDetail_NonUniform_Format => ResourceManager.GetString(nameof(Fg_RefusalDetail_NonUniform_Format), Culture) ?? nameof(Fg_RefusalDetail_NonUniform_Format);
+8
View File
@@ -4577,4 +4577,12 @@
<value>ネイティブ AA</value>
<comment>review</comment>
</data>
<data name="Fg_Refusal_BeyondGeneration" xml:space="preserve">
<value>比率がどのフレーム生成の上限も超えています</value>
<comment>review</comment>
</data>
<data name="Fg_RefusalDetail_BeyondGeneration_Format" xml:space="preserve">
<value>presents ÷ tokens = {0}。フレーム生成の上限 {1} を超えています。</value>
<comment>review</comment>
</data>
</root>
+6
View File
@@ -3443,4 +3443,10 @@ The documents below are the full terms; this summary does not replace them.</val
<data name="Fsr_Mode_NativeAa" xml:space="preserve">
<value>Native AA</value>
</data>
<data name="Fg_Refusal_BeyondGeneration" xml:space="preserve">
<value>the ratio is beyond what any frame generation produces</value>
</data>
<data name="Fg_RefusalDetail_BeyondGeneration_Format" xml:space="preserve">
<value>presents ÷ tokens = {0}, above {1}, the most any frame generation produces.</value>
</data>
</root>
+6
View File
@@ -3438,4 +3438,10 @@ Các văn bản bên dưới là điều khoản đầy đủ; bản tóm tắt
<data name="Fsr_Mode_NativeAa" xml:space="preserve">
<value>Native AA</value>
</data>
<data name="Fg_Refusal_BeyondGeneration" xml:space="preserve">
<value>tỷ lệ vượt quá mức mọi công nghệ tạo khung có thể sinh ra</value>
</data>
<data name="Fg_RefusalDetail_BeyondGeneration_Format" xml:space="preserve">
<value>presents ÷ tokens = {0}, vượt {1} — mức cao nhất mọi công nghệ tạo khung sinh ra.</value>
</data>
</root>
@@ -19,6 +19,14 @@ public sealed record FgMixRecord(IReadOnlyList<FgMixRecordRow> Rows)
: JsonSerializer.Serialize(new FgMixRecord([.. mix.Rows.Select(FgMixRecordRow.From)]), RecordingJsonContext.Default.FgMixRecord);
/// <summary>The column's text back, or null for a null/empty/unparsable column (a writer that predates it, or a hand edit).</summary>
/// <remarks>
/// <b>Read by today's rule</b> (beta.26): a stored state no window of this build would form — a factor above
/// <see cref="FgWindow.GenerationCeiling"/>, or windows that averaged fewer than <see cref="FgWindow.MinPerBucket"/>
/// application frames — is time no state claims, and joins the not-classified row. beta.24 and beta.25 stored such a
/// row for a loading screen presented through with one token per window (Silent Hill 2, 2026-10-19: ×1336.0,
/// 0.20 → 267.20 FPS), and the summary listed it and the DLSS line cited it. Every other row is as stored, and the
/// shares still add up to the whole.
/// </remarks>
public static FgMixRecord? Parse(string? json)
{
if (string.IsNullOrWhiteSpace(json))
@@ -28,11 +36,45 @@ public sealed record FgMixRecord(IReadOnlyList<FgMixRecordRow> Rows)
try
{
return JsonSerializer.Deserialize(json, RecordingJsonContext.Default.FgMixRecord);
FgMixRecord? record = JsonSerializer.Deserialize(json, RecordingJsonContext.Default.FgMixRecord);
return record is null ? null : Readable(record);
}
catch (JsonException)
{
return null;
}
}
private static FgMixRecord Readable(FgMixRecord record)
{
if (record.Rows is null || !record.Rows.Any(IsUnreadableState))
{
return record;
}
var kept = new List<FgMixRecordRow>();
double seconds = 0;
double share = 0;
int windows = 0;
foreach (FgMixRecordRow row in record.Rows)
{
if (IsUnreadableState(row) || FgMixRecordRow.KindOf(row.Kind) == FgMixKind.Unclassified)
{
seconds += row.Seconds;
share += row.Share;
windows += row.Windows;
continue;
}
kept.Add(row);
}
kept.Add(new FgMixRecordRow(FgMixRecordRow.Token(FgMixKind.Unclassified), null, null, null, seconds, share, windows));
return new FgMixRecord(kept);
}
private static bool IsUnreadableState(FgMixRecordRow row) =>
FgMixRecordRow.KindOf(row.Kind) == FgMixKind.Generated
&& (row.Factor is not double factor || factor > FgWindow.GenerationCeiling
|| row.NativeFps is not double native || native * FgSteadyState.WindowSeconds < FgWindow.MinPerBucket);
}
@@ -65,6 +65,7 @@ public static class Vocabulary
FgRefusalKind.NonUniform => "non_uniform",
FgRefusalKind.AmbiguousBand => "ambiguous_band",
FgRefusalKind.NoBatches => "no_batches",
FgRefusalKind.BeyondGeneration => "beyond_generation",
_ => null,
};
@@ -63,6 +63,10 @@ internal static class FgRefusalText
+ $"cadence threshold ({FgWindow.ActiveThreshold.ToString("0.0", CultureInfo.InvariantCulture)}) — not "
+ "a configuration this consumer can name",
FgRefusalKind.NoBatches => "no present drained a Streamline batch, so there is no ratio to read",
FgRefusalKind.BeyondGeneration =>
$"presents/tokens = {refusal.Overall.ToString("0.00", CultureInfo.InvariantCulture)} is above "
+ $"{FgWindow.GenerationCeiling.ToString("0.0", CultureInfo.InvariantCulture)}, more presents per application "
+ "frame than any frame generation produces — the count does not describe these presents",
_ => refusal.Kind.ToString(),
};
}
+6 -1
View File
@@ -24,6 +24,11 @@ namespace FrameLedger.Domain.Metrics;
/// denominator — and every window lands in exactly one row. States come first, by rising factor, then
/// <see cref="FgMixKind.None"/>, then <see cref="FgMixKind.Unclassified"/>.
/// </para>
/// <para>
/// <b>A window the count does not describe is not classified</b> (beta.26): fewer than <see cref="FgWindow.MinPerBucket"/>
/// application frames, or a ratio above <see cref="FgWindow.GenerationCeiling"/> (<see cref="FgSlices.Slice.IsReadable"/>,
/// <see cref="FgSlices.Slice.IsActive"/>).
/// </para>
/// </remarks>
public sealed record FgMix(IReadOnlyList<FgMixRow> Rows)
{
@@ -61,7 +66,7 @@ public sealed record FgMix(IReadOnlyList<FgMixRow> Rows)
foreach (FgSlices.Slice s in slices)
{
List<FgSlices.Slice> into = s.IsActive ? active
: noneAllowed && s.Samples >= FgWindow.MinPerBucket && s.Tokens > 0 && s.Factor <= FgWindow.NoneCeiling ? none
: noneAllowed && s.IsReadable && s.Factor <= FgWindow.NoneCeiling ? none
: unclassified;
into.Add(s);
}
@@ -38,4 +38,10 @@ public enum FgRefusalKind
/// <summary>No present drained a Streamline batch, so there is no presents-per-batch ratio to read.</summary>
NoBatches,
/// <summary>
/// The ratio is above <see cref="FgWindow.GenerationCeiling"/> — more presents per application frame than any frame
/// generation produces: the count does not describe these presents (beta.26).
/// </summary>
BeyondGeneration,
}
+12 -2
View File
@@ -19,8 +19,18 @@ internal static class FgSlices
/// <summary>Read only on windows that have tokens.</summary>
public double Factor => Displayed / (double)Tokens;
/// <summary>Generating: enough samples to judge, tokens counted, and at least <see cref="FgWindow.ActiveThreshold"/>.</summary>
public bool IsActive => Samples >= FgWindow.MinPerBucket && Tokens > 0 && Displayed >= Tokens * FgWindow.ActiveThreshold;
/// <summary>
/// A window a ratio can be read from: <see cref="FgWindow.MinPerBucket"/> presents AND as many application frames
/// (beta.26). Presents alone let a window with ONE token through, and its ratio was the presents themselves: Silent
/// Hill 2's loading screen read ×1336.0, a state the mix listed and the DLSS line cited.
/// </summary>
public bool IsReadable => Samples >= FgWindow.MinPerBucket && Tokens >= FgWindow.MinPerBucket;
/// <summary>
/// Generating: readable, at least <see cref="FgWindow.ActiveThreshold"/>, and no more than
/// <see cref="FgWindow.GenerationCeiling"/> — above it the ratio is no frame generation's.
/// </summary>
public bool IsActive => IsReadable && Displayed >= Tokens * FgWindow.ActiveThreshold && Factor <= FgWindow.GenerationCeiling;
}
/// <summary>
@@ -19,8 +19,9 @@ namespace FrameLedger.Domain.Metrics;
/// </para>
/// <para>
/// <b>What it is.</b> The claimed span cut into <see cref="WindowSeconds"/>-second windows — the live card's own window —
/// each classified by its own <c>presents ÷ tokens</c>; the ACTIVE windows (≥ <see cref="FgWindow.ActiveThreshold"/>)
/// that agree with one another within <see cref="StateTolerance"/> form a state, and the state holding the most time
/// each classified by its own <c>presents ÷ tokens</c>; the ACTIVE windows (≥ <see cref="FgWindow.ActiveThreshold"/>,
/// ≤ <see cref="FgWindow.GenerationCeiling"/>, with at least <see cref="FgWindow.MinPerBucket"/> application frames since
/// beta.26) that agree with one another within <see cref="StateTolerance"/> form a state, and the state holding the most time
/// is this record, with the share of the presenting time it covers. ×3 and ×4 are 25 % apart and never pool; a
/// factor that wanders (a dynamic multiplier) forms no state long enough and the refusal stands alone.
/// </para>
+19 -1
View File
@@ -174,6 +174,16 @@ public sealed record FgWindow
/// </summary>
public const double NoneCeiling = 1.05;
/// <summary>
/// Above this, a ratio is not frame generation. No shipping technology generates more than five frames per application
/// frame (DLSS 4.5 multi frame generation, ×6; measured ×6.06 with DXGI's count, 2026-10-19), and ×8 leaves room for a
/// window's edges. A ratio above it is a stretch the title presented through with almost no application-frame token —
/// a loading screen or a menu drawn outside the vendor's frame count: Silent Hill 2 (2026-10-19) presented 1,336 times
/// per token for ten seconds under the NVIDIA App's Dynamic multi frame generation, and the mix listed it as a ×1336.0
/// state. Raised only with a title measured above it (beta.26).
/// </summary>
public const double GenerationCeiling = 8.0;
/// <summary><c>none</c>, reached by counting: a published factor at or below <see cref="NoneCeiling"/>.</summary>
public bool IsNone => Factor is double f && f <= NoneCeiling;
@@ -428,7 +438,7 @@ public sealed record FgWindow
return null;
}
/// <summary>The refusals that need the ratio itself: uniformity, then the unnameable band.</summary>
/// <summary>The refusals that need the ratio itself: uniformity, then a ratio no frame generation produces, then the unnameable band.</summary>
private static FgRefusal? RefusalForRatio(FgWindow w)
{
double factor = w.DisplayedPresents / (double)w.Evaluations;
@@ -438,6 +448,14 @@ public sealed record FgWindow
return nonUniform;
}
// AFTER uniformity (beta.26): a session that changed state is refused as non-uniform and keeps its steady state
// and its mix; only a ratio that held throughout and is no configuration is refused here — the live card's five
// seconds of a loading screen, or a session that never left one.
if (factor > GenerationCeiling)
{
return new FgRefusal(FgRefusalKind.BeyondGeneration, FgRefusalSubject.Factor, Overall: factor);
}
// A ratio near 1 is publishable since 2026-09-04 (20_OPEN_QUESTIONS §S31 row P1): 1.0 means every
// present carried an application frame — `none`, reached by COUNTING. What is still refused is the
// band between: a steady 1.05–1.5 is not a configuration any vendor ships, and naming it would be
@@ -130,4 +130,22 @@ public sealed class DlssTextTests
DlssText.Label(Row(upscaler: "dlss", fgMode: "fsrfg", factor: 4.0)).Should().BeNull("only DLSS Frame Generation names a DLSS generation");
return 0;
});
/// <summary>
/// beta.26: the owner's Silent Hill 2 session (2026-10-19) stored a ×1336.0 "state" — a loading screen at one token
/// per window — and the line read "DLSS 4.5 (a ×1336.0 frame-generation state)". Read by today's rule, the evidence is
/// the ×6.1 state the session really held.
/// </summary>
[Fact]
public void AStoredStateNoFrameGenerationProducesIsNotTheEvidence() => InEnglish(() =>
{
const string mix = "{\"Rows\":[" +
"{\"Kind\":\"generated\",\"Factor\":2.999266324284666,\"NativeFps\":95.75,\"DisplayedFps\":287.18,\"Seconds\":42.7,\"Share\":0.5,\"Windows\":9}," +
"{\"Kind\":\"generated\",\"Factor\":6.057471264367816,\"NativeFps\":23.2,\"DisplayedFps\":140.53,\"Seconds\":15,\"Share\":0.3,\"Windows\":3}," +
"{\"Kind\":\"generated\",\"Factor\":1336,\"NativeFps\":0.2,\"DisplayedFps\":267.2,\"Seconds\":10,\"Share\":0.2,\"Windows\":2}]}";
SessionRow silentHill2 = Row("{\"sl.interposer.dll\":\"2,4,0,0\"}", upscaler: "unknown", fgMode: "dlssg", factor: 2.999266324284666, mix: mix);
DlssText.Label(silentHill2).Should().Be("DLSS 4.5 (a ×6.1 frame-generation state)");
return 0;
});
}
@@ -211,6 +211,15 @@ public sealed class FpsPresentationTests
InEnglish(() => FpsPresentation.IdentifiedTooltip("DLSS-G", "non_uniform", "not json")).Should().Be(InEnglish(() => FpsPresentation.IdentifiedTooltip("DLSS-G", "non_uniform")), "an unparsable detail is the old tooltip, never an exception");
}
/// <summary>beta.26: a ratio above what any frame generation produces has its own words, and its numbers in the tooltip.</summary>
[Fact]
public void ARatioBeyondAnyFrameGenerationIsSaidSo()
{
InEnglish(() => FpsPresentation.RefusalText("beyond_generation")).Should().Be("the ratio is beyond what any frame generation produces");
InEnglish(() => FpsPresentation.IdentifiedTooltip("DLSS-G", "beyond_generation", "{\"Kind\":\"beyond_generation\",\"Subject\":\"factor\",\"Count\":0,\"BucketIndex\":0,\"BucketCount\":0,\"BucketValue\":null,\"Overall\":1336}"))
.Should().Contain("presents ÷ tokens = 1336.00, above 8.00, the most any frame generation produces.");
}
/// <summary>
/// 2026-09-17: a steady-state factor (<c>fg_factor_scope = steady</c>) is the generated shape — Native, Displayed and
/// the factor together, as rule 6 asks — and its chip ALWAYS says how much of the session it describes; the tooltip
@@ -0,0 +1,77 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using FluentAssertions;
using FrameLedger.Application.Recording;
using FrameLedger.Domain.Metrics;
namespace FrameLedger.Application.Tests.Recording;
/// <summary><c>sessions.fg_mix</c> back from its text, read by today's rule (beta.26).</summary>
public sealed class FgMixRecordTests
{
/// <summary>The owner's Silent Hill 2 session (2026-10-19, 0.1.0-beta.25, the NVIDIA App's Dynamic multi frame generation), as stored.</summary>
private const string _silentHill2 =
"{\"Rows\":[" +
"{\"Kind\":\"generated\",\"Factor\":2.0194174757281553,\"NativeFps\":111.82857142857142,\"DisplayedFps\":225.82857142857142,\"Seconds\":35,\"Share\":0.17703207945353897,\"Windows\":7}," +
"{\"Kind\":\"generated\",\"Factor\":2.999266324284666,\"NativeFps\":95.75152407846059,\"DisplayedFps\":287.18432166745924,\"Seconds\":42.7042811,\"Share\":0.21600079099147035,\"Windows\":9}," +
"{\"Kind\":\"generated\",\"Factor\":6.057471264367816,\"NativeFps\":23.2,\"DisplayedFps\":140.53333333333333,\"Seconds\":15,\"Share\":0.07587089119437383,\"Windows\":3}," +
"{\"Kind\":\"generated\",\"Factor\":1336,\"NativeFps\":0.2,\"DisplayedFps\":267.2,\"Seconds\":10,\"Share\":0.05058059412958256,\"Windows\":2}," +
"{\"Kind\":\"none\",\"Factor\":null,\"NativeFps\":80.08,\"DisplayedFps\":80.08,\"Seconds\":75,\"Share\":0.3793544559718692,\"Windows\":15}," +
"{\"Kind\":\"unclassified\",\"Factor\":null,\"NativeFps\":null,\"DisplayedFps\":null,\"Seconds\":20,\"Share\":0.10116118825916512,\"Windows\":4}]}";
[Fact]
public void AStoredStateNoWindowOfThisBuildWouldFormIsTimeNoStateClaims()
{
FgMixRecord mix = FgMixRecord.Parse(_silentHill2)!;
mix.Rows.Select(static r => r.Kind).Should().Equal("generated", "generated", "generated", "none", "unclassified");
mix.Rows.Where(static r => string.Equals(r.Kind, "generated", StringComparison.Ordinal)).Select(static r => Math.Round(r.Factor!.Value, 1)).Should().Equal(2.0, 3.0, 6.1);
FgMixRecordRow unclassified = mix.Rows[^1];
unclassified.Seconds.Should().Be(30, "its own twenty seconds and the ten the ×1336.0 row held");
unclassified.Windows.Should().Be(6);
unclassified.Factor.Should().BeNull();
unclassified.NativeFps.Should().BeNull("time no state claims has no rate to show");
mix.Rows.Sum(static r => r.Share).Should().BeApproximately(1.0, 1e-9, "the shares still add up to the whole");
}
[Fact]
public void AStoredMixOfReadableStatesIsReadAsStored()
{
string json = FgMixRecord.ToJson(new FgMix(
[
new FgMixRow(FgMixKind.Generated, 2.0, 60, 120, 60, 0.6, 12),
new FgMixRow(FgMixKind.Generated, 8.0, 30, 240, 20, 0.2, 4),
new FgMixRow(FgMixKind.None, null, 120, 120, 20, 0.2, 4),
]))!;
FgMixRecord mix = FgMixRecord.Parse(json)!;
mix.Rows.Select(static r => r.Kind).Should().Equal("generated", "generated", "none");
mix.Rows[1].Factor.Should().Be(8.0, "at the ceiling a ratio is still frame generation's");
}
[Theory]
[InlineData(8.01, 30.0)]
[InlineData(4.0, 1.5)]
[InlineData(null, 30.0)]
public void AGeneratedRowAboveTheCeilingOrWithTooFewFramesIsFoldedEvenWithNoUnclassifiedRow(double? factor, double nativeFps)
{
string json = "{\"Rows\":[" +
"{\"Kind\":\"generated\",\"Factor\":2.0,\"NativeFps\":60,\"DisplayedFps\":120,\"Seconds\":40,\"Share\":0.8,\"Windows\":8}," +
$"{{\"Kind\":\"generated\",\"Factor\":{(factor is double f ? f.ToString(System.Globalization.CultureInfo.InvariantCulture) : "null")},\"NativeFps\":{nativeFps.ToString(System.Globalization.CultureInfo.InvariantCulture)},\"DisplayedFps\":240,\"Seconds\":10,\"Share\":0.2,\"Windows\":2}}]}}";
FgMixRecord mix = FgMixRecord.Parse(json)!;
mix.Rows.Select(static r => r.Kind).Should().Equal("generated", "unclassified");
mix.Rows[1].Seconds.Should().Be(10);
mix.Rows[1].Share.Should().Be(0.2);
mix.Rows[1].Windows.Should().Be(2);
}
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData("not json")]
public void NoTextOrNoJsonIsNoMix(string? json) => FgMixRecord.Parse(json).Should().BeNull();
}
@@ -60,5 +60,7 @@ public sealed class FgRefusalTextTests
.Should().Contain("the presents-per-batch ratio changed during the session — bucket 1 of 8 measures no evaluations against 2 overall");
FgRefusalText.Describe(new FgRefusal(FgRefusalKind.AmbiguousBand, FgRefusalSubject.Factor, Overall: 1.25))
.Should().Be("presents/tokens = 1.25 sits between the `none` ceiling (1.05) and the cadence threshold (1.5) — not a configuration this consumer can name");
FgRefusalText.Describe(new FgRefusal(FgRefusalKind.BeyondGeneration, FgRefusalSubject.Factor, Overall: 1336))
.Should().Be("presents/tokens = 1336.00 is above 8.0, more presents per application frame than any frame generation produces — the count does not describe these presents");
}
}
@@ -135,6 +135,36 @@ public sealed class FgMixTests
}
}
/// <summary>
/// beta.26: Silent Hill 2 (2026-10-19) presented 1,336 times per token for ten seconds — a loading screen drawn outside
/// the vendor's frame count — and the mix listed it as a ×1336.0 state, which the DLSS line then cited. A window needs
/// application frames, not only presents, and a ratio frame generation can produce.
/// </summary>
[Fact]
public void AWindowWithOneTokenOrARatioNoFrameGenerationProducesIsNotAState()
{
// One token per 1,200 presents: one per five-second window, for ten seconds.
List<FrameSample> loading = FgStream(appFrames: 2, k: 1200);
// Twelve tokens per window at ×100: frames enough to read, a ratio no frame generation produces.
List<FrameSample> beyond = FgStream(appFrames: 15 * _presentsPerSecond / 100, k: 100);
FgMix mix = FgMix.From(Concat(Play(30, 3), loading, beyond, Play(20, 6)), Frequency, noneAllowed: true)!;
mix.Rows.Select(static r => r.Kind).Should().Equal(FgMixKind.Generated, FgMixKind.Generated, FgMixKind.Unclassified);
mix.Rows.Where(static r => r.Kind == FgMixKind.Generated).Select(static r => Math.Round(r.Factor!.Value)).Should().Equal(3, 6);
mix.Rows[2].Seconds.Should().BeApproximately(25, 2, "the ten seconds of one-token windows and the fifteen at ×100");
mix.Rows.Should().OnlyContain(static r => r.Factor == null || r.Factor <= FgWindow.GenerationCeiling);
AddsUpToTheWhole(mix);
}
[Fact]
public void ARatioAtTheCeilingIsStillAState()
{
FgMix mix = FgMix.From(Concat(Play(20, 2), Play(20, 8)), Frequency, noneAllowed: true)!;
mix.Rows.Where(static r => r.Kind == FgMixKind.Generated).Select(static r => Math.Round(r.Factor!.Value)).Should().Equal(2, 8);
}
[Fact]
public void ASessionWithNoStateHasNoMix()
{
@@ -22,6 +22,21 @@ public sealed class FgSteadyStateTests
private static List<FrameSample> Play(int seconds, int k, uint swapchain = 1) =>
FgStream(appFrames: seconds * _presentsPerSecond / k, k: k, swapchain: swapchain);
/// <summary>
/// beta.26: thirty seconds of a loading screen at one token per window held more time than the fifteen seconds of ×2
/// gameplay, and every one of its windows read ×1200 alike — the longest "state" of the session was no state at all.
/// </summary>
[Fact]
public void WindowsWithOneTokenEachAreNotTheSteadyState()
{
List<FrameSample> session = Concat(Play(15, 2), FgStream(appFrames: 6, k: 1200));
FgSteadyState steady = FgSteadyState.From(session, 0, Frequency)!;
steady.Factor.Should().BeApproximately(2.0, 0.02);
steady.Share.Should().BeApproximately(15.0 / 45, 0.03);
}
/// <summary><paramref name="seconds"/> of presents with the count claimed and no token at all: a splash, a video, a loading screen.</summary>
private static List<FrameSample> NoTokens(int seconds) =>
FgStream(appFrames: seconds * _presentsPerSecond, k: 1, evalsPerFrame: 0);
@@ -64,6 +64,26 @@ public sealed class FgWindowTests
w.Refusal.Overall.Should().BeApproximately(1.25, 0.01);
}
/// <summary>
/// beta.26: a ratio that held throughout and is above <see cref="FgWindow.GenerationCeiling"/> is no configuration —
/// the live card's five seconds of a loading screen presented with a token every hundred presents, or a session that
/// never left one. At the ceiling it is still a factor.
/// </summary>
[Fact]
public void ASteadyRatioAboveWhatAnyFrameGenerationProducesIsRefused()
{
FgWindow beyond = FgWindow.From(FgStream(appFrames: 80, k: 100), Frequency);
beyond.Factor.Should().BeNull();
beyond.Refusal!.Kind.Should().Be(FgRefusalKind.BeyondGeneration);
beyond.Refusal.Overall.Should().BeApproximately(100, 0.5);
beyond.Steady.Should().BeNull("the ratio held throughout: there is no other state to keep");
FgWindow atCeiling = FgWindow.From(FgStream(appFrames: 80, k: 8), Frequency);
atCeiling.Refusal.Should().BeNull();
atCeiling.Factor.Should().BeApproximately(8.0, 0.01);
}
[Fact]
public void AFactorIsPublishedWhenEveryRefusalPasses()
{