Fix original-game export loading and add opt-in Steam comparison

Keep existing Space access settings and simulator binaries. Fix required Id, Stats and Snapshots in exported game networks. Add optional read-only Steam comparison, run-wide best lap and bounded request admission. Formula remains the only hosted vehicle.

DATA_POLICY.md

@@ -108,3 +108,12 @@ to the server. Exporting saves a new file, not the original source. No training
 history is attributed to freshly created or edited weights. A future bucket
 adapter is not implemented; it must be explicitly selected and must not silently
 turn public ephemeral storage into persistent storage.
+
+
+## Optional public Steam leaderboard check
+
+The “After a completed lap” checkbox is off by default. With it off, or when a run reports no completed lap, the browser makes no leaderboard request. When enabled, the browser sends only the built-in track ID and hash, Formula vehicle type, and reported best-lap seconds to this app's same-origin server. Custom or unidentified tracks are not sent. HF does not forward the lap, network, Steam ID, account credential, file name or other run data to Steam.
+
+The app reads the public Steam Community track index and matching board XML without a Steam login or publisher key. It resolves exact catalog reference labels against that live index; an absent or ambiguous mapping is unavailable. The app retains only a short-lived in-process cache of public board rank/time rows (up to 60 seconds) and the public index mapping (up to five minutes). Player names, Steam IDs and raw XML are discarded after parsing. The comparison request and result are not stored in the job result store or recipe library.
+
+The displayed value is an insertion-position estimate against the fetched raw global board, at millisecond precision. The board may contain entries for different vehicle types; the estimate is not vehicle-filtered, an official rank, a submitted score, or proof that replica timing matches the Steam game. The check runs in the background with an eight-second browser deadline. It cannot delay result availability or download; a timeout leaves the completed result intact. Steam's community page may change or become unavailable, in which case the app reports the check as unavailable.

FRONTEND_SOURCE.json

@@ -1,10 +1,10 @@
 {
   "source": "Runner r14 single-engine browser UI; selected .track tile renderer added from simulator atlas",
   "source_sha256": "65d1e5f2c4e19b4951b828e82510005ab99a5270cf3dcb9f4eaa0fa1af8c40f8",
-  "output_sha256": "182f8d8b5b5393a28d259aec2dbe9003fc356e4ff817b0e6c15a9f1be004dbf1",
+  "output_sha256": "713496757a5fa796cf35eb9fba7a4f29b0eb2f8abdd6c8e3a6fdfd8036a3a30f",
   "scope": "Frontend only; no engine, private data, track assets, API calls or storage copied",
-  "status": "Five-output and full vanilla-network candidate; hosted qualification recorded separately",
+  "status": "Original-game export metadata corrected; optional Steam comparison; vehicle/track audit separate",
   "track_atlas_sha256": "d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4",
-  "client_sha256": "b6c2e0439bc1e4cf55c5e751e497e842e1e911b229f7480d7b1e04dea246536f",
+  "client_sha256": "93af3e91c0c5fe56ea0d95c40bb26b3e81aff3d36c38b035b4666a4d0955563a",
   "track_map_sha256": "ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0"
 }

RELEASE_MANIFEST.json

@@ -5,9 +5,9 @@
     "BETA_TESTING.md": "840192b5dec11ab903b05b358d14bd266efd3aaceedcf6d2794f7dc874b9caeb",
     "BINARY_PROVENANCE.json": "1116e1757afc6c8629cb2d957e3d77380fe4f7e3186c3832d16a5a08abce6aa8",
     "CUDA_REFERENCE.md": "ecee71c9a509702011026ee62bb60ba4e41dac868d6710bcc8c49c8995a2ffeb",
-    "DATA_POLICY.md": "38da17f8528ede1ef1850e98832f75ba35ebdc86a0cde87e27674eb0ff9c7a7f",
+    "DATA_POLICY.md": "4d7d0da26a5366ea9c7d33a47dacb8d0d5545174febae170226cc2b924b0a479",
     "FEEDBACK.md": "f95b8f6afbf4a360976c0edca5d52f5b3a0b668c9a944d4947b840a7c53a122a",
