Replace synthetic viewer telemetry with recorded native drives

The current viewer derives motion and HUD values from aggregate results, which creates off-track starting poses, discontinuous movement and unsupported telemetry.

This change replaces that reconstruction with an explicit recorded CPU drive. The native engine supplies position, velocity, heading and contact samples for one unchanged policy; the viewer keeps native track curves, validates the track/policy identities, interpolates only between recorded poses and stops at the final sample. Unavailable controls, sensor rays and neural activity are removed.

The new recording endpoint is bounded to 15 seconds of simulation with a 30-second wall deadline, shares CPU admission with training and uses the existing binary. Physics and control stay at 60 Hz; samples are captured every six ticks. These are fresh drives with wall-hit and idle elimination off, clearly distinguished from historical training results.

Validation: 36 focused checks pass (14 recorder contract, 9 geometry/playback, 5 client lifecycle/integration and 8 existing tutorial/recipe/batch workflows). JavaScript and Python syntax checks pass. Hosted native recording and final visual inspection will follow the complete package update.

server.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 from pathlib import Path
 import re
+import subprocess
 import threading
 from fastapi import HTTPException, Request
 from fastapi.responses import FileResponse, Response, HTMLResponse, JSONResponse
@@ -363,6 +364,45 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
             except InvalidAnalysisOutput: raise HTTPException(422,'Processing failed; complete analysis could not be verified.') from None
             except Exception: raise HTTPException(422,'Processing failed; no result published. Cleanup status requires verification.') from None
         finally: admission.release()
+    @app.post('/api/replay')
+    async def recorded_replay(request:Request):
+        # Share CPU admission with training; recordings never allocate a GPU.
+        if not admission.acquire(blocking=False):
+            raise HTTPException(429,'Worker busy; finish the current run before recording a drive')
+        data=bytearray()
+        try:
+            async for chunk in request.stream():
+                if len(data)+len(chunk)>3*1024*1024:
+                    raise HTTPException(413,'Replay input exceeds the upload limit')
+                data.extend(chunk)
+            try:
+                body=json.loads(data)
+                if not isinstance(body,dict) or set(body)!={'track','network','ticks'}:
+                    raise ValueError()
+                if type(body['ticks']) is not int or not 1<=body['ticks']<=900:
+                    raise ValueError()
+                track=base64.b64decode(body['track'],validate=True)
+                network=base64.b64decode(body['network'],validate=True)
+                if not track or not network or max(len(track),len(network))>1024*1024:
+                    raise ValueError()
+            except Exception:
+                raise HTTPException(400,'Invalid replay input; select a track, a network and up to 15 seconds') from None
+            finally:
+                data.clear()
+            from replay import record_replay, ReplayError
+            try:
+                recording=await run_in_threadpool(record_replay,track,network,
+                    binary=ROOT/'bin/altd-sim',importer=ROOT/'bin/extract_saved_track',
+                    scene_template=ROOT/'assets/formula_template.json',ticks=body['ticks'])
+                recording['build']=build_identity()
+                return JSONResponse(recording,headers={'Cache-Control':'no-store','X-Content-Type-Options':'nosniff'})
+            except (TimeoutError,subprocess.TimeoutExpired):
+                raise HTTPException(504,'Recording reached its time limit. Try a 5-second drive.') from None
+            except (ReplayError,OSError,ValueError,KeyError,TypeError,subprocess.CalledProcessError):
+                raise HTTPException(422,'The engine could not produce a complete recorded drive. No estimated playback was substituted.') from None
+        finally:
+            data.clear()
+            admission.release()
     return app
 
 app=create_app()