Private CPU interface integration with ephemeral result lifecycle

.gitattributes

@@ -39,3 +39,4 @@ tracks/R09[[:space:]]Eau[[:space:]]Noir.track filter=lfs diff=lfs merge=lfs -tex
 tracks/The[[:space:]]Champions[[:space:]]Trial.track filter=lfs diff=lfs merge=lfs -text
 bin/altd-sim filter=lfs diff=lfs merge=lfs -text
 bin/libaltd_gpu.so filter=lfs diff=lfs merge=lfs -text
+bin/extract_saved_track filter=lfs diff=lfs merge=lfs -text

DATA_POLICY.md

@@ -0,0 +1,35 @@
+# Data handling & deletion policy — private integration test
+
+Operator: TiGa (seeker-cyber-maker). Version: draft 2026-10-08.
+
+Files are processed only for the requested job, not collected for our own
+training, analytics or public examples. Inputs remain in the browser until Run.
+This local test uses native CPU; the hosted GPU path is not yet integrated.
+
+Each job uses temporary files removed before a successful result is published.
+The application result store is memory-only. No public file URL is created.
+The browser holds a random job access key in memory, not a user account or HF token.
+Anyone who obtains that key can access the job; do not share it. Reloading the
+page loses access. Expiry is fixed at 30 minutes from result publication.
+
+Automatic deletion is enabled by default. The browser validates the complete
+download and acknowledges receipt; that deletes the result store's copy. One
+download attempt is permitted. We cannot verify that the browser saved to disk.
+An interrupted attempt is not retryable in automatic mode; Delete now and expiry
+still work. Unchecking automatic deletion allows repeat downloads until expiry.
+Delete now removes the stored result immediately. Downloads never reset expiry.
+
+Access is refused at the deadline. While the server is running, the expiry loop
+releases expired stored data within approximately one second, subject to runtime
+scheduling. Shutdown clears the store; a restart has no saved job data to reload.
+This is deletion of application-controlled files and stored results, not a claim
+of physical RAM/disk erasure, prevention of swap, or deletion of response buffers.
+No claim is made about hosting-provider logs or infrastructure retention.
+
+Results received by the browser and files saved locally are the user's to manage.
+The browser retains its received result in page memory so Save received result
+again can retry a local save without another server retrieval. Discard browser
+result clears the app's reference; closing or refreshing the page loses it.
+No bucket support, network sandbox or provider-wide ZDR guarantee is offered.
+The development service is single-process and loopback-only. Public deployment
+and its framework/proxy behavior must be tested separately before release.

GODOT_LICENSE

@@ -0,0 +1,43 @@
+Godot Engine source adaptations in src/physics/broadphase.rs
+
+Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md).
+Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Modified tree-balancing algorithm, originally Randy Gaul qu3e:
+/**
+ * @file    q3DynamicAABBTree.h
+ * @author  Randy Gaul
+ * @date    10/10/2014
+ *  Copyright (c) 2014 Randy Gaul http://www.randygaul.net
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty. In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *    1. The origin of this software must not be misrepresented; you must not
+ *       claim that you wrote the original software. If you use this software
+ *       in a product, an acknowledgment in the product documentation would be
+ *       appreciated but is not required.
+ *    2. Altered source versions must be plainly marked as such, and must not
+ *       be misrepresented as being the original software.
+ *    3. This notice may not be removed or altered from any source distribution.
+ */
+

IMPORTER_BUILD_RECEIPT.json