-    "FRONTEND_SOURCE.json": "0c478aac6c58f387b468d0c758bfdd16b461e033064d8b637b64fb3fcbe87f1b",
+    "FRONTEND_SOURCE.json": "53a819f3ce95a9393713e8db5e7b112cd0eed15bb57b84a415499436fad6224f",
     "GODOT_LICENSE": "fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304",
     "IMPORTER_BUILD_RECEIPT.json": "4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d",
     "LICENSE": "53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8",
@@ -53,14 +53,15 @@
     "builtin_tracks/tracks/Replica R08 Demolition Derby.track": "6f11a9ffbcb477c9d19964566b1b612d2a94675605246e93e21f27bbbdb357ef",
     "builtin_tracks/tracks/Replica R09 Eau Noir.track": "3ec0a78478cca1a4f0d2d98ac81f40783928adf271b70f0c32d295a6da2cdaa9",
     "builtin_tracks/tracks/Replica The Champions Trial.track": "a3bfb76422affc774b44c739b0636d08acb901fa7615b9adcb52c069f79834e1",
-    "client.js": "b6c2e0439bc1e4cf55c5e751e497e842e1e911b229f7480d7b1e04dea246536f",
+    "client.js": "93af3e91c0c5fe56ea0d95c40bb26b3e81aff3d36c38b035b4666a4d0955563a",
     "delivery.py": "07453999c3831a16e8b1fcc2b4ae5fb28beb7d3952a3fae8de65d16eb6f11e5b",
     "gpu_tickets.py": "b81aadb5ed42cec9212d44da7e7bbb7b413c5bd517383cac0b49ec9b4d659c92",
     "hf-auth.js": "d5cf17b961d1f2efa9d4648d33ba86a148eff0d542c74a121710c4df35c92936",
     "hf_identity.py": "6993d0238ada835606dbdc3275c17a3fe5a5cac5ad2156ab78230acf2d051eba",
-    "index.html": "182f8d8b5b5393a28d259aec2dbe9003fc356e4ff817b0e6c15a9f1be004dbf1",
+    "index.html": "713496757a5fa796cf35eb9fba7a4f29b0eb2f8abdd6c8e3a6fdfd8036a3a30f",
     "requirements.txt": "9b532747e51bd052e82090ece860d6dafe027407f4512dc74272c148ea104c22",
-    "server.py": "de98db424b96a4fbab7ce5b98ee42a94e846e2b3f317593e2346c5f87489ede8",
+    "server.py": "af567a30347bbcb75dda324408c47bc2fa8b519693d95c450403fd3012eb8fc5",
+    "steam_leaderboard.py": "0f2dbe9615f1bcda2e8f4399a2fa4257ef86a751887dd0b41e0f65034ed3138b",
     "track-library.js": "351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6",
     "track-map.js": "ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0",
     "training_config.py": "a0dd095e0de8c5a964ace66954f346e5d7b861db3d34cd2feaceedc5ecb80bad",
@@ -70,7 +71,7 @@
     "vendor/hf-oauth/LICENSE": "d6e7b19451c1b3d1d66353bb4b1274138953b3bfd9ae60c56e77b1f548796982",
     "vendor/hf-oauth/index.js": "53282844000a171011e547f6472a3846bb4cecb5071adafea079fcac3a2aee7e",
     "vendor/hf-oauth/package.json": "fafd4d8891023a1961546a7d3bc25cd24f64923a2ebfc449fe6d516a2949bda8",
-    "worker.py": "58bc6ba0a96e9d0b02af04c4d87df33cf973a44fdd7e67d8d4efe0b6d67cf0fe"
+    "worker.py": "2ddf02d3424bba451aa0031dfd9f06d1ec9e210c245ed36dcbe5c79f3732a9ba"
   },
   "interface": "single-engine-runner-with-map",
   "upstream_revision": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f"

client.js

@@ -13,6 +13,8 @@ let batchStopRequested = false;
 let batchReceipt = null;
 let runReceipt = null;
 let appBuild = null;
+let leaderboardRequest = null;
+let leaderboardGeneration = 0;
 // Display context affects quota guidance, never whether GPU can be selected.
 const hostedStandalone = location.hostname.endsWith('.hf.space') && window.self === window.top;
 const say = text => { $('status').textContent = text; };
@@ -45,6 +47,12 @@ function buttons() {
   if($('batch_export'))$('batch_export').disabled=busy || !batchReceipt;
 }
 $('backend').addEventListener('change',buttons);
+$('leaderboard_opt_in')?.addEventListener('change',()=>{
+  if(!$('leaderboard_opt_in').checked&&leaderboardRequest){
+    cancelSteamLeaderboard();
+    $('leaderboard_status').textContent='Steam check stopped. The completed run is unaffected.';
+  }
+});
 const feedbackLink=$('feedbackLink');
 feedbackLink?.addEventListener('click',()=>{
   const url=new URL('https://github.com/seeker-cyber-maker/driving_sim_rs/issues/new');
@@ -87,6 +95,38 @@ window.TrainingClient={
     buttons();
   }
 };
+async function checkSteamLeaderboard(trackInfo,report){
+  const status=$('leaderboard_status'),optIn=$('leaderboard_opt_in');
+  if(!optIn?.checked)return;
+  const lap=report?.best_lap_seconds;
+  if(typeof lap!=='number'||!Number.isFinite(lap)||lap<=0){status.textContent='Steam check not run: no completed best lap was reported.';return;}
+  if(trackInfo?.source!=='builtin'||typeof trackInfo.id!=='string'||typeof trackInfo.sha256!=='string'){
+    status.textContent='Steam check unavailable for custom or unidentified tracks. Your run result is unaffected.';return;
+  }
+  cancelSteamLeaderboard();
+  const generation=leaderboardGeneration,controller=new AbortController();
+  leaderboardRequest=controller;
+  status.textContent='Checking the public Steam board in the background…';
+  const timer=setTimeout(()=>controller.abort(),8000);
+  try{
+    const response=await fetch('/api/leaderboard/compare',{method:'POST',cache:'no-store',credentials:'same-origin',signal:controller.signal,headers:{'Content-Type':'application/json'},body:JSON.stringify({track_id:trackInfo.id,track_sha256:trackInfo.sha256,vehicle_type:0,lap_seconds:lap})});
+    const result=await response.json();
+    if(generation!==leaderboardGeneration)return;
+    if(!response.ok)throw Error('Steam check unavailable');
+    if(result.status==='ok'){
+      const rank=result.estimated_position?.label||'position unavailable';
+      status.textContent='Estimated '+rank+' of '+result.entries+' entries on '+result.board.track_label+' (snapshot '+result.fetched_at_utc+'). '+result.message;
+    }else status.textContent=result.message||'Steam check unavailable. Your run result is unaffected.';
+  }catch(error){
+    if(generation!==leaderboardGeneration)return;
+    status.textContent=error?.name==='AbortError'?'Steam check timed out; the completed result is ready to download.':'Steam check unavailable; the completed result is ready to download.';
+  }finally{clearTimeout(timer);if(generation===leaderboardGeneration)leaderboardRequest=null;}
+}
+function cancelSteamLeaderboard(){
+  leaderboardGeneration++;
+  const active=leaderboardRequest;leaderboardRequest=null;
+  active?.abort();
+}
 async function submit(body){
   if(body.backend==='gpu' && gpuTransport==='gradio-ticket'){
     await verifyGpuIdentity();
@@ -145,6 +185,8 @@ function showDetails(r){
     'Generation '+h.generation+' · mutation '+metric(h.mutation)+' · best '+metric(h.best_score)+' · mean '+metric(h.mean_score)+' · lap '+(h.best_lap_seconds??'none')).join('\n');
 }
 $('run').onclick = async () => {
+  cancelSteamLeaderboard();
+  if($('leaderboard_status'))$('leaderboard_status').textContent='';
   const started=performance.now();
   $('runState').textContent='RUNNING — waiting for server confirmation';
   $('runState').style.color='#ffd073';
@@ -178,6 +220,8 @@ $('run').onclick = async () => {
       'A completed test does not establish improved driving.'
     ].join('\n'):'Server returned a candidate; detailed metrics unavailable.';
     showDetails(r);
+    if($('leaderboard_opt_in')?.checked)void checkSteamLeaderboard(trackInfo,r);
+    else if($('leaderboard_status'))$('leaderboard_status').textContent='';
     $('track').value=''; $('network').value='';
     stagedNetwork=null;if($('networkChoice'))$('networkChoice').textContent='Network input released after the run.';
     say('Result ready ('+job.backend.toUpperCase()+'). Inputs and intermediate worker files have been removed.');

index.html

@@ -44,7 +44,7 @@
 <p><button id="saveLocal" disabled>Save received result again (browser only)</button> <button id="forgetLocal" disabled>Discard browser result</button></p>
 <p>The browser keeps the received result in memory until discarded, replaced by a new run, or this page is closed. It is not saved to browser storage.</p>
 <h3 id="runState" role="status" aria-live="polite">READY — no run started</h3>
-<pre id="runSummary" style="white-space:pre-wrap;line-height:1.7" aria-live="polite"></pre>
+<pre id="runSummary" style="white-space:pre-wrap;line-height:1.7" aria-live="polite"></pre><label class="keep-result"><input id="leaderboard_opt_in" type="checkbox"> After a completed lap, check its position against the public Steam leaderboard</label><p class="privacy-note">Optional, read-only check for supported built-in tracks. It sends the track ID and best lap to this app server; Steam receives only a public leaderboard read. No score is submitted. The result is an estimate, not an official rank.</p><p id="leaderboard_status" role="status" aria-live="polite"></p>
 <p><button id="run_export" disabled>Export run receipt</button></p><p class="hint">Receipts include build identity, settings, metrics and file hashes. Review them before sharing; they contain no network weights or job access keys.</p>
 <p id="deadline"></p><p id="status" role="status">Ready. Inputs remain on this device until you run the test.</p>
 <details><summary>Effective training settings</summary><pre id="effectiveSettings"></pre></details><details><summary>Generation results</summary><pre id="generationHistory"></pre></details><details><summary>Star challenges — not evaluated</summary><p>The current runner has star-challenge reporting. Its evaluator and required statistics have not been ported to HF; no star result is inferred from a completed test.</p></details></section></div>
@@ -224,7 +224,10 @@
     const network=neural(n),shape=network.Shape;
     if(!Array.isArray(source.Sensors)||source.Sensors.length!==shape[0]||!outputsValid(source.Outputs)||source.Outputs.length!==shape.at(-1))throw Error('Editing must preserve the sensor/output contract');
     if(typeof name!=='string'||!name.trim()||name.length>80)throw Error('Network name required (80 characters maximum)');
-    return {Name:name.trim(),Type:source.Type,Outputs:[...source.Outputs],Sensors:JSON.parse(JSON.stringify(source.Sensors)),NeuralNetwork:network};
+    const idPattern=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const id=typeof source.Id==='string'&&idPattern.test(source.Id)?source.Id:(root.crypto&&typeof root.crypto.randomUUID==='function'?root.crypto.randomUUID():null);
+    if(!id)throw Error('Secure GUID generation is unavailable');
+    return {Id:id,Name:name.trim(),Type:source.Type,Stats:{Generations:[]},Snapshots:[],Outputs:[...source.Outputs],Sensors:JSON.parse(JSON.stringify(source.Sensors)),NeuralNetwork:network};
   }
   function fresh({shape,outputs=[0,1,2,3,4],seed,xavier=true,bias=false,name='Fresh network'}){
     if(!Array.isArray(shape)||shape.length<1||shape.length>11||shape.some(n=>!Number.isInteger(n)||n<1)||shape[0]>20||shape.slice(1).some(n=>n>16))throw Error('Fresh shape: 1–20 inputs and 0–10 hidden layers of 1–16 nodes');
@@ -529,4 +532,4 @@ document.querySelectorAll('[data-tab]').forEach(button=>button.addEventListener(
     event.preventDefault();try{const {file}=await artifact();if(exportURL)URL.revokeObjectURL(exportURL);exportURL=URL.createObjectURL(file);const a=document.createElement('a');a.href=exportURL;a.download=file.name;a.click();status('Export requested. This is a new edited artifact with no inherited training scores.');}catch(error){status('Not exported: '+error.message);}
   };
 })();
-</script></html>
+</script></html>

server.py

@@ -12,16 +12,48 @@ from build_info import build_identity
 from training_config import validate_config
 from hf_identity import oauth_config
 from builtin_tracks import TrackLibrary
+from steam_leaderboard import compare_public_best_lap, milliseconds, SteamUnavailable
 
 ROOT=Path(__file__).resolve().parent
 
 def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None):
     app=create_api(store)
     admission=threading.BoundedSemaphore(1)
+    leaderboard_admission=threading.BoundedSemaphore(1)
     library=track_library if track_library is not None else TrackLibrary(ROOT/'builtin_tracks')
     @app.get('/api/tracks')
     def track_catalog():
         return JSONResponse(library.catalog(),headers={'Cache-Control':'no-store'})
+    @app.post('/api/leaderboard/compare')
+    async def leaderboard_compare(request:Request):
+        data=bytearray()
+        async for chunk in request.stream():
+            if len(data)+len(chunk)>4096: raise HTTPException(413,'Request too large')
+            data.extend(chunk)
+        try:
+            body=json.loads(data)
+            if not isinstance(body,dict) or set(body)!={'track_id','track_sha256','vehicle_type','lap_seconds'}:
+                raise ValueError()
+            if not isinstance(body['track_id'],str) or not isinstance(body['track_sha256'],str): raise ValueError()
+            if type(body['vehicle_type']) is not int: raise ValueError()
+            milliseconds(body['lap_seconds'])
+        except Exception: raise HTTPException(400,'Invalid leaderboard comparison request') from None
+        finally: data.clear()
+        if body['vehicle_type']!=0:
+            return {'status':'unsupported_vehicle','message':'Steam comparison is available only for Formula runs.'}
+        entry=next((track for track in library.catalog()['tracks'] if track['id']==body['track_id']),None)
+        if entry is None:
+            return {'status':'unsupported_track','message':'Steam comparison is available only for supported built-in tracks.'}
+        if body['track_sha256']!=entry['sha256']:
+            raise HTTPException(400,'Track identity did not match the built-in catalog')
+        if not leaderboard_admission.acquire(blocking=False):
+            return {'status':'busy','message':'Another Steam check is in progress. The completed result is unaffected.'}
+        try:
+            return await run_in_threadpool(compare_public_best_lap,entry,body['lap_seconds'])
+        except SteamUnavailable:
+            return {'status':'unavailable','message':'Steam could not provide a complete public leaderboard. The completed result is unaffected.'}
+        finally:
+            leaderboard_admission.release()
     @app.get('/api/tracks/{identifier}/file')
     def reference_track(identifier:str):
         try:payload=library.read(identifier)

steam_leaderboard.py

@@ -0,0 +1,228 @@
+"""Anonymous read-only Steam Community leaderboard comparison; never uploads scores."""
+from datetime import datetime, timezone
+from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
+from html.parser import HTMLParser
+import hashlib
+import re
+import threading
+import time
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+import xml.etree.ElementTree as ET
+
+APP_ID = 3312030
+INDEX_URL = f'https://steamcommunity.com/stats/{APP_ID}/leaderboards/'
+MAX_BYTES = 8_000_000
+TIMEOUT_SECONDS = 4
+TOTAL_TIMEOUT_SECONDS = 10
+INDEX_TTL_SECONDS = 300
+BOARD_TTL_SECONDS = 60
+
+_cache_lock = threading.Lock()
+_index_cache = None
+_board_cache = {}
+
+
+class SteamUnavailable(Exception):
+    """The public Community endpoint could not provide a validated board."""
+
+
+class BoardOptions(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.options = {}
+        self.value = None
+        self.parts = []
+        self.duplicate = False
+
+    def handle_starttag(self, tag, attrs):
+        if tag == 'option':
+            self.value = dict(attrs).get('value')
+            self.parts = []
+
+    def handle_data(self, data):
+        if self.value is not None:
+            self.parts.append(data)
+
+    def handle_endtag(self, tag):
+        if tag == 'option' and self.value is not None:
+            if self.value in self.options:
+                self.duplicate = True
+            self.options[self.value] = ''.join(self.parts).strip()
+            self.value = None
+
+
+def _read(url):
+    # Callers pass only INDEX_URL or a URL assembled from a numeric ID in that
+    # verified public index. No request data is placed in a Steam URL.
+    request = Request(url, headers={'User-Agent': 'ALD-hosted-public-board-check/1.0'})
+    started = time.monotonic()
+    try:
+        with urlopen(request, timeout=TIMEOUT_SECONDS) as response:
+            final = urlparse(response.geturl())
+            if final.scheme != 'https' or final.hostname != 'steamcommunity.com':
+                raise SteamUnavailable('Steam public leaderboard redirected outside its fixed host')
+            chunks, size = [], 0
+            while True:
+                if time.monotonic() - started >= TOTAL_TIMEOUT_SECONDS:
+                    raise SteamUnavailable('Steam public leaderboard request exceeded its time limit')
+                chunk = response.read(min(65536, MAX_BYTES + 1 - size))
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                size += len(chunk)
+                if size > MAX_BYTES:
+                    raise SteamUnavailable('Steam public leaderboard response exceeded the size limit')
+            return b''.join(chunks)
+    except SteamUnavailable:
+        raise
+    except Exception as error:
+        raise SteamUnavailable('Steam public leaderboard is temporarily unavailable') from error
+
+
+def _index():
+    global _index_cache
+    now = time.monotonic()
+    with _cache_lock:
+        if _index_cache and now - _index_cache[0] < INDEX_TTL_SECONDS:
+            return _index_cache[1]
+        raw = _read(INDEX_URL)
+        parser = BoardOptions()
+        try:
+            parser.feed(raw.decode('utf-8'))
+        except (UnicodeDecodeError, ValueError) as error:
+            raise SteamUnavailable('Steam public leaderboard index was invalid') from error
+        if parser.duplicate:
+            raise SteamUnavailable('Steam public leaderboard index had duplicate IDs')
+        boards = {}
+        for identifier, label in parser.options.items():
+            if identifier.isdecimal() and label:
+                if label in boards:
+                    raise SteamUnavailable('Steam public leaderboard index had ambiguous track labels')
+                boards[label] = (int(identifier), label)
+        fetched = datetime.now(timezone.utc).isoformat()
+        _index_cache = (now, {'boards': boards, 'sha256': hashlib.sha256(raw).hexdigest(), 'fetched_at_utc': fetched})
+        return _index_cache[1]
+
+
+def _parse_board(raw, board_id):
+    try:
+        root = ET.fromstring(raw)
+        if root.tag != 'response' or root.findtext('appID') != str(APP_ID):
+            raise ValueError()
+        if root.findtext('leaderboardID') != str(board_id):
+            raise ValueError()
+        count = int(root.findtext('totalLeaderboardEntries'))
+        received = int(root.findtext('resultCount'))
+        entries = []
+        prior_score = 0
+        for row in root.findall('./entries/entry'):
+            rank = int(row.findtext('rank'))
+            score = int(row.findtext('score'))
+            if rank != len(entries) + 1 or score <= 0 or score < prior_score:
+                raise ValueError()
+            entries.append({'rank': rank, 'score_ms': score})
+            prior_score = score
+        if count < 1 or received != count or len(entries) != count:
+            raise ValueError()
+    except (ET.ParseError, TypeError, ValueError, OverflowError) as error:
+        raise SteamUnavailable('Steam returned an incomplete or mismatched leaderboard') from error
+    return entries
+
+
+def _board(label, board_id):
+    key = (label, board_id)
+    now = time.monotonic()
+    with _cache_lock:
+        cached = _board_cache.get(key)
+        if cached and now - cached[0] < BOARD_TTL_SECONDS:
+            return cached[1]
+        url = f'{INDEX_URL}{board_id}/?xml=1'
+        raw = _read(url)
+        entries = _parse_board(raw, board_id)
+        value = {
+            'entries': entries,
+            'fetched_at_utc': datetime.now(timezone.utc).isoformat(),
+            'source_sha256': hashlib.sha256(raw).hexdigest(),
+        }
+        _board_cache[key] = (now, value)
+        return value
+
+
+def milliseconds(seconds):
+    if isinstance(seconds, bool):
+        raise ValueError('Lap time must be a positive finite number')
+    try:
+        value = Decimal(str(seconds))
+    except (InvalidOperation, ValueError) as error:
+        raise ValueError('Lap time must be a positive finite number') from error
+    if not value.is_finite() or value <= 0 or value > 3600:
+        raise ValueError('Lap time must be positive and no more than one hour')
+    score = int((value * 1000).quantize(Decimal('1'), rounding=ROUND_HALF_UP))
+    if score < 1:
+        raise ValueError('Lap time must be at least one millisecond')
+    return score
+
+
+def compare_public_best_lap(track, lap_seconds):
+    """Compare to a public full board; caller has already verified car + track."""
+    label = track['reference_label']
+    # The original game only assigns campaign leaderboard IDs to A/B tracks.
+    # Some R-series labels happen to appear in the public HTML index, but the
+    # game source has no verified mapping from those tracks to Steam boards.
+    if not isinstance(label, str) or not re.match(r'^[AB]\d{2} ', label):
+        return {
+            'status': 'unsupported_track',
+            'track': {'reference_label': label if isinstance(label, str) else None},
+            'source': 'Original game leaderboard mapping',
+            'message': 'The original game has no verified Steam leaderboard mapping for this track.',
+            'official_rank': False,
+        }
+    mapping = _index()
+    item = mapping['boards'].get(label)
+    if not item:
+        return {
+            'status': 'unsupported_track',
+            'track': {'reference_label': label},
+            'source': 'Steam Community public index',
+            'fetched_at_utc': mapping['fetched_at_utc'],
+            'message': 'Steam has no public leaderboard for this built-in track.',
+            'official_rank': False,
+        }
+    board_id, label = item
+    data = _board(label, board_id)
+    score = milliseconds(lap_seconds)
+    entries = data['entries']
+    ties = [row['rank'] for row in entries if row['score_ms'] == score]
+    if ties:
+        lower, upper = min(ties), max(ties)
+    else:
+        lower = 1 + sum(row['score_ms'] < score for row in entries)
+        upper = lower
+    exact = lower == upper
+    position = f'#{lower}' if exact else f'#{lower}–#{upper}'
+    if ties:
+        position += ' (displayed-time tie)'
+    return {
+        'status': 'ok',
+        'board': {'app_id': APP_ID, 'leaderboard_id': board_id, 'track_label': label, 'scope': 'global'},
+        'source': 'Steam Community public XML',
+        'source_url': f'{INDEX_URL}{board_id}/?xml=1',
+        'fetched_at_utc': data['fetched_at_utc'],
+        'index_sha256': mapping['sha256'],
+        'board_sha256': data['source_sha256'],
+        'entries': len(entries),
+        'lap_milliseconds': score,
+        'estimated_position': {'lower': lower, 'upper': upper, 'exact_in_snapshot': exact, 'label': position},
+        'ties': ties,
+        'rank_basis': 'Insertion position in the complete raw global Steam board at fetch time; not filtered by vehicle metadata.',
+        'official_rank': False,
+        'message': 'Estimate only: the run was not submitted. This is a snapshot insertion position, not an official Steam rank or verification of game timing parity.',
+    }
+
+
+def _reset_cache_for_tests():
+    global _index_cache
+    with _cache_lock:
+        _index_cache = None
+        _board_cache.clear()

worker.py

@@ -13,6 +13,7 @@ import subprocess
 import struct
 import tempfile
 import time
+import uuid
 from training_config import validate_config
 from build_info import build_identity
 
@@ -95,7 +96,8 @@ def network_input(data):
             not isinstance(biases[i],list) or len(biases[i])!=b): raise ValueError('Dimensions')
         for n in [x for row in weights[i] for x in row]+biases[i]:
             if type(n) not in (int,float) or not math.isfinite(n) or abs(n)>1e6: raise ValueError('Weight value')
-    return {'Type':0,'Outputs':outputs[:],'Sensors':clean_sensors,
+    return {'Id':str(uuid.uuid4()),'Stats':{'Generations':[]},'Snapshots':[],
+            'Type':0,'Outputs':outputs[:],'Sensors':clean_sensors,
             'Name':'HF candidate','NeuralNetwork':{'Shape':shape,'InputShape':shape[0],'OutputShape':shape[-1],
                 'NeuronsCount':sum(shape),'TotalParams':sum((a+1)*b for a,b in zip(shape,shape[1:])),
                 'Weights':weights,'Biases':biases}}
@@ -123,6 +125,13 @@ def native_environment(gpu_library=None):
         env['ALTD_GPU_LIB']=str(library)
     return env
 
+def best_run_lap(history):
+    # Native best_lap_s is generation-local. Include the independently logged
+    # all-time value and prior generations, never a non-finite sentinel.
+    values = [row.get(key) for row in history for key in ('best_lap_s', 'all_time_best_lap_s')]
+    laps = [v for v in values if type(v) in (int, float) and math.isfinite(v) and v > 0]
+    return min(laps) if laps else None
+
 def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_template=None,with_report=False,gpu_library=None,config=None):
     started=time.perf_counter()
     config=validate_config(config)
@@ -177,7 +186,7 @@ def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_templ
         report={'build':build_identity(),'state':'completed','elapsed_seconds':time.perf_counter()-started,
             'generations_completed':len(history),'generations_requested':config['generations'],'population':config['population'],
             'best_score':last.get('best_score'),'mean_score':last.get('mean_score'),
-            'best_lap_seconds':last.get('best_lap_s'),'lapped_cars':last.get('lapped_cars'),
+            'best_lap_seconds':best_run_lap(history),'best_lap_scope':'Best completed lap observed during this run; may belong to a different car than the exported candidate','lapped_cars':last.get('lapped_cars'),
             'simulated_ticks':last.get('simulated_ticks'),'requested_ticks':config['ticks'],
             'candidate_validated':True,'execution_backend':'cuda' if gpu_library is not None else 'cpu',
             'inputs':{'track_sha256':hashlib.sha256(track_bytes).hexdigest(),'network_sha256':hashlib.sha256(network_bytes).hexdigest()},