@@ -0,0 +1,60 @@
+{
+  "created_utc": "2026-10-08T19:25:38.550739+00:00",
+  "status": "built_and_smoke_verified",
+  "repository": "https://github.com/Zorro909/driving_sim_rs",
+  "source_revision": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f",
+  "source_worktree_clean": true,
+  "build_command": "RUSTFLAGS=\"-C target-cpu=x86-64\" cargo build --locked --release --no-default-features --features cli --example extract_saved_track",
+  "build_exit_code": 0,
+  "rustc": "rustc 1.93.0 (254b59607 2026-01-19)\nbinary: rustc\ncommit-hash: 254b59607d4417e9dffbc307138ae5c86280fe4c\ncommit-date: 2026-01-19\nhost: x86_64-unknown-linux-gnu\nrelease: 1.93.0\nLLVM version: 21.1.8",
+  "cargo": "cargo 1.93.0 (083ac5135 2025-12-15)",
+  "architecture": "x86_64-unknown-linux-gnu",
+  "cpu_codegen": "x86-64 baseline (target-cpu=native overridden)",
+  "host_libc": "Debian GLIBC 2.41-12+deb13u4",
+  "binary_minimum_glibc_symbol_version": "2.34",
+  "dynamic_libraries": [
+    "libgcc_s.so.1",
+    "libc.so.6"
+  ],
+  "elf_interpreter": "/lib64/ld-linux-x86-64.so.2",
+  "runtime_compatibility_note": "ELF symbol requirements indicate glibc 2.34 or newer; tested only on this glibc 2.41 host. Destination integration remains untested.",
+  "smoke_commands": [
+    "./extract_saved_track --help",
+    "./extract_saved_track verification/generated_saved_track.json synthetic-smoke assets/scenes/formula_template.json verification/synthetic-scene.json"
+  ],
+  "verification": {
+    "help_exit_code": 0,
+    "synthetic_conversion_exit_code": 0,
+    "name_matches": true,
+    "tile_count_matches": true,
+    "tile_map_position_matches": true,
+    "native_broadphase_false": true,
+    "formula_vehicle_preserved": true,
+    "formula_physics_preserved": true,
+    "tiles": 24,
+    "physics_shapes": 160,
+    "walls": 401,
+    "path_points": 4593
+  },
+  "scope": "Importer build and smoke checks only. No full project test suite, private game data, deployment, shared source edits, or external services.",
+  "checksums_sha256": {
+    "GODOT_LICENSE": "fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304",
+    "LICENSE": "53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8",
+    "SOURCE_REVISION": "1d1f925697ae11f17015c08189043fb55bcc48b724e97daf5e102d043d1d1f0a",
+    "assets/scenes/formula_template.json": "80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b",
+    "extract_saved_track": "3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a",
+    "verification/Cargo.lock": "d8b8dfcfd4ddd90388a9aadae6c12a675e46277a3f26dabcce5ba8af6ff12183",
+    "verification/build.log": "55c65f1a725126537b35f3fafacccc5bcc8e6707a60f02d26b803da3a48b8763",
+    "verification/cargo-version.txt": "49f46ff5ffe434e6c1c66388a9230ac33bbe3dbd9175314e9ffc9aa7c418d329",
+    "verification/elf-report.txt": "ce9a1831871e3e7ce7cb24bb338934c92518cc65559d619a75c05657c09e5788",
+    "verification/file.txt": "18dcdc24bdaaf8eb6cd84fb37ab0ba9096766ffa31a5595cb9262ae8c3430363",
+    "verification/generated_saved_track.json": "dafb51079bddbc7b2a958acff37b6df3bbdd3af70fcae2b08df536db2f92f59b",
+    "verification/help.stderr.txt": "2da7efbb9ab342a5b0efb5e30855709859bc81fbbc134c539fd33cea1e86bf70",
+    "verification/help.stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "verification/ldd.txt": "38f782b358e5a768f4fccfff32f68262f4274fc1575b8568bf74d361d2d33a5d",
+    "verification/rustc-version.txt": "83e4eefd5e010a92d9f63328bf8219e23fe5e4cf5e5d17ce53d0263cfa4218a6",
+    "verification/smoke.stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "verification/smoke.stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "verification/synthetic-scene.json": "1d87b18c7844402df8ef8272f99f3f32670f98a240f3f72e14b505c2b45743e0"
+  }
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zorro909
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,33 +1,14 @@
 ---
-title: TAO ZeroGPU Qualification
-emoji: 🏎️
-colorFrom: green
-colorTo: blue
+title: AI Learns To Drive — TiGa interface
 sdk: gradio
 sdk_version: 6.29.1
-python_version: '3.10'
+python_version: "3.10"
 app_file: app.py
-pinned: false
 ---
 
-Private native CUDA compatibility probe and bounded upload smoke test, not a qualified trainer.
-Uses included ZeroGPU allowance through a 45-second leased call. No paid Jobs
-or dedicated hardware requested. Check the authenticated caller's included quota
-before each call; the app itself does not know account billing balances.
-
-Original Docker source and dashboard remain in this repository but are inactive.
-Rollback: restore README.md from revision ba07e35a39211af7a0deda0ebd9adb2c554b4f38
-and request CPU Basic. BINARY_PROVENANCE.json pins the two exact HF-built binaries
-to that revision and upstream d8ab74c25df70b6a86ed101080e33d5fb785ea6f.
-
-No CUDA initialization outside the lease. First check device discovery and a
-three-value sine kernel in process, then the normal Rust gpu-info subprocess.
-No fallback, trajectory parity, speedup or H200 claim. A second lease
-must independently pass before testing training. Retained PACKAGE_MANIFEST.json
-describes the prior Docker snapshot only; ZEROGPU_MANIFEST.json covers this overlay.
-
-The upload test validates the exact supplied A01 track and a 6-4-2 Formula network
-before leasing a GPU for at most 90 seconds. It repeats qualification, then runs
-4 vehicles for 1 generation of 60 physics ticks, seed 42, proton math profile.
-The subprocess has a 25-second timeout. It exports a candidate and receipt, not
-an improvement claim. Real-game import compatibility and physics parity remain unverified.
+Private CPU integration candidate. Custom FastAPI interface on port 7860.
+Simulator: https://github.com/Zorro909/driving_sim_rs
+Hosting adaptation and UI: TiGa https://github.com/seeker-cyber-maker/driving_sim_rs
+GPU is deliberately unavailable in this candidate. No bundled tracks or networks.
+One server process; no persistent storage. See DATA_POLICY.md for retention limits.
+Not yet verified in the hosted Linux runtime; do not publish as a stable release.

RELEASE_MANIFEST.json

@@ -0,0 +1,22 @@
+{
+  "backend": "cpu",
+  "files": {
+    "DATA_POLICY.md": "99844eda4df9f68be4b06ce7671a18474bd2a860ff20b30a221163698bfaef6d",
+    "GODOT_LICENSE": "fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304",
+    "IMPORTER_BUILD_RECEIPT.json": "4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d",
+    "LICENSE": "53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8",
+    "README.md": "8711574749eb4cc53da0253c40692868b337adb63ce045f2c881840982a032a8",
+    "app.py": "40cef7e65bbcf9798eaa1374a2c7be4bb45a5d4e70e981a1eeb8b0b2f2a00c35",
+    "assets/formula_template.json": "80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b",
+    "bin/altd-sim": "2f2f2144ae14b0ef599ca8510f95712da00243c6875881491d384b394e7499f7",
+    "bin/extract_saved_track": "3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a",
+    "client.js": "828d29ae0291d9696364415397c113e907d1c512e01c0ef4cb771da63e5a48bf",
+    "delivery.py": "effc7e33c11c2e999b48620feaae263975a13df59c85f9c3a12c3f038ad47a5a",
+    "index.html": "cf4c0670c81184f8ea2726041457ae3cecc6c79b9030a41fe545b1bc503f0a47",
+    "requirements.txt": "dbdedd8a6f30e16dc41bc3e210c1a936f679655420075f8f89bdd40bdd03f91b",
+    "server.py": "df0f3d22c55653de9216da2443d17cd098cf5552f66a0fafb742160b5b29eefe",
+    "worker.py": "b6178a26cc8cb916d9b24d4f13131f522a8055eaa834b84c4a101307852b9e33"
+  },
+  "hosted_verified": false,
+  "upstream_revision": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f"
+}

app.py

@@ -1,36 +1,33 @@
-import spaces
-import gradio as gr
-from cloud_probe import run_probe
+"""HF CPU release entrypoint. One process owns all ephemeral results."""
+import hashlib
+import json
+from pathlib import Path
+from server import create_app
+from worker import run_native
 
-def cpu_smoke():
-    return run_probe(False)
+ROOT=Path(__file__).resolve().parent
 
-@spaces.GPU(duration=90)
-def gpu_smoke():
-    return run_probe(True)
+def verify_package(root=ROOT):
+    manifest=json.loads((root/'RELEASE_MANIFEST.json').read_text())
+    for name,expected in manifest['files'].items():
+        path=(root/name).resolve()
+        if not path.is_relative_to(root.resolve()) or not path.is_file():
+            raise RuntimeError('Invalid release member')
+        if hashlib.sha256(path.read_bytes()).hexdigest()!=expected:
+            raise RuntimeError('Release integrity check failed: '+name)
+    return manifest
 
-def selected_smoke(backend):
-    if backend == 'cpu':
-        return cpu_smoke()
-    if backend == 'gpu':
-        return gpu_smoke()
-    raise ValueError('Choose CPU or GPU')
+def cpu_worker(track,network):
+    return run_native(track,network,binary=ROOT/'bin/altd-sim',
+        importer=ROOT/'bin/extract_saved_track',
+        scene_template=ROOT/'assets/formula_template.json',with_report=True)
 
-with gr.Blocks() as demo:
-    gr.Markdown('''# AI Learns To Drive — private compute test
-Simulator by [Zorro909](https://github.com/Zorro909/driving_sim_rs).
-UI and HF implementation by TiGa (seeker-cyber-maker).
+def main():
+    verify_package()
+    for name in ('altd-sim','extract_saved_track'):
+        (ROOT/'bin'/name).chmod(0o755)
+    import uvicorn
+    uvicorn.run(create_app(worker=cpu_worker),host='0.0.0.0',port=7860,
+        workers=1,access_log=False)
 
-Fixed synthetic network, 4 cars, 1 generation, 60 ticks. CPU runs without a GPU lease.
-GPU uses up to 90 seconds of included allowance; check quota first. No automatic runs.
-No user uploads; temporary model files are deleted before the receipt is returned.
-This tests backend execution, not useful learning, performance, or full UI integration.
-''')
-    backend=gr.Radio(choices=[('CPU — no GPU allowance needed','cpu'),('GPU — uses included GPU allowance','gpu')],value='cpu',label='Compute')
-    report=gr.JSON(label='Execution receipt')
-    gr.Button('Run selected backend',variant='primary').click(selected_smoke,inputs=backend,outputs=report,api_name='selected_smoke',concurrency_limit=1,concurrency_id='native')
-    gr.Button('Run CPU-only test').click(cpu_smoke,outputs=report,api_name='cpu_smoke',concurrency_limit=1,concurrency_id='native')
-    gr.Button('Run GPU test').click(gpu_smoke,outputs=report,api_name='gpu_smoke',concurrency_limit=1,concurrency_id='native')
-
-if __name__=='__main__':
-    demo.queue(max_size=1).launch()
+if __name__=='__main__': main()

assets/formula_template.json

@@ -0,0 +1,111 @@
+{
+  "vehicle": {
+    "type": "Formula",
+    "mass": 2,
+    "inertia_property": 0,
+    "inertia_server": 1038.1666259765625,
+    "shape_size": [
+      73,
+      30
+    ],
+    "shape_position": [
+      0,
+      0
+    ],
+    "shape_rotation": 1.5708,
+    "gravity_scale": 1,
+    "linear_damp": 0,
+    "angular_damp": 0,
+    "max_contacts_reported": 4,
+    "friction": 0.95,
+    "bounce": 0.1,
+    "grip": 2,
+    "steering_speed": 0.4000000059604645,
+    "center_steering": true,
+    "air_resistance": 0.10000000149011612,
+    "max_velocity": 1200,
+    "surfaces": {
+      "asphalt": {
+        "grip": 1,
+        "power": 1,
+        "steering": 1
+      },
+      "dirt": {
+        "grip": 0.8,
+        "power": 0.5,
+        "steering": 1
+      },
+      "ice": {
+        "grip": 0.3,
+        "power": 0.5,
+        "steering": 1
+      }
+    },
+    "wheels": [
+      {
+        "position": [
+          -11,
+          -17
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          11,
+          -17
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          -13,
+          29
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      },
+      {
+        "position": [
+          13,
+          29
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      }
+    ]
+  },
+  "physics": {
+    "real_precision": "single",
+    "contact_recycle_radius": 1,
+    "contact_max_separation": 1.5,
+    "contact_max_allowed_penetration": 0.3,
+    "contact_default_bias": 0.8,
+    "solver_iterations": 16
+  },
+  "track": {
+    "name": "Generated track template",
+    "tiles": [],
+    "path": [],
+    "walls": [],
+    "physics_shapes": []
+  },
+  "reset_position": [
+    0,
+    0
+  ],
+  "reset_rotation": 0
+}

bin/extract_saved_track

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a
+size 3247776

client.js

@@ -0,0 +1,111 @@
+'use strict';
+const $ = id => document.getElementById(id);
+let job = null;
+let busy = false;
+let localResult = null;
+let capabilitiesReady = false;
+const say = text => { $('status').textContent = text; };
+function buttons() {
+  $('run').disabled = busy || !!job || !capabilitiesReady;
+  $('backend').disabled = busy || !!job || !capabilitiesReady;
+  $('download').disabled = busy || !job;
+  $('erase').disabled = busy || !job;
+  $('automatic').disabled = busy || !!job;
+  $('saveLocal').disabled = busy || !localResult;
+  $('forgetLocal').disabled = busy || !localResult;
+}
+function saveLocal() {
+  if(!localResult)return;
+  const link=document.createElement('a'),url=URL.createObjectURL(localResult);
+  link.href=url;link.download='candidate.evolution';document.body.appendChild(link);link.click();link.remove();
+  setTimeout(()=>URL.revokeObjectURL(url),60000);
+}
+$('saveLocal').onclick=saveLocal;
+$('forgetLocal').onclick=()=>{localResult=null;buttons();say('Browser result discarded. Downloaded files are unaffected.');};
+async function request(path, options = {}) {
+  const response = await fetch(path, {cache:'no-store', credentials:'omit', ...options});
+  if (!response.ok) throw new Error(response.status === 404 ? 'Result unavailable or expired.' : 'Request failed ('+response.status+').');
+  return response;
+}
+async function encoded(file) {
+  if (!file || file.size > 1048576) throw new Error('Choose both files, no more than 1 MB each.');
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  let text=''; for (let i=0;i<bytes.length;i+=8192) text+=String.fromCharCode(...bytes.subarray(i,i+8192));
+  return btoa(text);
+}
+const headers = () => ({Authorization:'Bearer '+job.key});
+$('run').onclick = async () => {
+  localResult=null;
+  const started=performance.now();
+  $('runState').textContent='RUNNING — waiting for server confirmation';
+  $('runState').style.color='#ffd073';
+  const tick=()=>{$('runSummary').textContent='Backend: '+$('backend').value.toUpperCase()+'\nElapsed: '+((performance.now()-started)/1000).toFixed(1)+' s\nCompletion is not yet confirmed.';};
+  tick(); const progress=setInterval(tick,250);
+  busy=true; buttons(); say('Processing the bounded test…');
+  try {
+    const body={track:await encoded($('track').files[0]),network:await encoded($('network').files[0]),automatic:$('automatic').checked,backend:$('backend').value};
+    job=await (await request('/api/process',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)})).json();
+    clearInterval(progress);
+    $('runState').textContent='COMPLETE — candidate ready to download';
+    $('runState').style.color='#62dfb1';
+    const r=job.report;
+    const metric=n=>typeof n==='number'?n.toFixed(3):'Not reported';
+    $('runSummary').textContent=r?[
+      'Backend: '+job.backend.toUpperCase(),
+      'Generations: '+r.generations_completed+' / '+r.generations_requested+' · Population: '+r.population,
+      'Server processing: '+metric(r.elapsed_seconds)+' s',
+      'Best score: '+metric(r.best_score)+' · Mean score: '+metric(r.mean_score),
+      'Best lap: '+(r.best_lap_seconds==null?'No completed lap':metric(r.best_lap_seconds)+' s'),
+      'Cars completing a lap: '+(r.lapped_cars??'Not reported'),
+      'Reported simulation ticks: '+(r.simulated_ticks??'Not reported')+' · Requested: '+r.requested_ticks,
+      'Candidate validated: '+(r.candidate_validated?'Yes':'No'),
+      'A completed test does not establish improved driving.'
+    ].join('\n'):'Server returned a candidate; detailed metrics unavailable.';
+    $('track').value=''; $('network').value='';
+    say('Result ready ('+job.backend.toUpperCase()+'). Inputs and intermediate worker files have been removed.');
+  } catch (error) {
+    clearInterval(progress);
+    $('runState').textContent='ERROR — no successful result confirmed';
+    $('runState').style.color='#ffb5a2';
+    $('runSummary').textContent='Elapsed: '+((performance.now()-started)/1000).toFixed(1)+' s\nNo downloadable result was received. A connection error does not prove the server stopped.';
+    say(error.message);
+  }
+  finally {clearInterval(progress);busy=false; buttons();}
+};
+$('download').onclick = async () => {
+  busy=true; buttons();
+  try {
+    const response=await request('/api/jobs/'+job.id+'/download',{method:'POST',headers:headers()});
+    const bytes=await response.arrayBuffer();
+    const digest=Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',bytes)),x=>x.toString(16).padStart(2,'0')).join('');
+    if (bytes.byteLength!==job.size || digest!==job.sha256) throw new Error('Result validation failed; no deletion acknowledgment sent. Use Delete now or await expiry.');
+    // The browser has the complete validated result. Disk-save success cannot be observed.
+    localResult=new Blob([bytes]); saveLocal();
+    const acknowledgment=await (await request('/api/jobs/'+job.id+'/ack',{method:'POST',headers:{...headers(),'Content-Type':'application/json'},body:JSON.stringify({receipt:response.headers.get('x-delivery-receipt')})})).json();
+    if (acknowledgment.deleted) { job=null; say('Result received by browser. Server result deleted. Save your local download; server retrieval is no longer available.'); }
+    else say('Result received by browser. Verify your saved file, then select Delete now; repeat downloads remain available until expiry.');
+  } catch (error) { say(error.message+' If receipt acknowledgment failed, use Delete now; automatic expiry still applies.'); }
+  finally {busy=false; buttons();}
+};
+$('erase').onclick=async()=>{
+  if(!confirm('Delete remaining server-side result and revoke download access? Local files are unaffected.'))return;
+  busy=true; buttons();
+  try {await request('/api/jobs/'+job.id,{method:'DELETE',headers:headers()}); job=null; say('Server result deleted. Local files are unaffected.');}
+  catch(error){say(error.message);}
+  finally {busy=false; buttons();}
+};
+setInterval(()=>{
+  if(!job){$('deadline').textContent='';return;}
+  const remaining=Math.max(0,Math.ceil(job.expires_at-Date.now()/1000));
+  $('deadline').textContent='Automatic expiry: '+new Date(job.expires_at*1000).toLocaleTimeString()+' · '+Math.floor(remaining/60)+'m '+remaining%60+'s remaining';
+  if(!remaining && !busy){job=null; buttons(); say('Result access has expired. Server cleanup runs independently of this browser.');}
+},1000);
+buttons();
+(async()=>{
+  try {
+    const capabilities=await (await request('/api/capabilities')).json();
+    $('gpuOption').disabled=!capabilities.gpu;
+    $('backendNote').textContent=capabilities.gpu?'CPU uses no GPU allowance. GPU requires available allowance. No automatic switching.':'CPU available. GPU is not connected on this deployment; no GPU allowance is needed for CPU.';
+    capabilitiesReady=true; buttons();
+  } catch(error) {say('Cannot connect to the service. Open the hosted app, not a downloaded HTML file.');}
+})();

delivery.py

@@ -0,0 +1,151 @@
+"""Process-local result delivery. No disk cache, public URLs, or background service.
+
+Run one ASGI worker. Restarts discard results. This does not promise physical
+memory erasure or control provider logs, swap, snapshots, or response buffers.
+"""
+import asyncio
+from contextlib import asynccontextmanager
+import hashlib
+import hmac
+import secrets
+import threading
+import time
+from fastapi import FastAPI, Header, HTTPException
+from fastapi.responses import Response
+from pydantic import BaseModel, Field
+
+class Unavailable(Exception): pass
+class CapacityExceeded(Exception): pass
+
+class ResultStore:
+    def __init__(self, clock=time.monotonic, wall_clock=time.time, max_bytes=64*1024*1024):
+        self.clock, self.wall_clock = clock, wall_clock
+        self.max_bytes = max_bytes
+        self.lock = threading.RLock()
+        self.jobs = {}
+
+    @property
+    def retained_bytes(self):
+        with self.lock: return sum(len(j['data']) for j in self.jobs.values())
+
+    def _delete(self, ident):
+        record = self.jobs.pop(ident)
+        record['data'][:] = b'\0'*len(record['data'])
+        record['data'].clear()
+
+    def expire(self):
+        with self.lock:
+            for ident in list(self.jobs):
+                if self.clock() >= self.jobs[ident]['deadline']: self._delete(ident)
+
+    def clear(self):
+        with self.lock:
+            for ident in list(self.jobs): self._delete(ident)
+
+    def publish(self, data, automatic=True):
+        if not isinstance(data, bytes) or not data or len(data)>4*1024*1024:
+            raise CapacityExceeded()
+        with self.lock:
+            self.expire()
+            if len(self.jobs)>=16 or self.retained_bytes+len(data)>self.max_bytes:
+                raise CapacityExceeded()
+            ident, key = secrets.token_urlsafe(24), secrets.token_urlsafe(32)
+            expires = self.wall_clock()+1800
+            self.jobs[ident] = dict(key=key, data=bytearray(data), automatic=automatic,
+                deadline=self.clock()+1800, expires_at=expires, delivered=False, receipt=None)
+            return dict(id=ident,key=key,expires_at=expires,automatic=automatic,
+                        sha256=hashlib.sha256(data).hexdigest(),size=len(data))
+
+    def _get(self, ident, key):
+        self.expire()
+        record = self.jobs.get(ident)
+        if not record or not hmac.compare_digest(record['key'],key): raise Unavailable()
+        return record
+
+    def status(self, ident, key):
+        with self.lock:
+            r = self._get(ident,key)
+            return dict(expires_at=r['expires_at'],automatic=r['automatic'],delivered=r['delivered'])
+
+    def download(self, ident, key):
+        with self.lock:
+            r = self._get(ident,key)
+            if r['automatic'] and r['delivered']: raise Unavailable()
+            r['delivered'] = True
+            r['receipt'] = secrets.token_urlsafe(32)
+            return bytes(r['data']), r['receipt']
+
+    def acknowledge(self, ident, key, receipt):
+        with self.lock:
+            r = self._get(ident,key)
+            if not r['receipt'] or not hmac.compare_digest(r['receipt'],receipt): raise Unavailable()
+            if r['automatic']:
+                self._delete(ident)
+                return dict(deleted=True)
+            return dict(deleted=False,expires_at=r['expires_at'])
+
+    def delete(self, ident, key):
+        with self.lock:
+            self._get(ident,key)
+            self._delete(ident)
+            return dict(deleted=True)
+
+class Acknowledgment(BaseModel):
+    receipt: str = Field(min_length=1,max_length=128)
+
+def create_api(store=None):
+    store = store if store is not None else ResultStore()
+    @asynccontextmanager
+    async def lifespan(app):
+        async def expiry():
+            while True:
+                await asyncio.sleep(1)
+                store.expire()
+        task = asyncio.create_task(expiry())
+        try: yield
+        finally:
+            task.cancel()
+            try: await task
+            except asyncio.CancelledError: pass
+            store.clear()
+
+    app = FastAPI(lifespan=lifespan,docs_url=None,redoc_url=None,openapi_url=None)
+    app.state.results = store
+    @app.middleware('http')
+    async def headers(request,call_next):
+        response = await call_next(request)
+        response.headers['Cache-Control']='no-store'
+        response.headers['Referrer-Policy']='no-referrer'
+        response.headers['X-Content-Type-Options']='nosniff'
+        return response
+
+    def key(authorization):
+        if not authorization or not authorization.startswith('Bearer '):
+            raise HTTPException(404,'Job unavailable')
+        value = authorization[7:]
+        if not value.isascii() or len(value)>128: raise HTTPException(404,'Job unavailable')
+        return value
+
+    def call(fn,*args):
+        try: return fn(*args)
+        except Unavailable: raise HTTPException(404,'Job unavailable') from None
+
+    @app.get('/api/jobs/{ident}')
+    def status(ident:str,authorization:str|None=Header(default=None)):
+        return call(store.status,ident,key(authorization))
+
+    @app.post('/api/jobs/{ident}/download')
+    def download(ident:str,authorization:str|None=Header(default=None)):
+        data,receipt = call(store.download,ident,key(authorization))
+        return Response(data,media_type='application/octet-stream',headers={
+            'Content-Disposition':'attachment; filename="candidate.evolution"',
+            'X-Delivery-Receipt':receipt})
+
+    @app.post('/api/jobs/{ident}/ack')
+    def ack(ident:str,body:Acknowledgment,authorization:str|None=Header(default=None)):
+        return call(store.acknowledge,ident,key(authorization),body.receipt)
+
+    @app.delete('/api/jobs/{ident}')
+    def delete(ident:str,authorization:str|None=Header(default=None)):
+        return call(store.delete,ident,key(authorization))
+    return app

index.html

@@ -1,138 +1,23 @@
-<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>TAO · Driving Lab</title>
+<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>AI Learns To Drive — HF integration test</title>
 <style>
-:root{color-scheme:dark;font:16px system-ui;background:#0c1420;color:#e5edf5}body{max-width:1320px;margin:auto;padding:28px}h1{font-size:32px;margin:0}h2{font-size:21px;margin:0 0 14px}small,.hint{color:#a2b4c8;line-height:1.6}.grid{display:grid;grid-template-columns:minmax(350px,430px) minmax(0,1fr);gap:24px}.card{background:#152233;border:1px solid #2a3d52;border-radius:16px;padding:22px;margin-top:20px}label{display:block;margin:12px 0 5px}input,select,button{font:inherit;background:#0c1725;color:#e5edf5;border:1px solid #49627c;border-radius:7px;padding:9px}input[type=number],select{width:100%;box-sizing:border-box}input[type=file]{max-width:100%;box-sizing:border-box}button{cursor:pointer}button.primary{background:#62dfb1;color:#102522;font-weight:700}button:disabled{opacity:.4;cursor:default}.row{display:grid;grid-template-columns:1fr 1fr;gap:15px}.reward{display:grid;grid-template-columns:1.7fr 1fr 70px 30px;gap:5px;margin:8px 0}.reward input{width:70px;box-sizing:border-box}a{color:#7ce4c3}canvas{width:100%;background:#09111b;border-radius:10px}#status{white-space:pre-wrap;line-height:1.7}table{width:100%;text-align:left;border-collapse:collapse;font-size:14px}td,th{padding:9px;border-bottom:1px solid #2a3d52}.pill{display:inline-block;background:#284539;border-radius:20px;padding:5px 12px;color:#91efc6;margin:6px 0}#error{color:#ffb5a2;white-space:pre-wrap}.toolbar{display:flex;gap:12px;align-items:center;flex-wrap:wrap;padding-bottom:16px;border-bottom:1px solid #2a3d52;margin-bottom:15px}.run-card{position:sticky;top:20px}details{margin-top:18px;border-top:1px solid #2a3d52;padding-top:14px}summary{cursor:pointer;font-weight:600;color:#c6d9e9}details[open]>summary{margin-bottom:12px}[hidden]{display:none!important}#map_note{font-size:14px}#runs{max-height:380px;overflow:auto}.table-scroll{overflow:auto}@media(max-width:850px){.grid{grid-template-columns:1fr}#drive .grid>section:nth-child(2){order:-1}.run-card{position:static}body{padding:16px}}
-.tabs{display:flex;flex-wrap:wrap;gap:10px;margin:20px 0}.tabs button[aria-selected=true]{background:#62dfb1;color:#102522}.library{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:20px}.library input[type=text]{width:100%;box-sizing:border-box}.queue-row{display:flex;gap:8px;margin:8px 0}.queue-row select{flex:1}.pane{min-width:0}</style>
-<header><h1>TAO · CPU Lab</h1><p class="hint">Private CPU comparison Space · uploaded networks run on Hugging Face CPU hardware. Download receipts before a restart; container storage is temporary.</p></header>
-<nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section><div class="card"><h2>Simulation</h2><span class="pill">Formula · steering + acceleration</span>
-<label for="backend">Simulation engine</label><select id="backend"><option value="github">GitHub simulator · Native CPU</option></select>
-<label><input type="radio" name="network_source" id="source_upload" checked> Use uploaded network</label><label for="file">Upload a network (.evolution)</label><input id="file" type="file" accept=".evolution"><label><input type="radio" name="network_source" id="source_latest"> Use latest completed candidate</label><p><button id="sample">Load latest completed candidate</button></p><label id="editor_source_group" hidden><input type="radio" name="network_source" id="source_editor"> Use network from editor</label><details><summary>Saved cars · common ALD folder</summary><label><input type="radio" name="network_source" id="source_library"> Use saved car</label><select id="library_car" aria-label="Saved car"></select><button id="library_load">Load saved car</button></details><label><input id="require_standard" type="checkbox" checked> Require standard game network</label><small>Uncheck only for explicitly modified research networks. Engine compatibility is checked separately.</small><p><small id="network">No network selected</small></p><p id="network_contract" class="hint"></p>
-<label for="track">Track</label><select id="track"></select><small id="track_support"></small>
-<label for="mode">Activity</label><select id="mode"><option value="replay">Drive / evaluate frozen network</option><option value="train">Train a population</option></select>
-<label for="seconds">Seconds per attempt</label><input id="seconds" type="number" min="1" max="300" value="60"><small>1–300 simulated seconds. Start with 10–15 when learning, then extend.</small>
-<div id="training_controls" hidden>
-<div class="row"><div><label for="population">Population</label><input id="population" type="number" min="1" max="128" value="8"><small>1–128; native 64 or Godot 8–16 initially.</small></div><div><label for="generations">Generations</label><input id="generations" type="number" min="1" max="1000" value="30"><small>1–1,000; try 20–50 before review.</small></div></div>
-<label id="mutation_label" for="mutation">Mutation strength (Gaussian σ)</label><input id="mutation" type="number" min="0" max="4.2" step="0.01" value="0.1"><small>0–4.2; native 0.3 → 0.1 → 0.05. Native rates and Godot σ are different scales.</small>
-<details id="native_settings" hidden><summary>Native evolution settings</summary>
-<label for="preset">Recommended starting recipe</label><select id="preset"><option value="custom">Custom / keep current settings</option><option value="starter">First laps · mutation 0.3, decay 0.0005</option><option value="explore">Wide exploration · mutation 0.5, decay 0.0005</option><option value="refine">Established driver · mutation 0.1, decay 0.0001</option><option value="speed">Lap refinement · mutation 0.05, decay 0</option></select><small>Starting hypotheses, not proven optimums. Change stages after stable improvement.</small>
-<label for="schedule">Mutation schedule for this run</label><select id="schedule"><option value="fixed">Fixed · change stages manually</option><option value="linear">Linear start → end</option><option value="geometric">Geometric start → end</option></select>
-<div id="end_rate_group" hidden><label for="mutation_end">End mutation rate</label><input id="mutation_end" type="number" min="0.000001" max="4.2" step="0.01" value="0.1"><small>Both schedule rates must be positive.</small></div>
-<label><input id="adaptive_mutation" type="checkbox"> Adaptive mutation · normalize for network size</label><small>Architecture scaling, not progress-aware adjustment. Decay is fixed; adaptive decay isn't exposed by this CLI.</small>
-<label for="selection">Parent selection</label><select id="selection"><option value="best">Best</option><option value="tournament">Tournament</option><option value="roulette">Roulette</option></select>
-<div class="row"><div><label for="parents">Selected parents</label><input id="parents" type="number" min="1" value="1"><small>1–population; start with 3.</small></div><div><label for="elite">Preserved elites</label><input id="elite" type="number" min="0" value="1"><small>0–population; start with 1.</small></div></div>
-<label for="crossover">Crossover</label><select id="crossover"><option value="none">Off</option><option value="single_point">Single point</option><option value="uniform">Uniform</option></select>
-<label for="decay">Weight decay</label><input id="decay" type="number" min="0" max="1" step="0.0001" value="0"><small>Allowed 0–1; suggested 0–0.001. Decay 0.05 shrinks children by 5%.</small>
-</details>
-<details id="reward_settings"><summary>Rewards · presets and up to five metrics</summary>
-<label for="reward_preset">Reward preset</label><select id="reward_preset"><option value="custom">Custom</option><option value="distance">First laps · distance only</option><option value="center">Your starter mix · center, clearance, collisions</option><option value="clean">Clean driving · distance + collision penalty</option><option value="lap">Lap refinement · best lap only</option><option value="multilap">Endurance · distance only, longer horizon</option></select><p id="reward_preset_note" class="hint"></p>
-<div id="rewards"></div><p id="budget" class="hint"></p><button id="add">+ Add reward</button><p id="guidance" class="hint"></p><small>Weights −100…+100; absolute shares normalize to 100%. Five distinct metrics maximum. Braking is zero for this two-output network.</small>
-</details></div>
-<details id="run_settings"><summary>Run settings · timing and elimination</summary><div class="row"><div><label for="control_hz">Decisions per second</label><select id="control_hz"><option>60</option><option>30</option><option>15</option></select></div><div><label for="workers">Parallel simulations</label><select id="workers"><option>1</option><option selected>2</option><option>3</option><option>4</option></select></div></div><small>Physics always 60 Hz. Start with 2 workers; frozen replay uses one car.</small><div id="seed_group"><label for="seed">Random seed</label><input id="seed" type="number" min="0" max="2147483647" value="42105"></div><label><input id="collision" type="checkbox"> Eliminate on wall contact</label><label><input id="idle" type="checkbox"> Eliminate when stuck</label></details>
-</div>
-<div class="card"><details id="comparison"><summary>Website comparison and track downloads</summary><p><a href="https://drivinglab.jectrum.de/" target="_blank" rel="noopener">Open Drive Lab ↗</a></p><p class="hint">Optional website WebGPU comparison. Our local engines use CPU here; native WebSocket server port 47800. No recipes are sent there by this dashboard.</p><details><summary>All track downloads</summary><div id="track_downloads"></div></details></details></div></section>
-<section><div class="card run-card"><h2>Run & results</h2><div class="toolbar"><button class="primary" id="start">Start</button><button id="stop" disabled>Stop run</button><button id="reset">Reset form</button><a id="download" hidden>Download candidate .evolution</a></div><div id="error" role="alert"></div><div id="status">Ready. Select a network to begin.</div><details id="run_notes" hidden><summary>Run details</summary><p id="run_note" class="hint"></p></details><div id="artifacts"></div>
-<section id="map_panel" style="margin-top:18px"><h2>Selected track & terrain</h2><div id="map_legend" class="hint"></div><canvas id="map" width="800" height="550"></canvas><p id="map_note" class="hint">Choose a track to preview its layout.</p></section>
-<details id="history_panel"><summary>Generation results</summary><div class="table-scroll"><table><thead><tr><th>Generation</th><th>Net laps (ours)</th><th>Distance (native)</th><th>Lap / circuit</th><th>Contacts</th></tr></thead><tbody id="history"></tbody></table></div></details>
-<details id="saved_panel"><summary>Saved runs</summary><div id="runs"></div><small>Exact inputs and settings are kept with each run. Original-game validation remains separate.</small></details>
-</div></section></div>
-</div>
-<section id="training" class="pane" hidden><div class="card"><h2>Training settings</h2><p class="hint">Choose the engine and track on Drive & view. Save settings and rewards separately, then combine their permanent references into a run.</p><div id="training_home"></div><div id="timing_home"></div></div><div id="library_status" role="status"></div><p><button id="refresh_presets">Refresh library</button> <a href="/api/presets" download="tao-preset-library.json">Download preset library</a></p><div class="library" id="libraries"></div></section>
-<section id="batch" class="pane" hidden><div class="card"><h2>Training batches · A–J</h2><label for="batch_slot">Batch slot</label><select id="batch_slot"></select><label for="batch_name">Display name</label><input id="batch_name" type="text" maxlength="80" value="My curriculum"><label><input id="carry" type="checkbox" checked> Continue from the previous run’s candidate</label><p class="hint">Unchecked: each run starts from the original uploaded network. Repeated run references are allowed. Recipes freeze when the batch starts.</p><div id="queue"></div><button id="queue_add">+ Add run</button><div class="toolbar"><button id="batch_save">Save batch</button><button id="batch_load">Load batch</button><button class="primary" id="batch_start">Start saved batch</button><button id="batch_stop" disabled>Stop batch</button></div><div id="batch_status" role="status">No batch selected.</div><div id="batch_history"></div><div id="preset_message" role="status"></div></div></section>
-<section id="editor" class="pane" hidden><div class="card"><h2>Network editor</h2><p class="hint">An original editor inspired by <a href="https://the-mars-guy.github.io/AI-Learns-To-Drive-Tool/" target="_blank" rel="noopener">Mars’s network creator</a>. Formula Beginner inputs and steering/acceleration outputs remain fixed here. You can create and download other hidden-layer shapes; the trainer accepts Formula networks with steering/acceleration outputs. Native CPU supports additional sensors; Godot currently supports raycasts + speed.</p><div class="toolbar"><label for="editor_file">Load an existing .evolution file</label><input id="editor_file" type="file" accept=".evolution"><button id="editor_import">Inspect selected network</button><button id="editor_create">Create fresh network</button><button id="editor_apply">Use edited network</button><a id="editor_download" hidden download>Download .evolution</a></div><div class="row"><div><label for="editor_name">Network name</label><input id="editor_name" type="text" maxlength="80" value="TAO fresh network"><label for="editor_shape">Layer sizes</label><input id="editor_shape" type="text" value="6,4,2"><small>6 inputs → hidden layers of 1–64 nodes → 2 outputs. Up to 20 layers.</small></div><div><label for="editor_seed">Initialization seed</label><input id="editor_seed" type="number" min="0" max="2147483647" value="42105"><label><input id="editor_xavier" type="checkbox" checked> Xavier uniform weights</label><label><input id="editor_bias" type="checkbox"> Xavier uniform biases</label><small>Unchecked: zeros. Biases default to zero.</small></div></div><p id="editor_status" role="status">Create a fresh network or inspect the selected source.</p><p id="editor_metadata" class="hint"></p><p id="editor_legality" class="hint"></p><details id="editor_history_panel"><summary>Training history · recorded generations</summary><div class="table-scroll"><table><thead><tr><th>Record</th><th>Time</th><th>Mutation</th><th>Best score</th><th>Best lap</th></tr></thead><tbody id="editor_history"></tbody></table></div><details><summary>Full saved training metadata</summary><pre id="editor_stats"></pre></details></details><canvas id="network_map" width="1100" height="450"></canvas><details id="weight_values"><summary>Individual weight and bias values</summary><div class="table-scroll" style="max-height:420px;overflow:auto"><table><thead><tr><th>Connection / bias</th><th>Value</th></tr></thead><tbody id="editor_parameters"></tbody></table></div></details><details><summary>Weights, biases and input contract</summary><pre id="editor_contract"></pre><label for="editor_json">NeuralNetwork JSON · editable weights and biases</label><textarea id="editor_json" rows="16" style="width:100%;box-sizing:border-box;background:#0c1725;color:#e5edf5"></textarea></details></div></section><script>
-const $=id=>document.getElementById(id);let trackCatalog=[],catalog=[],data=null,job=null,lastPath=null,mapRequest=0,activeRun=false;const json=async(url,opts)=>{let r=await fetch(url,opts),x=await r.json();if(!r.ok)throw Error(x.error||'Request failed');return x};
-function reward(metric='TotalScore',type='Default',weight=100){if($('rewards').children.length>=5)return;let used=[...$('rewards').children].map(r=>r.children[0].value);if(used.includes(metric))metric=catalog.find(r=>!used.includes(r.metric)).metric;let row=document.createElement('div');row.className='reward';let sel=document.createElement('select'),typ=document.createElement('select'),w=document.createElement('input'),del=document.createElement('button');sel.setAttribute('aria-label','Reward metric');typ.setAttribute('aria-label','Reward averaging');w.setAttribute('aria-label','Reward weight');catalog.forEach(r=>sel.add(new Option(r.label,r.metric)));sel.value=metric;w.type='number';w.min=-100;w.max=100;w.value=weight;del.textContent='×';del.setAttribute('aria-label','Remove reward');function change(){let r=catalog.find(r=>r.metric===sel.value);typ.replaceChildren();r.types.forEach(t=>typ.add(new Option(t,t)));$('guidance').textContent=r.description+' '+r.game_sign_guidance;budget();}sel.onchange=()=>{customReward();change()};del.onclick=()=>{customReward();row.remove();budget()};w.oninput=()=>{customReward();budget()};typ.onchange=()=>{customReward();budget()};row.append(sel,typ,w,del);$('rewards').append(row);change();typ.value=type;budget();}
-function customReward(){$('reward_preset').value='custom';$('reward_preset_note').textContent='Custom reward mix; the percentages below show its effective allocation.'}
-function budget(){let rows=[...$('rewards').children],sum=rows.reduce((a,r)=>a+Math.abs(Number(r.children[2].value)),0);rows.forEach(row=>[...row.children[0].options].forEach(o=>o.disabled=rows.some(other=>other!==row&&other.children[0].value===o.value)));$('add').disabled=rows.length>=5;$('budget').textContent=rows.length+'/5 slots · absolute weight total '+sum+' → 100% allocation: '+rows.map(r=>r.children[0].selectedOptions[0].text+' '+(sum?100*Number(r.children[2].value)/sum:0).toFixed(1)+'%').join(' · ')}
-function support(){
- const native=$('backend').value==='github',train=$('mode').value==='train';
- const r=trackCatalog.find(x=>x.name===$('track').value);
- $('track_support').textContent=native?'Local native CPU · all-track training and replay; Formula vehicle.':(r?.ours_training?'Godot · A01 training and replay.':'Godot · replay only here; native engine supports training.');
- $('training_controls').hidden=!train;$('seed_group').hidden=!train;
- $('native_settings').hidden=!(native&&train);
- if(!native){$('adaptive_mutation').checked=false;$('schedule').value='fixed';$('native_settings').open=false;}
- ['schedule','mutation_end','adaptive_mutation','selection','parents','elite','crossover','decay','preset'].forEach(k=>$(k).disabled=!(native&&train));
- $('end_rate_group').hidden=!(native&&train&&$('schedule').value!=='fixed');
- $('mutation_label').textContent=native?'Mutation rate (native)':'Mutation strength (Gaussian σ)';
- $('start').textContent=train?'Start training':'Run frozen network';
- if(!activeRun&&(!data||train))$('map_panel').open=false;
-}
-function applyRewardPreset(k){
- if(k==='custom')return;
- const recipes={distance:[['TotalScore','Default',100]],center:[['TotalScore','Default',100],['TotalDistanceFromCenter','Average',-60],['TotalDistanceFromWall','Average',10],['CollisionCount','Default',-100],['BestLapPerformance','Default',5]],clean:[['TotalScore','Default',100],['CollisionCount','Default',-30]],lap:[['BestLapPerformance','Default',100]],multilap:[['TotalScore','Default',100]]};
- $('rewards').replaceChildren();recipes[k].forEach(row=>reward(...row));$('reward_preset').value=k;
- $('reward_preset_note').textContent={distance:'Learn forward progress before optimizing speed.',center:'Your five-metric starter mix. Center and clearance can conflict with tight racing lines; relax them later.',clean:'Distance stays dominant; collisions carry a smaller penalty.',lap:'Use after laps are reliable. Faster completed laps lead; incomplete laps may provide little selection signal.',multilap:'Distance rewards sustained progress. Set the horizon long enough for multiple laps; this preset does not change timing.'}[k];
-}
-$('reward_preset').onchange=()=>applyRewardPreset($('reward_preset').value);
-$('mode').onchange=()=>{support();if(data&&$('mode').value==='replay')$('map_panel').open=true;};
-$('schedule').onchange=support;
-$('track').onchange=()=>{support();draw(null,$('track').value);};
-$('preset').onchange=()=>{let k=$('preset').value;if(k==='custom')return;$('backend').value='github';$('mode').value='train';$('population').value=64;$('generations').value=30;$('parents').value=3;$('elite').value=1;$('selection').value='best';$('crossover').value='none';$('schedule').value='fixed';$('adaptive_mutation').checked=false;$('mutation').value={starter:.3,explore:.5,refine:.1,speed:.05}[k];$('decay').value={starter:.0005,explore:.0005,refine:.0001,speed:0}[k];$('idle').checked=true;$('collision').checked=k==='refine'||k==='speed';$('seconds').value=k==='starter'||k==='explore'?15:90;applyRewardPreset(k==='speed'?'lap':'distance');support();$('backend').onchange()};
-let editorData=null,editorUrl=null;
-async function readFile(){let f=$('file').files[0];if(!f)throw Error('Browse for a network first');return await new Promise((resolve,reject)=>{let reader=new FileReader();reader.onerror=()=>reject(Error('Could not read the selected file'));reader.onload=()=>resolve({data:reader.result.split(',')[1],filename:f.name});reader.readAsDataURL(f);});}
-async function readSource(){let x;if($('source_library').checked)x=await json('/api/library/'+$('library_car').value);else if($('source_latest').checked)x=await json('/api/latest');else if($('source_editor').checked){if(!editorData)throw Error('Apply the editor network first');x=editorData;}else x=await readFile();data=x.data;$('network').textContent=x.filename;let info=await json('/api/network/editor',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'inspect',data})});$('network_contract').textContent='Game rules: '+info.legality.classification+' · '+[...info.legality.errors,...info.legality.warnings].join(' · ')+' · Shape '+info.network.Shape.join(' → ')+' · Native: '+info.compatibility.github+' · Godot: '+info.compatibility.ours;return data;}
-$('add').onclick=()=>{customReward();reward()};$('sample').onclick=async()=>{try{$('source_latest').checked=true;await readSource();$('error').textContent='';$('map_panel').open=$('mode').value==='replay';draw(null,$('track').value);}catch(e){$('error').textContent=e.message}};
-$('file').onchange=async()=>{try{$('source_upload').checked=true;await readSource();$('error').textContent='';$('map_panel').open=$('mode').value==='replay';draw(null,$('track').value)}catch(e){$('error').textContent=e.message}};
-['source_upload','source_latest','source_editor','source_library'].forEach(k=>$(k).onchange=async()=>{try{await readSource();$('error').textContent=''}catch(e){$('network').textContent='Selected source not loaded';$('error').textContent=e.message}});
-$('library_load').onclick=async()=>{try{$('source_library').checked=true;await readSource();$('error').textContent='';}catch(e){$('error').textContent=e.message}};
-function showEditor(x){let n=x.network;$('editor_json').value=JSON.stringify(n,null,2);$('editor_shape').value=n.Shape.join(',');$('editor_status').textContent='Shape '+n.Shape.join(' → ')+' · '+n.Weights.reduce((sum,w,i)=>sum+w.flat().length+n.Biases[i].length,0)+' parameters · '+'Shape parsed · engine compatibility depends on vehicle, sensors and outputs';if(x.name)$('editor_name').value=x.name;showEditorInfo(x);if(x.sensors)$('editor_contract').textContent=JSON.stringify({sensors:x.sensors,outputs:x.outputs,vehicle:x.vehicle},null,2);drawNetwork(n);}
-function drawNetwork(n){let cv=$('network_map'),ctx=cv.getContext('2d');ctx.clearRect(0,0,cv.width,cv.height);let points=n.Shape.map((count,l)=>Array.from({length:count},(_,i)=>[45+l*(cv.width-90)/(n.Shape.length-1),35+(i+.5)*(cv.height-70)/count]));n.Weights.forEach((w,l)=>w.forEach((row,i)=>row.forEach((v,j)=>{ctx.strokeStyle=v<0?'#f27676':'#62dfb1';ctx.globalAlpha=Math.min(.8,.08+Math.abs(v)*.35);ctx.lineWidth=Math.min(4,.4+Math.abs(v));ctx.beginPath();ctx.moveTo(...points[l][i]);ctx.lineTo(...points[l+1][j]);ctx.stroke();})));ctx.globalAlpha=1;points.forEach(layer=>layer.forEach(([x,y])=>{ctx.fillStyle='#0c1725';ctx.strokeStyle='#e5edf5';ctx.beginPath();ctx.arc(x,y,Math.min(7,140/layer.length),0,Math.PI*2);ctx.fill();ctx.stroke();}));}
-function showEditorInfo(x){let generations=x.stats?.Generations||[],times=generations.map(g=>g.Time).filter(v=>typeof v==='number'&&Number.isFinite(v));let total=times.reduce((a,b)=>a+b,0),duration=Math.floor(total/3600)+'h '+Math.floor(total%3600/60)+'m '+(total%60).toFixed(1)+'s';$('editor_metadata').textContent='Vehicle: '+['Formula','Rally','Snowmobile','Truck'][x.vehicle]+' · '+generations.length+' saved generation records · recorded training time '+duration+' ('+total.toFixed(1)+' s)'+(times.length!==generations.length?' (some record times missing)':'')+' · '+(x.snapshots?.length||0)+' snapshots';$('editor_legality').textContent=x.legality?('Game rules: '+x.legality.classification+' · '+[...x.legality.errors,...x.legality.warnings].join(' · ')):'';$('editor_stats').textContent=JSON.stringify({stats:x.stats,snapshots:x.snapshots||[]},null,2);$('editor_history').replaceChildren();generations.forEach((g,i)=>{let row=document.createElement('tr');[i+1,g.Time==null?'—':g.Time+' s',g.MutationRate??'—',g.BestScore??'—',g.BestLapTime??'—'].forEach(v=>{let td=document.createElement('td');td.textContent=v;row.append(td)});$('editor_history').append(row)});$('editor_parameters').replaceChildren();let n=x.network;function param(label,path,value){let row=document.createElement('tr'),cell=document.createElement('td'),val=document.createElement('td'),input=document.createElement('input');cell.textContent=label;input.type='number';input.step='any';input.value=value;input.setAttribute('aria-label',label);input.oninput=()=>{let edited=JSON.parse($('editor_json').value),target=edited;path.slice(0,-1).forEach(k=>target=target[k]);target[path.at(-1)]=Number(input.value);$('editor_json').value=JSON.stringify(edited,null,2);drawNetwork(edited)};val.append(input);row.append(cell,val);$('editor_parameters').append(row);}n.Weights.forEach((w,l)=>w.forEach((r,i)=>r.forEach((v,j)=>param('Layer '+(l+1)+' · input '+i+' → node '+j,['Weights',l,i,j],v))));n.Biases.forEach((b,l)=>b.forEach((v,j)=>param('Layer '+(l+1)+' · node '+j+' bias',['Biases',l,j],v)));}
-$('editor_file').onchange=async()=>{try{let f=$('editor_file').files[0];if(!f)return;let bytes=await f.arrayBuffer(),encoded=btoa(Array.from(new Uint8Array(bytes),v=>String.fromCharCode(v)).join(''));data=encoded;editorData={data,filename:f.name};showEditor(await editorRequest('inspect'));$('editor_status').textContent+=' · Loaded '+f.name;}catch(e){$('editor_status').textContent=e.message}};
-async function editorRequest(action,extra={}){return await json('/api/network/editor',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action,data,...extra})});}
-$('editor_import').onclick=async()=>{try{await readSource();editorData={data,filename:$('network').textContent};showEditor(await editorRequest('inspect'));}catch(e){$('editor_status').textContent=e.message}};
-$('editor_create').onclick=async()=>{try{let x=await editorRequest('create',{data:null,shape:$('editor_shape').value.split(',').map(Number),seed:Number($('editor_seed').value),xavier:$('editor_xavier').checked,xavier_bias:$('editor_bias').checked,name:$('editor_name').value});editorData=x;showEditor(x);editorDownload(x);}catch(e){$('editor_status').textContent=e.message}};
-function editorDownload(x){if(editorUrl)URL.revokeObjectURL(editorUrl);editorUrl=URL.createObjectURL(new Blob([Uint8Array.from(atob(x.data),c=>c.charCodeAt(0))],{type:'application/octet-stream'}));$('editor_download').href=editorUrl;$('editor_download').download=x.filename;$('editor_download').hidden=false;}
-$('editor_apply').onclick=async()=>{try{let x=await editorRequest('save',{data:editorData?.data||data,network:JSON.parse($('editor_json').value),name:$('editor_name').value});editorData=x;data=x.data;showEditor(x);editorDownload(x);$('editor_source_group').hidden=false;$('source_editor').checked=true;$('network').textContent=x.filename;$('editor_status').textContent+=' · Applied as active source';}catch(e){$('editor_status').textContent=e.message}};
-$('start').onclick=async()=>{try{$('error').textContent='';await readSource();let c=readConfig();let x=await json('/api/run',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({config:c,data})});job=x.id;lastPath=null;activeRun=true;$('history_panel').open=c.mode==='train';$('map_panel').open=c.mode==='replay';$('download').hidden=true;await poll();}catch(e){$('error').textContent=e.message}};
-
-function readConfig(){let c={};['seconds','population','generations','workers','control_hz','seed','mutation','parents','elite','decay','mutation_end'].forEach(k=>c[k]=Number($(k).value));['mode','track','backend','selection','crossover','schedule'].forEach(k=>c[k]=$(k).value);['collision','idle','adaptive_mutation','require_standard'].forEach(k=>c[k]=$(k).checked);if(c.backend==='ours'){c.adaptive_mutation=false;c.schedule='fixed';c.decay=0;c.selection='best';c.parents=1;c.elite=1;c.crossover='none';}if(c.mode==='replay'){c.mutation=0;c.decay=0;c.adaptive_mutation=false;c.schedule='fixed';c.population=1;c.generations=1;c.parents=1;c.elite=1;c.mutation_end=0;}c.rewards=[...$('rewards').children].map(r=>({metric:r.children[0].value,type:r.children[1].value,weight:Number(r.children[2].value)}));if(c.mode==='replay')c.rewards=[{metric:'TotalScore',type:'Default',weight:100}];return c;}
-let book=null,batchId=null;
-function tab(id){if(id==='training'){$('mode').value='train';support();}document.querySelectorAll('.pane').forEach(p=>p.hidden=p.id!==id);document.querySelectorAll('[data-tab]').forEach(b=>b.setAttribute('aria-selected',String(b.dataset.tab===id)));}
-document.querySelectorAll('[data-tab]').forEach(b=>b.onclick=()=>tab(b.dataset.tab));
-$('training_home').append($('training_controls'));$('timing_home').append($('run_settings'));
-const slots='ABCDEFGHIJ'.split('');
-function fillSlots(sel,family){let old=sel.value;sel.replaceChildren(...slots.map(k=>new Option(k+' · '+(book?.[family]?.[k]?.name||'Empty'),k)));if(old)sel.value=old;}
-function setConfig(c){Object.entries(c).forEach(([k,v])=>{if(k==='rewards'||!$(k))return;if(typeof v==='boolean')$(k).checked=v;else $(k).value=v;});support();draw(null,$('track').value);}
-function setRewards(rows){$('rewards').replaceChildren();rows.forEach(r=>reward(r.metric,r.type,r.weight));customReward();}
-function refreshBook(){['settings','rewards','runs'].forEach(f=>fillSlots($(f+'_slot'),f));fillSlots($('run_settings_ref'),'settings');fillSlots($('run_rewards_ref'),'rewards');fillSlots($('batch_slot'),'batches');document.querySelectorAll('.queue-row select').forEach(s=>fillSlots(s,'runs'));}
-async function saveSlot(f,record){book=await json('/api/presets',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({revision:book.revision,family:f,slot:$(f==='batches'?'batch_slot':f+'_slot').value,record})});refreshBook();$('preset_message').textContent='Saved · library revision '+book.revision;$('error').textContent='';$('library_status').textContent='Saved · library revision '+book.revision;}
-function notice(e){$('preset_message').textContent=e.message;$('error').textContent=e.message;}
-function buildLibraries(){['settings','rewards','runs'].forEach(f=>{let card=document.createElement('div');card.className='card';let h=document.createElement('h2');h.textContent={settings:'Settings slots',rewards:'Reward slots',runs:'Training run slots'}[f];card.append(h);let sel=document.createElement('select');sel.id=f+'_slot';sel.setAttribute('aria-label',f+' slot');card.append(sel);let name=document.createElement('input');name.id=f+'_name';name.type='text';name.maxLength=80;name.placeholder='Display name';name.setAttribute('aria-label',f+' display name');card.append(name);if(f==='runs'){['settings','rewards'].forEach(t=>{let label=document.createElement('label');label.textContent=t+' reference';label.htmlFor='run_'+t+'_ref';let ref=document.createElement('select');ref.id='run_'+t+'_ref';card.append(label,ref);});}let save=document.createElement('button'),load=document.createElement('button');save.textContent='Save slot';load.textContent='Load slot';save.onclick=async()=>{try{let record={name:name.value};if(f==='settings'){record.config=readConfig();record.config.mode='train';}if(f==='rewards')record.rows=[...$('rewards').children].map(r=>({metric:r.children[0].value,type:r.children[1].value,weight:Number(r.children[2].value)}));if(f==='runs'){record.settings=$('run_settings_ref').value;record.rewards=$('run_rewards_ref').value;}await saveSlot(f,record);}catch(e){notice(e)}};load.onclick=()=>{try{let r=book[f][sel.value];if(!r)throw Error('This slot is empty');name.value=r.name;if(f==='settings')setConfig(r.config);if(f==='rewards')setRewards(r.rows);if(f==='runs'){$('run_settings_ref').value=r.settings;$('run_rewards_ref').value=r.rewards;setConfig(book.settings[r.settings].config);setRewards(book.rewards[r.rewards].rows);} }catch(e){notice(e)}};sel.onchange=()=>{name.value=book[f][sel.value]?.name||'';};card.append(save,load);$('libraries').append(card);});}
-function queueRow(slot='A'){let row=document.createElement('div');row.className='queue-row';let sel=document.createElement('select');sel.setAttribute('aria-label','Queued training run');fillSlots(sel,'runs');sel.value=slot;let del=document.createElement('button');del.textContent='Remove';del.onclick=()=>row.remove();let up=document.createElement('button'),down=document.createElement('button');up.textContent='↑';down.textContent='↓';up.setAttribute('aria-label','Move run earlier');down.setAttribute('aria-label','Move run later');up.onclick=()=>{if(row.previousElementSibling)row.before(row.previousElementSibling);};down.onclick=()=>{if(row.nextElementSibling)row.after(row.nextElementSibling);};row.append(sel,up,down,del);$('queue').append(row);}
-$('refresh_presets').onclick=async()=>{book=await json('/api/presets');refreshBook();$('library_status').textContent='Loaded revision '+book.revision;};
-$('reset').onclick=()=>{if(activeRun)return notice(Error('Finish or stop the active run before resetting'));$('mode').value='replay';$('backend').value='github';$('track').value='A01 Beginner';$('seconds').value=60;$('population').value=8;$('generations').value=30;$('mutation').value=.1;$('parents').value=1;$('elite').value=1;$('workers').value=2;$('seed').value=42105;$('control_hz').value=60;$('collision').checked=false;$('idle').checked=false;$('decay').value=0;$('adaptive_mutation').checked=false;$('schedule').value='fixed';applyRewardPreset('center');support();draw(null,$('track').value);};
-$('queue_add').onclick=()=>{if($('queue').children.length<100)queueRow();};
-$('batch_save').onclick=async()=>{try{await saveSlot('batches',{name:$('batch_name').value,carry:$('carry').checked,runs:[...$('queue').children].map(r=>r.children[0].value)});}catch(e){notice(e)}};
-$('batch_load').onclick=()=>{let b=book.batches[$('batch_slot').value];if(!b)return notice(Error('This batch slot is empty'));$('batch_name').value=b.name;$('carry').checked=b.carry;$('queue').replaceChildren();b.runs.forEach(queueRow);};
-$('batch_start').onclick=async()=>{try{await readSource();let b=await json('/api/batch/start',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({slot:$('batch_slot').value,data})});batchId=b.id;await pollBatches();}catch(e){notice(e)}};
-$('batch_stop').onclick=async()=>{if(batchId)await json('/api/batch/stop',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({id:batchId})});};
-async function pollBatches(){try{let all=await json('/api/batches');let active=all.find(b=>['queued','running'].includes(b.state));if(active)batchId=active.id;let b=all.find(b=>b.id===batchId);$('batch_stop').disabled=!active;$('batch_start').disabled=!!active; if(b){$('batch_status').textContent=b.slot+' · '+b.name+' · '+b.state+' · run '+b.step+'/'+b.total+(b.error?' · '+b.error:'');if(active&&b.current_job&&job!==b.current_job){job=b.current_job;lastPath=null;poll();}}$('batch_history').replaceChildren();all.slice().reverse().forEach(b=>{let p=document.createElement('p'),button=document.createElement('button');button.textContent=b.name+' · '+b.state+' · '+b.step+'/'+b.total;button.onclick=()=>{batchId=b.id;if(b.current_job){job=b.current_job;lastPath=null;poll();}pollBatches();};p.append(button);['manifest','status'].forEach(name=>{let a=document.createElement('a');a.href='/batches/'+b.id+'/'+name+'.json';a.textContent=' · '+name;a.download=b.id+'-'+name+'.json';p.append(a);});$('batch_history').append(p);});}catch(e){notice(e)}}
-$('stop').onclick=async()=>{if(job)await json('/api/stop',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({id:job})})};
-function num(x,d=2){return x==null?'—':Number(x).toFixed(d)}
-const modelCache=new Map();
-function decode(x){if(x&&typeof x==='object'){if(x.$ald_f64_le){let bytes=new Uint8Array(x.$ald_f64_le.match(/../g).map(h=>parseInt(h,16)));return new DataView(bytes.buffer).getFloat64(0,true)}if(Array.isArray(x))return x.map(decode);return Object.fromEntries(Object.entries(x).map(([k,v])=>[k,decode(v)]))}return x;}
-async function draw(path,track){
- const request=++mapRequest;
- try{
-  if(!modelCache.has(track))modelCache.set(track,await json('/godot/assets/imported/'+encodeURIComponent(track)+'.model.json'));
-  const m=modelCache.get(track).track,polys=m.tiles.flatMap(t=>(t.collision?.layers||[]).flatMap(l=>l.polygons_world||[]));
-  const tiles=m.tiles.map(t=>[t.cell_origin,[t.cell_origin[0]+768,t.cell_origin[1]+768]]);
-  let pts=[];
-  if(path){let response=await fetch('/'+path+'/trajectory.jsonl');if(!response.ok)throw Error('Trajectory unavailable');let txt=await response.text();pts=txt.trim().split('\n').filter(Boolean).map(s=>decode(JSON.parse(s)).pose.position).filter(p=>p.every(Number.isFinite));}
-  if(request!==mapRequest)return;
-  const all=[...tiles.flat(),...pts];if(!all.length)return;
-  const xs=all.map(p=>p[0]),ys=all.map(p=>p[1]),minx=Math.min(...xs),maxx=Math.max(...xs),miny=Math.min(...ys),maxy=Math.max(...ys);
-  const cv=$('map'),ctx=cv.getContext('2d'),scale=Math.min((cv.width-40)/(maxx-minx||1),(cv.height-40)/(maxy-miny||1));
-  const screen=p=>[20+(p[0]-minx)*scale,20+(p[1]-miny)*scale];ctx.clearRect(0,0,cv.width,cv.height);
-  m.tiles.forEach(t=>{let [x,y]=screen(t.cell_origin);ctx.fillStyle={asphalt:'#52708b',dirt:'#ae7246',ice:'#79cde5'}[t.surface]||'#52708b';ctx.fillRect(x,y,768*scale,768*scale)});
-  polys.forEach(poly=>{ctx.beginPath();poly.forEach((p,i)=>ctx[i?'lineTo':'moveTo'](...screen(p)));ctx.closePath();ctx.fillStyle='#0a111c';ctx.fill();ctx.strokeStyle='#b5c3cf';ctx.lineWidth=1;ctx.stroke()});
-  if(pts.length){ctx.beginPath();pts.forEach((p,i)=>ctx[i?'lineTo':'moveTo'](...screen(p)));ctx.strokeStyle='#ffb064';ctx.lineWidth=2;ctx.stroke();let [x,y]=screen(pts.at(-1));ctx.fillStyle='#ffb064';ctx.beginPath();ctx.arc(x,y,4,0,2*Math.PI);ctx.fill();}
-  let r=trackCatalog.find(r=>r.name===track);if(r?.ours_spawn){let [x,y]=screen(r.ours_spawn.position);ctx.fillStyle='#8ce8c1';ctx.beginPath();ctx.arc(x,y,4,0,2*Math.PI);ctx.fill();}
-  let counts={};m.tiles.forEach(t=>counts[t.surface]=(counts[t.surface]||0)+1);$('map_legend').replaceChildren();Object.entries(counts).forEach(([surface,count])=>{let label=document.createElement('span');label.style.marginRight='16px';let swatch=document.createElement('span');swatch.textContent='■ ';swatch.style.color={asphalt:'#52708b',dirt:'#ae7246',ice:'#79cde5'}[surface]||'#52708b';label.append(swatch,document.createTextNode(surface+' · '+count+' tiles'));$('map_legend').append(label)});let obstacle=document.createElement('span');obstacle.textContent='▧ Dark outlined areas: collision walls / solid obstacles · Green: spawn · Orange: recorded path';$('map_legend').append(obstacle);$('map').dataset.track=track;$('map').dataset.trajectoryPoints=String(pts.length);$('map').dataset.wallPolygons=String(polys.length);
-  $('map_note').textContent=track+' · '+(pts.length?'Orange = frozen/selected car trajectory; green = spawn.':'Track layout preview; green = spawn. Native jobs do not export car trajectories; Godot replay adds the actual path.');
- }catch(e){if(request===mapRequest)$('map_note').textContent='Map unavailable: '+e.message;}
-}
-$('backend').onchange=()=>{support();draw(null,$('track').value);};
-async function poll(){if(!job)return;try{let j=await json('/api/job/'+job);let active=['queued','running'].includes(j.state);activeRun=active;$('start').disabled=active;$('reset').disabled=active;$('stop').disabled=!active;$('status').textContent=`${j.state.toUpperCase()} · ${j.network_name}\n${j.config.track} · ${j.config.mode} · ${j.config.backend||'ours'}\nGeneration ${j.generation} / ${j.config.mode==='train'?j.config.generations:1} · ${j.evaluations} evaluations\nElapsed ${num(j.elapsed,1)} s${j.error?'\n'+j.error:''}`; $('run_notes').hidden=!j.note;$('run_note').textContent=j.note||'';$('history').replaceChildren();j.history.slice(-30).forEach(h=>{let tr=document.createElement('tr');[h.generation,num(h.score.progress,3),num(h.score.native_distance_score,3),h.score.full_circuit_seconds==null?'—':num(h.score.full_circuit_seconds,1)+' s',h.score.contacts==null?'—':h.score.contacts].forEach(v=>{let td=document.createElement('td');td.textContent=v;tr.append(td)});$('history').append(tr)});if(j.best){if(!j.best.path&&lastPath!=='native:'+j.id){lastPath='native:'+j.id;await draw(null,j.config.track);}$('download').hidden=(j.config.backend==='github'&&!j.candidate_ready&&j.state==='running');$('download').href='/runs/'+j.id+'/candidate.evolution';if(j.best.path && lastPath!==j.best.path){lastPath=j.best.path;await draw(lastPath,j.config.track);if(j.config.mode==='replay')$('map_panel').open=true}}$('artifacts').replaceChildren();(j.artifacts||[]).forEach(a=>{let el=document.createElement('a');el.href='/'+a.path;el.textContent='Best lap: '+a.label;let para=document.createElement('p');para.append(el);$('artifacts').append(para)});if(!active)await loadRuns();}catch(e){$('error').textContent=e.message}}
-async function loadRuns(){let c=await json('/api/config');$('runs').replaceChildren();c.runs.reverse().forEach(j=>{let p=document.createElement('p'),b=document.createElement('button');b.textContent=j.id+' · '+j.state;b.onclick=()=>{job=j.id;lastPath=null;$('map_panel').open=j.config.mode==='replay';$('history_panel').open=j.config.mode==='train';poll()};p.append(b);$('runs').append(p)})}
-(async()=>{let c=await json('/api/config');catalog=c.rewards;trackCatalog=c.track_catalog;book=await json('/api/presets');let cars=await json('/api/library');cars.forEach(c=>$('library_car').add(new Option(c.name,c.id)));$('library_load').disabled=!cars.length;buildLibraries();refreshBook();queueRow();await pollBatches();setInterval(pollBatches,1500);['A','B','R','Bonus'].forEach(group=>{let opt=document.createElement('optgroup');opt.label=group==='Bonus'?'Bonus':'Series '+group;trackCatalog.filter(r=>r.group===group).forEach(r=>opt.append(new Option(r.name,r.name)));$('track').append(opt)});support();trackCatalog.forEach(r=>{let a=document.createElement('a');a.href='/tracks/'+encodeURIComponent(r.name)+'.track';a.textContent=r.name;let q=document.createElement('p');q.append(a);$('track_downloads').append(q)});applyRewardPreset('center');await draw(null,$('track').value);await loadRuns();let live=c.runs.find(j=>['queued','running'].includes(j.state));if(live)job=live.id;setInterval(poll,1500)})().catch(e=>$('error').textContent=e.message);
-</script></html>
+:root{color-scheme:dark;font:16px system-ui;background:#0c1420;color:#e5edf5}body{max-width:1320px;margin:auto;padding:28px}h1{font-size:32px}h2{font-size:21px}a{color:#7ce4c3}p{line-height:1.6}.grid{display:grid;grid-template-columns:minmax(300px,430px) minmax(0,1fr);gap:24px}.card{background:#152233;border:1px solid #2a3d52;border-radius:16px;padding:22px;margin-top:20px}input,select,button{font:inherit;background:#0c1725;color:#e5edf5;border:1px solid #49627c;border-radius:7px;padding:9px;max-width:100%;box-sizing:border-box}button{cursor:pointer;margin:4px 0}button:disabled{opacity:.45;cursor:default}#run{background:#62dfb1;color:#102522;font-weight:700}#status{white-space:pre-wrap}small,.hint{color:#a2b4c8}.map{min-height:260px;background:#09111b;border-radius:10px;display:grid;place-content:center;text-align:center} @media(max-width:850px){.grid{grid-template-columns:1fr}body{padding:16px}}
+</style>
+<body><main><h1>AI Learns To Drive</h1>
+<p>Game by ActivationFunction · <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">Steam store</a></p>
+<p>Simulator by <a href="https://github.com/Zorro909/driving_sim_rs">Zorro909</a> · UI and HF implementation by <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">TiGa (seeker-cyber-maker)</a></p>
+<p class="hint">Private release integration · bounded training test. No app account needed; private hosting may require access.</p>
+<div class="grid"><section class="card"><h2>Simulation</h2><p>4 vehicles · 1 generation · 60 requested ticks. Formula networks, steering and acceleration; speed and raycast sensors. This is not yet the full trainer.</p>
+<p><label for="backend">Compute</label><select id="backend" disabled><option value="cpu">CPU — no GPU allowance</option><option id="gpuOption" value="gpu" disabled>GPU — uses GPU allowance</option></select></p><p id="backendNote" class="hint">Checking available backends…</p>
+<p><label>Track (.track) <input id="track" type="file" accept=".track"></label></p>
+<p><label>Formula network (.evolution) <input id="network" type="file" accept=".evolution"></label></p>
+<p><label><input id="automatic" type="checkbox" checked> Automatically delete server-side job data after receiving the result</label></p>
+<p>If unchecked, results expire 30 minutes after processing finishes. Repeat downloads do not extend that deadline. <a href="/policy" target="_blank" rel="noopener">Full data handling &amp; deletion policy</a></p>
+<button id="run" disabled>Run short test</button></section><section class="card"><h2>Run &amp; results</h2><button id="download" disabled>Download result</button> <button id="erase" disabled>Delete server-side job data now</button>
+<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>
+<p id="deadline"></p><p id="status" role="status">Ready. Inputs remain on this device until you run the test.</p>
+<h2>Selected track &amp; terrain</h2><div class="map" role="img" aria-label="Track map placeholder"><strong>Track map</strong><p>Renderer not connected yet.</p></div></section></div>
+</main><script src="/client.js"></script></body></html>

requirements.txt

@@ -1 +1,2 @@
-spaces==0.51.3
+fastapi==0.141.1
+uvicorn==0.52.1

server.py

@@ -1,290 +1,60 @@
-"""Loopback UI for the isolated TAO Godot runner. External simulator stays separate."""
-import os,base64,copy,gzip,hashlib,json,math,random,subprocess,sys,threading,time,uuid
+"""Anonymous local integration test server; not yet a ZeroGPU entrypoint."""
+import base64
+import json
 from pathlib import Path
-from urllib.parse import unquote
-from http.server import ThreadingHTTPServer,BaseHTTPRequestHandler
-from concurrent.futures import ThreadPoolExecutor
-ROOT=Path(__file__).resolve().parent
-sys.path.insert(0,str(ROOT/'vendor'))
-import cloud_core as core
-from reward_extraction import RewardEvaluation,extract_rewards,reward_models
-RUNS=ROOT/'runs';RUNS.mkdir(exist_ok=True)
-CAT=json.loads((ROOT/'reward-catalog.json').read_text())
-for r in CAT:r['enabled']=True;r['reason']=None
-SAVELOCK=threading.RLock()
-TRACK_CATALOG=json.loads((ROOT/'tracks/catalog.json').read_text());TRACKS=[r['name'] for r in TRACK_CATALOG];JOBS={};LOCK=threading.RLock()
-SAMPLE=ROOT/'demo.evolution'
-
-def parse_network(data):
- if data[:2]==b'\x1f\x8b':
-  import io
-  with gzip.GzipFile(fileobj=io.BytesIO(data)) as f:data=f.read(8*1024*1024+1)
- if len(data)>8*1024*1024:raise ValueError('Network exceeds 8 MB')
- x=json.loads(data)
- if 'NeuralNetwork' not in x:raise ValueError('Upload a game .evolution network')
- n=x['NeuralNetwork'];shape=n['Shape']
- if x.get('Type')!=0:raise ValueError('This dashboard currently simulates Formula physics. This file is a different vehicle type; choosing an engine does not change its vehicle physics.')
- if not isinstance(shape,list) or not 2<=len(shape)<=20 or any(type(z)!=int or not 1<=z<=64 for z in shape):raise ValueError('Network layers must contain 1–64 nodes, with 2–20 layers')
- if x.get('Outputs')!=[0,1] or shape[-1]!=2:raise ValueError('Current dashboard output contract is steering + acceleration only; brake, handbrake and boost adapters are pending')
- sensors=x.get('Sensors')
- if not isinstance(sensors,list) or len(sensors)!=shape[0]:raise ValueError('Sensor count does not match the network input layer')
- supported={'raycast','speed','trackCurvature','wheelAngle','angularVelocity','correctDirection','grip','accelerationFront','accelerationSide','distanceFromWall','boostCapacity','velocityFront','velocitySide'}
- if any(sensor.get('$type') not in supported for sensor in sensors):raise ValueError('Network contains a sensor type not supported by the native adapter')
- if len(n['Weights'])!=len(shape)-1 or len(n['Biases'])!=len(shape)-1:raise ValueError('Weight/bias layer count differs from shape')
- v=[]
- for i,(a,b) in enumerate(zip(shape[:-1],shape[1:])):
-  w=n['Weights'][i];bs=n['Biases'][i]
-  if len(w)!=a or any(len(row)!=b for row in w) or len(bs)!=b:raise ValueError('Malformed weight dimensions')
-  v.extend(z for row in w for z in row);v.extend(bs)
- if any(type(z) not in (int,float) or not math.isfinite(z) for z in v):raise ValueError('All weights must be finite numbers')
- return x,v
-
-def engine_contract(template,c):
- if c.get('backend','ours')=='ours':
-  missing=sorted({r['$type'] for r in template['Sensors']} - {'raycast','speed'})
-  if missing:raise ValueError('Our Godot runner does not yet sample '+', '.join(missing)+'. Choose the local Native CPU engine for this Formula network.')
-
-def shaped_network(template,v):
- n=template['NeuralNetwork'];shape=n['Shape'];weights=[];biases=[];offset=0
- for a,b in zip(shape[:-1],shape[1:]):
-  weights.append([v[offset+i*b:offset+(i+1)*b] for i in range(a)]);offset+=a*b;biases.append(v[offset:offset+b]);offset+=b
- if offset!=len(v):raise ValueError('Parameter vector does not match shape')
- return {'shape':shape,'weights':weights,'biases':biases,'sensors':template['Sensors'],'outputs':template['Outputs']}
-
-def validate(c):
- def integer(k,lo,hi):
-  z=c[k]
-  if type(z)!=int or not lo<=z<=hi:raise ValueError(f'{k} must be {lo}–{hi}')
- for k,lo,hi in [('seconds',1,300),('population',1,128),('generations',1,1000),('workers',1,4),('control_hz',15,60),('seed',0,2147483647)]:integer(k,lo,hi)
- if c['control_hz'] not in (15,30,60):raise ValueError('Choose 15, 30 or 60 controller decisions/sec')
- if c['track'] not in TRACKS or c['mode'] not in ('replay','train'):raise ValueError('Unknown track or mode')
- if c.get('backend')!='github':raise ValueError('Cloud CPU Space supports the native comparison engine only; our Godot runner remains local')
- if c.get('backend','ours') not in ('ours','github'):raise ValueError('Unknown simulator')
- if c.get('backend','ours')=='ours' and c['mode']=='train' and c['track']!='A01 Beginner':raise ValueError('Our runner currently validates training rewards on A01 only. Choose the local GitHub engine to train this track.')
- z=c['mutation']
- if type(z) not in (float,int) or not math.isfinite(z) or not 0<=z<=4.2:raise ValueError('Mutation strength must be 0–4.2')
- for k in ['collision','idle']:
-  if type(c[k])!=bool:raise ValueError('Invalid elimination setting')
- rows=c['rewards']
- if not isinstance(rows,list) or not 1<=len(rows)<=5:raise ValueError('Select 1–5 reward slots')
- catalog={x['metric']:x for x in CAT};seen=set()
- for r in rows:
-  ident=r['metric']
-  if ident in seen or r['metric'] not in catalog or r['type'] not in catalog[r['metric']]['types']:raise ValueError('Invalid or duplicate reward')
-  seen.add(ident)
-  if type(r['weight'])!=int or not -100<=r['weight']<=100:raise ValueError('Reward weights must be −100 to 100')
- if not any(r['weight'] for r in rows):raise ValueError('At least one reward weight must be nonzero')
- if c.get('selection','best') not in ('best','tournament','roulette') or c.get('crossover','none') not in ('none','single_point','uniform'):raise ValueError('Unknown selection or crossover')
- for k in ['parents','elite']:
-  z=c.get(k,1)
-  if type(z)!=int or not (0 if k=='elite' else 1)<=z<=c['population']:raise ValueError(f'{k} must fit the population')
- z=c.get('decay',0)
- if type(z) not in (float,int) or not math.isfinite(z) or not 0<=z<=1:raise ValueError('Decay must be 0–1')
- for k in ['adaptive_mutation']:
-  if type(c.get(k,False))!=bool:raise ValueError('Invalid adaptive mutation setting')
- if c.get('schedule','fixed') not in ('fixed','linear','geometric'):raise ValueError('Unknown mutation schedule')
- end=c.get('mutation_end',c['mutation'])
- if type(end) not in (int,float) or not math.isfinite(end) or not 0<=end<=4.2:raise ValueError('End mutation must be 0–4.2')
- if c.get('backend','ours')=='github' and c['mode']=='train' and c.get('schedule','fixed')!='fixed' and (c['mutation']==0 or end==0):raise ValueError('Native schedules need positive start/end rates. Use fixed mutation 0 for frozen replay.')
- if c.get('backend','ours')=='ours' and (c.get('schedule','fixed')!='fixed' or c.get('adaptive_mutation',False)):raise ValueError('Scheduled/adaptive native mutation requires the GitHub engine')
- return c
-
-def public_job(job):
- return {k:v for k,v in job.items() if k not in ('cancel','processes','template','vector')}
-
-def save(job):
- public=public_job(job)
- with SAVELOCK:
-  target=RUNS/job['id']/'status.json';temp=target.with_suffix('.tmp');temp.write_text(json.dumps(public,indent=2,allow_nan=False));temp.replace(target)
- return public
-
-def rollout(v,d,c,job):
- d.mkdir();request={'ticks':c['seconds']*60,'record_trace':True,'network':shaped_network(job['template'],v),'track':c['track'],'control_interval':60//c['control_hz'],'collision_elimination':c['collision'],'idle_elimination':c['idle']}
- request['spawn']=next(r['ours_spawn'] for r in TRACK_CATALOG if r['name']==c['track'])
- (d/'request.json').write_text(json.dumps(request));t=time.perf_counter()
- with (d/'stdout.log').open('w') as a,(d/'stderr.log').open('w') as b:
-  p=subprocess.Popen([str(core.ENGINE),'--headless','--disable-render-loop','--fixed-fps','60','--path',str(ROOT/'godot'),'--log-file',str(d/'engine.log'),'--script','res://benchmark.gd','--',str(d)],stdout=a,stderr=b)
-  with LOCK:job['processes'].append(p)
-  try:
-   while p.poll() is None:
-    if job['cancel'].is_set():p.terminate();p.wait(timeout=10);raise InterruptedError('Stopped by user')
-    if time.perf_counter()-t>180:p.terminate();p.wait(timeout=10);raise RuntimeError('Simulation exceeded three-minute timeout')
-    time.sleep(.05)
-   if p.returncode:raise RuntimeError('Simulation failed: '+(d/'stderr.log').read_text()[-1500:])
-  finally:
-   with LOCK:job['processes'].remove(p)
- result=core.decode(json.loads((d/'result.json').read_text()))
- if result['coordinator_error']:raise RuntimeError(str(result['coordinator_error']))
- if c['track']=='A01 Beginner':s=core.collect(d)
- else:s={'ticks':result['ticks'],'contacts':result['contact_ticks'],'progress':None,'full_circuit_seconds':None,'raw':{},'stats_count':result['ticks']//6}
- s['wall_seconds']=time.perf_counter()-t;s['path']=str(d.relative_to(ROOT));(d/'score.json').write_text(json.dumps(s,indent=2));return s
+import threading
+from fastapi import HTTPException, Request
+from fastapi.responses import FileResponse, Response
+from starlette.concurrency import run_in_threadpool
+from delivery import create_api, CapacityExceeded
+from worker import run_reported
 
-def rank(scores,vectors,rows):
- mean=[sum(v[i] for v in vectors)/len(vectors) for i in range(len(vectors[0]))]
- for s,v in zip(scores,vectors):s['raw']['NetworkNovelty']=math.sqrt(sum((a-b)**2 for a,b in zip(v,mean)))
- raw={k:[s['raw'][k] for s in scores] for k in scores[0]['raw']};policy={(r['metric'],r['type']):r['weight'] for r in rows}
- selected,_=extract_rewards(RewardEvaluation(raw,[s['stats_count'] for s in scores]),reward_models(policy),len(scores))
- rewards=core.combine_rewards(selected,policy)
- return sorted(range(len(scores)),key=lambda i:(-rewards.relative[i],i)),list(rewards.relative)
-
-def export(x,v,path):
- x=copy.deepcopy(x);n=shaped_network(x,v);x['NeuralNetwork']['Weights']=n['weights'];x['NeuralNetwork']['Biases']=n['biases'];x['Name']='TAO dashboard candidate';x['Id']=str(uuid.uuid4());x['Stats']={'Generations':[]};x['Snapshots']=[];x['OpponentId']=None;x['SteamWorkshopId']=None;x['Description']='Local simulator candidate; original-game validation pending.'
- path.write_bytes(gzip.compress(json.dumps(x).encode(),mtime=0));parse_network(path.read_bytes())
-
-def run(job):
- d=RUNS/job['id'];c=job['config'];rng=random.Random(c['seed']);v=job['vector'].copy();start=time.perf_counter()
- try:
-  job['state']='running';save(job)
-  if c.get('backend')=='github':
-   from github_adapter import execute
-   execute(job,save,export);job['state']='complete';return
-  for gen in range(c['generations'] if c['mode']=='train' else 1):
-   if job['cancel'].is_set():raise InterruptedError('Stopped by user')
-   pop=[v.copy()]
-   if c['mode']=='train':pop += [[z+rng.gauss(0,c['mutation']) for z in v] for _ in range(c['population']-1)]
-   (d/f'g{gen:04d}-weights.json').write_text(json.dumps(pop))
-   def ev(pair):
-    i,w=pair;s=rollout(w,d/f'g{gen:04d}-c{i:04d}',c,job)
-    with LOCK:job['evaluations']+=1
-    return s
-   with ThreadPoolExecutor(max_workers=c['workers']) as pool:scores=list(pool.map(ev,enumerate(pop)))
-   order,rewards=rank(scores,pop,c['rewards']) if c['mode']=='train' else ([0],[0])
-   winner=order[0];v=pop[winner];best=scores[winner]
-   job['history'].append({'generation':gen+1,'score':best,'winner':winner,'rewards':rewards,'rank':order});job['generation']=gen+1;job['best']=best;job['elapsed']=time.perf_counter()-start
-   (d/f'g{gen:04d}-selection.json').write_text(json.dumps(job['history'][-1],indent=2));export(job['template'],v,d/'candidate.evolution');save(job)
-  job['state']='complete'
- except InterruptedError:job['state']='stopped'
- except Exception as e:job['state']='failed';job['error']=str(e)
- finally:job['elapsed']=time.perf_counter()-start;save(job)
-
-def make_job(c,data,batch_id=None):
- template,v=parse_network(data);legality=network_legality(template)
- if legality['errors']:raise ValueError('Invalid network: '+'; '.join(legality['errors']))
- if c.get('require_standard',True) and not legality['standard']:raise ValueError('Network is outside standard game rules. Review the legality report; research mode can explicitly allow modified networks.')
- engine_contract(template,c)
- with LOCK:
-  ident=time.strftime('%Y%m%d-%H%M%S')+'-'+uuid.uuid4().hex[:6];d=RUNS/ident;d.mkdir();(d/'input.evolution').write_bytes(data)
-  job={'id':ident,'output_dir':str(d),'batch_id':batch_id,'state':'queued','config':c,'network_name':template.get('Name','Uploaded network'),'input_sha256':hashlib.sha256(data).hexdigest(),'generation':0,'evaluations':0,'history':[],'cancel':threading.Event(),'processes':[],'template':template,'vector':v}
-  JOBS[ident]=job;(d/'config.json').write_text(json.dumps(c,indent=2));save(job)
- return job
-
-from network_legality import network_legality
-from preset_store import Store
-from batch_runner import Batches
-PRESETS=Store(ROOT/'preset-library',validate)
-BATCHES=Batches(ROOT/'batches',PRESETS,parse_network,make_job,run)
-
-def network_library():
- base=Path('/Volumes/Steam/CrossOver/ald')
- if not base.exists():base=Path.home()/'Library/Application Support/CrossOver/ald'
- return {hashlib.sha256(str(p.relative_to(base)).encode()).hexdigest()[:16]:p for p in sorted(base.rglob('*.evolution')) if p.is_file() and p.stat().st_size<=8*1024*1024} if base.exists() else {}
-
-def latest_network():
- candidates=[(RUNS/j['id']/'candidate.evolution',j) for j in list(JOBS.values()) if j['state']=='complete']
- candidates=[(p,j) for p,j in candidates if p.is_file()]
- if not candidates:raise ValueError('No completed candidate exists yet. Upload a network or create one in the editor.')
- p,j=max(candidates,key=lambda pair:pair[0].stat().st_mtime_ns)
- return {'filename':j['id']+'/candidate.evolution','job_id':j['id'],'data':base64.b64encode(p.read_bytes()).decode()}
+ROOT=Path(__file__).resolve().parent
 
-def edit_network(x):
- data=base64.b64decode(x.get('data') or base64.b64encode(SAMPLE.read_bytes()).decode(),validate=True)
- if data[:2]==b'\x1f\x8b':
-  import io
-  with gzip.GzipFile(fileobj=io.BytesIO(data)) as f:data=f.read(8*1024*1024+1)
- if len(data)>8*1024*1024:raise ValueError('Network exceeds 8 MB')
- template=json.loads(data);n=template['NeuralNetwork']
- if x['action']=='inspect':
-  compatibility={}
-  for backend in ('ours','github'):
-   try:parsed,_=parse_network(data);engine_contract(parsed,{'backend':backend});compatibility[backend]='supported'
-   except (ValueError,KeyError,TypeError,IndexError) as e:compatibility[backend]=str(e)
-  return {'network':n,'sensors':template.get('Sensors'),'name':template.get('Name'),'outputs':template.get('Outputs'),'vehicle':template.get('Type'),'compatibility':compatibility,'stats':template.get('Stats',{}),'snapshots':template.get('Snapshots',[]),'id':template.get('Id'),'legality':network_legality(template)}
- if x['action']=='create':
-  shape=x['shape']
-  if not isinstance(shape,list) or not 3<=len(shape)<=20 or shape[0]!=6 or shape[-1]!=2 or any(type(z)!=int or not 1<=z<=64 for z in shape):raise ValueError('Shape must start with 6, end with 2, and contain 1–18 hidden layers of 1–64 nodes')
-  if sum(a*b+b for a,b in zip(shape[:-1],shape[1:]))>100000:raise ValueError('Editor limit: 100,000 parameters')
-  seed=x['seed']
-  if type(seed)!=int or not 0<=seed<=2147483647:raise ValueError('Seed must be 0–2147483647')
-  rng=random.Random(seed);weights=[];biases=[]
-  for a,b in zip(shape[:-1],shape[1:]):
-   bound=math.sqrt(6/(a+b));weights.append([[rng.uniform(-bound,bound) if x.get('xavier',True) else 0. for _ in range(b)] for _ in range(a)]);biases.append([rng.uniform(-bound,bound) if x.get('xavier_bias',False) else 0. for _ in range(b)])
-  n={'Shape':shape,'Weights':weights,'Biases':biases}
- elif x['action']=='save':n=x['network']
- else:raise ValueError('Unknown editor action')
- shape=n['Shape']
- if not 2<=len(shape)<=20 or any(type(z)!=int or not 1<=z<=64 for z in shape) or len(n['Weights'])!=len(shape)-1 or len(n['Biases'])!=len(shape)-1:raise ValueError('Invalid network shape')
- for i,(a,b) in enumerate(zip(shape[:-1],shape[1:])):
-  w,bs=n['Weights'][i],n['Biases'][i]
-  if len(w)!=a or any(len(row)!=b for row in w) or len(bs)!=b:raise ValueError('Malformed weight dimensions')
-  if any(type(z) not in (int,float) or not math.isfinite(z) for z in [v for row in w for v in row]+bs):raise ValueError('All weights and biases must be finite numbers')
- n['InputShape']=shape[0];n['OutputShape']=shape[-1];n['NeuronsCount']=sum(shape);n['TotalParams']=sum(a*b+b for a,b in zip(shape[:-1],shape[1:]));template['NeuralNetwork']=n;template['Name']=str(x.get('name','TAO editor network'))[:80];template['Id']=str(uuid.uuid4());template['Stats']={'Generations':[]};template['Snapshots']=[];template['OpponentId']=None;template['SteamWorkshopId']=None;template['Description']='Locally edited research network; no game or leaderboard validation claimed.'
- legality=network_legality(template)
- if legality['errors']:raise ValueError('Cannot export structurally invalid network: '+'; '.join(legality['errors']))
- payload=gzip.compress(json.dumps(template).encode(),mtime=0)
- return {'filename':template['Name']+'.evolution','data':base64.b64encode(payload).decode(),'network':n,'trainable':template.get('Outputs')==[0,1] and template.get('Type')==0,'stats':template['Stats'],'sensors':template['Sensors'],'outputs':template['Outputs'],'vehicle':template.get('Type'),'legality':network_legality(template)}
+def create_app(worker=run_reported,store=None,gpu_worker=None):
+    app=create_api(store)
+    admission=threading.BoundedSemaphore(1)
+    @app.get('/api/capabilities')
+    def capabilities():
+        return {'cpu':True,'gpu':gpu_worker is not None,'default':'cpu'}
+    @app.get('/')
+    def index(): return FileResponse(ROOT/'index.html',media_type='text/html')
+    @app.get('/client.js')
+    def script(): return FileResponse(ROOT/'client.js',media_type='text/javascript')
+    @app.get('/policy')
+    def policy(): return FileResponse(ROOT/'DATA_POLICY.md',media_type='text/plain')
+    @app.post('/api/process')
+    async def process(request:Request):
+        if not admission.acquire(blocking=False): raise HTTPException(429,'Worker busy; try later')
+        try:
+            data=bytearray()
+            async for chunk in request.stream():
+                if len(data)+len(chunk)>3*1024*1024: raise HTTPException(413,'Request too large')
+                data.extend(chunk)
+            try:
+                body=json.loads(data)
+                automatic=body.get('automatic',True)
+                backend=body.get('backend','cpu')
+                if backend not in ('cpu','gpu'): raise ValueError()
+                if type(automatic)!=bool: 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 input envelope') from None
+            finally: data.clear()
+            selected=worker if backend=='cpu' else gpu_worker
+            if selected is None: raise HTTPException(503,'GPU is unavailable; select CPU to run without a GPU lease')
+            try:
+                result=await run_in_threadpool(selected,track,network)
+                payload,report=result if isinstance(result,tuple) else (result,None)
+                return {**app.state.results.publish(payload,automatic),'backend':backend,'report':report}
+            except CapacityExceeded: raise HTTPException(503,'Result capacity reached') from None
+            except Exception: raise HTTPException(422,'Processing failed; no result published. Cleanup status requires verification.') from None
+        finally: admission.release()
+    return app
+
+app=create_app()
 
-class Handler(BaseHTTPRequestHandler):
- def allowed(self):
-  host=self.headers.get('Host','').split(':')[0]
-  origins=('https://huggingface.co','https://tiga-rce-ald-tao-gpu.hf.space','http://localhost:7860','http://127.0.0.1:7860')
-  return host in ('localhost','127.0.0.1','tiga-rce-ald-tao-gpu.hf.space','0.0.0.0') and self.headers.get('Origin',origins[0]) in origins
- def send(self,x,status=200):
-  data=json.dumps(x,allow_nan=False).encode();self.send_response(status);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(data)));self.end_headers();self.wfile.write(data)
- def do_GET(self):
-  if not self.allowed():return self.send({'error':'Local access only'},403)
-  if self.path=='/api/presets':return self.send(PRESETS.read())
-  if self.path=='/api/batches':return self.send([BATCHES.public(b) for b in list(BATCHES.items.values())])
-  if self.path=='/api/config':return self.send({'service':'tao-local-driving-dashboard','port':self.server.server_address[1],'tracks':TRACKS,'track_catalog':TRACK_CATALOG,'rewards':CAT,'runs':[public_job(j) for j in list(JOBS.values())]})
-  if self.path.startswith('/api/job/'):
-   j=JOBS.get(self.path.split('/')[-1]);return self.send(public_job(j) if j else {'error':'Unknown run'},200 if j else 404)
-  if self.path=='/api/library':return self.send([{'id':id,'name':str(p.relative_to(p.parents[1])) if p.parent.name in ('Steam','Steam-AI') else p.name} for id,p in network_library().items()])
-  if self.path.startswith('/api/library/'):
-   p=network_library().get(self.path.rsplit('/',1)[-1])
-   if not p:return self.send({'error':'Saved network not found'},404)
-   return self.send({'filename':p.parent.name+'/'+p.name,'data':base64.b64encode(p.read_bytes()).decode()})
-  if self.path=='/api/latest':
-   try:return self.send(latest_network())
-   except ValueError as e:return self.send({'error':str(e)},400)
-  if self.path=='/api/sample':return self.send({'filename':SAMPLE.name,'data':base64.b64encode(SAMPLE.read_bytes()).decode()})
-  path=ROOT/('index.html' if self.path=='/' else unquote(self.path.lstrip('/')))
-  path=path.resolve()
-  if not path.is_relative_to(ROOT) or not path.is_file() or path.suffix not in ('.html','.evolution','.track','.json','.jsonl'):return self.send({'error':'Not found'},404)
-  data=path.read_bytes();typ='text/html' if path.suffix=='.html' else 'application/octet-stream';self.send_response(200);self.send_header('Content-Type',typ);self.send_header('Content-Length',str(len(data)))
-  if path.suffix in ('.evolution','.track'):self.send_header('Content-Disposition',f'attachment; filename="{path.name}"')
-  self.end_headers();self.wfile.write(data)
- def do_POST(self):
-  if not self.allowed():return self.send({'error':'Local access only'},403)
-  try:
-   size=int(self.headers.get('Content-Length','0'))
-   if not 0<size<=12*1024*1024:raise ValueError('Request too large')
-   x=json.loads(self.rfile.read(size))
-   if self.path=='/api/stop':
-    job=JOBS[x['id']]
-    if job.get('batch_id'):BATCHES.stop(job['batch_id'],JOBS)
-    else:job['cancel'].set()
-    return self.send({'state':'stopping'})
-   if self.path=='/api/network/editor':return self.send(edit_network(x))
-   if self.path=='/api/presets':return self.send(PRESETS.update(x))
-   if self.path=='/api/batch/stop':return self.send(BATCHES.stop(x['id'],JOBS))
-   if self.path not in ('/api/run','/api/batch/start'):return self.send({'error':'Unknown action'},404)
-   data=base64.b64decode(x['data'],validate=True)
-   with LOCK:
-    if BATCHES.active() or any(j['state'] in ('queued','running') for j in JOBS.values()):raise ValueError('Stop or finish the current run or batch first')
-    if self.path=='/api/batch/start':return self.send(BATCHES.start(x['slot'],data))
-    job=make_job(validate(x['config']),data)
-   threading.Thread(target=run,args=(job,),daemon=True).start();return self.send({'id':job['id']})
-  except (ValueError,KeyError,TypeError,IndexError) as e:return self.send({'error':str(e)},400)
- def log_message(self,*args):pass
 if __name__=='__main__':
- for p in sorted(RUNS.glob('*/status.json')):
-  j=json.loads(p.read_text());j['cancel']=threading.Event();j['processes']=[]
-  if j['state'] in ('queued','running'):j['state']='interrupted';save(j)
-  JOBS[j['id']]=j
- ports=[int(os.environ['ALD_DASHBOARD_PORT'])] if 'ALD_DASHBOARD_PORT' in os.environ else [47810,47811]
- for port in ports:
-  try:http=ThreadingHTTPServer(('0.0.0.0',port),Handler);break
-  except OSError:
-   if port==ports[-1]:raise
- (ROOT/'dashboard-port.json').write_text(json.dumps({'port':port}))
- print(f'TAO dashboard: http://127.0.0.1:{port}',flush=True)
- http.serve_forever()
+    import uvicorn
+    uvicorn.run(app,host='127.0.0.1',port=47831,access_log=False)

worker.py

@@ -0,0 +1,125 @@
+"""Bounded native adapter. No engine modifications; no network calls.
+
+This is NOT a network sandbox. Private deployment pending integration verification.
+"""
+import gzip
+import io
+import json
+import math
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import time
+
+ROOT = Path(__file__).resolve().parents[2]
+
+def read_json(data):
+    if len(data)>1024*1024: raise ValueError('Input exceeds 1 MB')
+    if data[:2]==b'\x1f\x8b':
+        with gzip.GzipFile(fileobj=io.BytesIO(data)) as stream:
+            data=stream.read(4*1024*1024+1)
+    if len(data)>4*1024*1024: raise ValueError('Expanded input exceeds 4 MB')
+    result=json.loads(data,parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON')))
+    if not isinstance(result,dict): raise ValueError('Expected JSON object')
+    return result
+
+def network_input(data):
+    value=read_json(data)
+    network=value['NeuralNetwork']; shape=network['Shape']
+    if value.get('Type')!=0 or value.get('Outputs')!=[0,1]: raise ValueError('Formula steering/acceleration only')
+    if not isinstance(shape,list) or not 2<=len(shape)<=4 or any(type(n)!=int or not 1<=n<=16 for n in shape) or shape[-1]!=2:
+        raise ValueError('Unsupported shape')
+    sensors=value['Sensors']
+    if not isinstance(sensors,list) or len(sensors)!=shape[0]: raise ValueError('Sensor count')
+    # Deliberately small first supported contract. Do not forward unknown settings.
+    clean_sensors=[]
+    for sensor in sensors:
+        if sensor.get('$type')=='speed': clean_sensors.append({'$type':'speed'})
+        elif sensor.get('$type')=='raycast':
+            selected={'$type':'raycast'}
+            for key in ('Degrees','Length'):
+                n=sensor[key]
+                if type(n) not in (int,float) or not math.isfinite(n): raise ValueError('Sensor value')
+                if key=='Degrees' and not -360<=n<=360: raise ValueError('Degrees')
+                if key=='Length' and not 1<=n<=10000: raise ValueError('Length')
+                selected[key]=n
+            clean_sensors.append(selected)
+        else: raise ValueError('Only speed and raycast sensors supported in smoke version')
+    weights,biases=network['Weights'],network['Biases']
+    if len(weights)!=len(shape)-1 or len(biases)!=len(shape)-1: raise ValueError('Layer count')
+    for i,(a,b) in enumerate(zip(shape,shape[1:])):
+        if len(weights[i])!=a or any(len(row)!=b for row in weights[i]) 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':[0,1],'Sensors':clean_sensors,
+            'Name':'HF candidate','NeuralNetwork':{'Shape':shape,'Weights':weights,'Biases':biases}}
+
+def track_input(data):
+    value=read_json(data)
+    tiles=value['Tiles']
+    if not isinstance(tiles,dict) or not 4<=len(tiles)<=256: raise ValueError('Track tile limit')
+    start=value.get('StartTileConnection')
+    if not isinstance(start,dict): raise ValueError('StartTileConnection must be an object')
+    # Match the local runner's saved-track import: game files can omit default Type.
+    # Normalize only this parsed copy; never rewrite the uploaded source bytes.
+    if 'Type' not in start: start['Type']=0
+    elif type(start['Type']) is not int: raise ValueError('StartTileConnection.Type must be an integer')
+    return value
+
+def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_template=None,with_report=False):
+    started=time.perf_counter()
+    track=track_input(track_bytes); template=network_input(network_bytes)
+    # Deployment paths are supplied by trusted application configuration, never uploads.
+    binary=Path(binary or ROOT/'target/release/altd-sim').resolve()
+    importer=Path(importer or ROOT/'target/release/examples/extract_saved_track').resolve()
+    scene_template=Path(scene_template or ROOT/'assets/scenes/formula_template.json').resolve()
+    if not all(p.is_file() for p in (binary,importer,scene_template)):
+        raise RuntimeError('Native tools or scene template unavailable')
+    # No inherited provider tokens, credential paths, or caller-chosen commands.
+    env={'PATH':'/usr/bin:/bin','LANG':'C','RUST_BACKTRACE':'0'}
+    with tempfile.TemporaryDirectory(prefix='tiga-native-') as directory:
+        work=Path(directory)
+        env.update(HOME=directory,TMPDIR=directory)
+        def save(name,value):
+            path=work/name; path.write_text(json.dumps(value,allow_nan=False)); return str(path)
+        saved=save('track.json',track)
+        scene=work/'scene.json'
+        subprocess.run([str(importer),saved,'User track',str(scene_template),str(scene)],
+            cwd=work,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=10,check=True)
+        imported=json.loads(scene.read_text())
+        spawn=save('spawn.json',{'frames':[{'position':imported['reset_position'],'rotation':imported['reset_rotation']}]})
+        n=template['NeuralNetwork']; names=[f'sensor-{i}' for i in range(n['Shape'][0])]
+        network=save('network.json',{'shape':n['Shape'],'weights':n['Weights'],'biases':n['Biases'],'inputs':names,'outputs':['Steering','Acceleration']})
+        model=save('model.json',{'sensor_layout':{'names':names,'sensors':template['Sensors']}})
+        settings=save('settings.json',{'population':4,'selection_algorithm':'best','selection_size':1,
+            'crossover':'none','mutation_rate':.01,'adaptive_mutation':False,'weight_decay':0,
+            'preserve_parents':'on_custom','preserve_parents_size':1,
+            'rewards':[{'metric':'total_score','type':'default','weight':1}]})
+        out=work/'result'
+        command=[str(binary),'--math-profile','proton','--threads','1','train-scratch',
+            '--scene',str(scene),'--spawn-trace',spawn,'--network',network,'--init-network',network,
+            '--model',model,'--settings',settings,'--shape',','.join(map(str,n['Shape'])),
+            '--population','4','--generations','1','--ticks','60','--seed','42','--batch-count','2',
+            '--out-dir',str(out),'--mutation-start','.01','--mutation-end','.01',
+            '--schedule','linear','--save-final-candidate']
+        subprocess.run(command,cwd=work,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=25,check=True)
+        candidate=out/'candidate.json'
+        if candidate.stat().st_size>1024*1024: raise ValueError('Output too large')
+        trained=json.loads(candidate.read_text())
+        n['Weights']=trained['weights']; n['Biases']=trained['biases']
+        result=gzip.compress(json.dumps(template,allow_nan=False).encode(),mtime=0)
+        network_input(result)
+        history=[json.loads(line) for line in (out/'log.jsonl').read_text().splitlines() if line.strip()]
+        last=history[-1] if history else {}
+        report={'state':'completed','elapsed_seconds':time.perf_counter()-started,
+            'generations_completed':len(history),'generations_requested':1,'population':4,
+            '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'),
+            'simulated_ticks':last.get('simulated_ticks'),'requested_ticks':60,
+            'candidate_validated':True}
+    # The context has removed input/intermediate files before result publication.
+    return (result,report) if with_report else result
+
+def run_reported(track_bytes,network_bytes):
+    return run_native(track_bytes,network_bytes,with_report=True)