language2drive 0.1.0__py3-none-any.whl

l2d_benchmark/__init__.py

@@ -0,0 +1,4 @@
+"""Public SDK. The legacy CARLA package keeps its original namespace."""
+from .adapter import Request, OutputSpec, load_adapter
+__version__ = "0.1.0"
+__all__ = ["Request", "OutputSpec", "load_adapter"]

l2d_benchmark/adapter.py

@@ -0,0 +1,90 @@
+"""One model contract across all five backends; no evaluator labels cross it."""
+from __future__ import annotations
+from dataclasses import asdict, dataclass
+import importlib.util
+import math
+import hashlib
+from pathlib import Path
+import sys
+from typing import Any
+
+@dataclass(frozen=True)
+class OutputSpec:
+    timestamps_s: tuple[float, ...]
+    reference_point: str
+    coordinate_frame: str = "ego_at_anchor"
+    axes: str = "+x forward, +y left; metres"
+
+@dataclass(frozen=True)
+class Request:
+    track: str
+    instruction: str
+    observation: dict[str, Any]
+    output_spec: OutputSpec
+    seed: int = 0
+
+    def to_dict(self):
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, value):
+        value = dict(value)
+        spec = dict(value.pop("output_spec"))
+        spec["timestamps_s"] = tuple(spec["timestamps_s"])
+        return cls(output_spec=OutputSpec(**spec), **value)
+
+SPECS = {
+    "nuscenes": OutputSpec(tuple(i * .25 for i in range(1, 13)), "ego_pose_origin"),
+    "navsim": OutputSpec(tuple(i * .5 for i in range(1, 9)), "rear_axle"),
+    "wod": OutputSpec(tuple(i * .25 for i in range(1, 21)), "rear_axle"),
+    "carla": OutputSpec(tuple(i * .25 for i in range(1, 21)), "rear_axle"),
+    "realsim": OutputSpec(tuple(i * .1 for i in range(1, 61)), "rig_origin"),
+}
+
+def load_adapter(path, config=None):
+    path = Path(path).resolve()
+    if not path.is_file():
+        raise FileNotFoundError(f"Model adapter missing: {path}")
+    name = "l2d_adapter_" + hashlib.sha256(str(path).encode()).hexdigest()[:16]
+    cached = sys.modules.get(name)
+    if cached is not None:
+        factory = getattr(cached, "create_adapter", None)
+        return factory(config or {}) if callable(factory) else cached
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    sys.path.insert(0, str(path.parent))
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        sys.path.pop(0)
+    factory = getattr(module, "create_adapter", None)
+    adapter = factory(config or {}) if callable(factory) else module
+    if not callable(getattr(adapter, "predict", None)):
+        raise ValueError("Define create_adapter(config) returning an object with predict(request), or a module-level predict(request)")
+    return adapter
+
+
+def validate_trajectory(result, spec):
+    if not isinstance(result, dict):
+        raise ValueError("predict must return a dictionary")
+    for key, expected in (("coordinate_frame", spec.coordinate_frame), ("reference_point", spec.reference_point)):
+        if result.get(key) != expected:
+            raise ValueError(f"{key} must be {expected}; convert the model frame explicitly")
+    times, xy = result.get("timestamps_s"), result.get("xy_m")
+    if not isinstance(times, (list, tuple)) or len(times) != len(spec.timestamps_s):
+        raise ValueError("timestamps_s must match requested grid")
+    if any(type(t) not in (int, float) or not math.isfinite(t) or abs(t - target) > 1e-7
+           for t, target in zip(times, spec.timestamps_s)):
+        raise ValueError("timestamps_s must match requested grid")
+    if not isinstance(xy, (list, tuple)) or len(xy) != len(times):
+        raise ValueError("xy_m must have one XY point per requested timestamp")
+    if any(not isinstance(p, (list, tuple)) or len(p) != 2 or
+           any(type(v) not in (int, float) or not math.isfinite(v) for v in p) for p in xy):
+        raise ValueError("xy_m must contain finite XY pairs")
+    return {"coordinate_frame": spec.coordinate_frame, "reference_point": spec.reference_point,
+            "timestamps_s": list(spec.timestamps_s), "xy_m": [[float(v) for v in p] for p in xy]}
+
+
+def predict(adapter, request):
+    return validate_trajectory(adapter.predict(request), request.output_spec)

l2d_benchmark/bridges/__init__.py

@@ -0,0 +1 @@
+"""Simulator bridges, imported only in their dedicated runtime environments."""

l2d_benchmark/bridges/carla.py

@@ -0,0 +1,72 @@
+"""Bench2Drive autonomous agent using the common trajectory service.
+
+Controller: pure pursuit, wheelbase 2.8m; no route/target-point input.
+"""
+import json
+import math
+import uuid
+import carla
+from leaderboard.autoagents.autonomous_agent import AutonomousAgent, Track
+from team_code.language2drive_context import PublicContextState
+from l2d_benchmark.adapter import Request, SPECS
+from l2d_benchmark.service import Client, image_payload
+
+
+def get_entry_point():
+    return 'UnifiedAgent'
+
+
+class UnifiedAgent(AutonomousAgent):
+    def set_language2drive_context(self, context):
+        state = getattr(self, '_context_state', None) or PublicContextState()
+        self._context_state = state
+        parsed = state.bind(context)
+        if parsed.track != 'standardized':
+            raise ValueError('Unified bridge requires standardized, language-only evaluation')
+        self._global_plan = self._global_plan_world_coord = None
+        return parsed.to_dict()
+
+    def set_global_plan(self, *args):
+        raise ValueError('Unified bridge never consumes global routes')
+
+    def setup(self, path_to_conf_file, route_index=None):
+        self.track = Track.SENSORS
+        self.cfg = json.loads(open(path_to_conf_file).read())
+        self.client = Client(self.cfg.get('endpoint', 'http://127.0.0.1:8090'))
+        self.session = uuid.uuid4().hex
+        self.client.reset(self.session)
+        self.history = []
+
+    def sensors(self):
+        result = []
+        for name, yaw in [('front', 0), ('left', -60), ('right', 60)]:
+            result.append(dict(type='sensor.camera.rgb', x=0, y=0, z=1.6, roll=0, pitch=0, yaw=yaw,
+                               width=960, height=540, fov=100, id='rgb_' + name))
+        result.append(dict(type='sensor.speedometer', reading_frequency=20, id='speed'))
+        return result
+
+    def run_step(self, input_data, timestamp):
+        context = self._context_state.context
+        if context is None:
+            raise ValueError('Evaluator did not bind the public instruction')
+        # CARLA camera BGRA -> RGB. Camera positions are vehicle origin, not rear axle.
+        cameras = {name: [{'timestamp_s': float(timestamp), 'image': image_payload(input_data['rgb_' + name][1][:, :, :3][:, :, ::-1])}]
+                   for name in ('front', 'left', 'right')}
+        speed = float(input_data['speed'][1]['speed'])
+        request = Request('carla', context.instruction,
+                          {'cameras': cameras, 'speed_m_s': speed, 'timestamp_s': float(timestamp),
+                           'camera_rig': self.sensors(), 'vehicle_origin_to_rear_axle_m': self.cfg.get('rear_axle_offset_m', -1.4)}, SPECS['carla'], int(self.cfg.get('model_seed', 0)))
+        xy = self.client.predict(request, self.session)['xy_m']
+        lookahead = max(2.0, speed * .5)
+        target = next((p for p in xy if math.hypot(*p) >= lookahead), xy[-1])
+        distance2 = max(target[0]**2 + target[1]**2, .01)
+        # Positive model Y is left; positive CARLA steer is right.
+        steering_angle = -math.atan2(2 * 2.8 * target[1], distance2)
+        steer = max(-1., min(1., steering_angle / .7))
+        desired = math.hypot(*xy[0]) / SPECS['carla'].timestamps_s[0]
+        delta = desired - speed
+        return carla.VehicleControl(steer=steer, throttle=max(0., min(.75, delta * .3)), brake=max(0., min(1., -delta * .5)))
+
+    def destroy(self):
+        if hasattr(self, 'client'):
+            self.client.call('close', {'session': self.session})

l2d_benchmark/bridges/realsim.py

@@ -0,0 +1,64 @@
+"""Pinned AlpaSim trajectory plugin, with isolated recurrent sessions."""
+import os
+import numpy as np
+from alpasim_driver.models.base import BaseTrajectoryModel, ModelPrediction
+from alpasim_utils.geometry import Trajectory, pose_from_grpc
+from l2d_benchmark.adapter import Request, SPECS
+from l2d_benchmark.service import Client, image_payload
+
+
+class UnifiedTrajectoryModel(BaseTrajectoryModel):
+    @classmethod
+    def from_config(cls, model_cfg, device, camera_ids, context_length, output_frequency_hz):
+        if output_frequency_hz != 10:
+            raise ValueError('Unified RealSim output frequency must be 10Hz')
+        return cls(camera_ids, context_length)
+
+    def __init__(self, camera_ids, context_length):
+        self._camera_ids = list(camera_ids)
+        self._context_length = context_length
+        self.client = Client(os.environ.get('L2D_MODEL_ENDPOINT', 'http://127.0.0.1:8090'))
+        self.sessions = set()
+
+    @property
+    def camera_ids(self):
+        return self._camera_ids
+
+    @property
+    def context_length(self):
+        return self._context_length
+
+    @property
+    def output_frequency_hz(self):
+        return 10
+
+    def _encode_command(self, command):
+        return 0
+
+    def predict(self, prediction_input):
+        session = prediction_input.l2d_session_uuid
+        if session not in self.sessions:
+            self.client.reset(session)
+            self.sessions.add(session)
+        timestamp = int(prediction_input.l2d_timestamp_us)
+        cameras = {name: [{'timestamp_us': int(t), 'image': image_payload(im)} for t, im in frames]
+                   for name, frames in prediction_input.camera_images.items()}
+        poses = sorted(prediction_input.ego_pose_history or [], key=lambda p: p.timestamp_us)
+        if not poses or not poses[0].timestamp_us <= timestamp <= poses[-1].timestamp_us:
+            raise ValueError('No ego pose covers the trajectory anchor; refusing unanchored output')
+        trajectory = self.client.predict(Request('realsim', prediction_input.language_instruction,
+            {'cameras': cameras, 'speed_m_s': float(prediction_input.speed), 'acceleration_m_s2': float(prediction_input.acceleration), 'timestamp_us': timestamp, 'camera_rectification': prediction_input.l2d_camera_calibration},
+            SPECS['realsim'], int(prediction_input.inference_seed)), session)
+        xy = np.asarray(trajectory['xy_m'])
+        delta = np.diff(np.vstack([np.zeros((1, 2)), xy]), axis=0)
+        prediction = ModelPrediction.from_planar(xy, np.arctan2(delta[:, 1], delta[:, 0]))
+        pose = Trajectory.from_poses(np.asarray([p.timestamp_us for p in poses], dtype=np.uint64), [pose_from_grpc(p.pose) for p in poses]).interpolate_pose(timestamp)
+        prediction.model_t0_us = timestamp
+        prediction.pose_local_to_rig_t0 = pose
+        prediction.waypoint_timestamps_us = timestamp + np.arange(1, len(xy)+1, dtype=np.uint64) * 100000
+        return prediction
+
+    def close(self):
+        for session in self.sessions:
+            self.client.call('close', {'session': session})
+        self.sessions.clear()

l2d_benchmark/cli.py

@@ -0,0 +1,121 @@
+"""Public language2drive command. Native track entry points remain unchanged."""
+import argparse
+import json
+from pathlib import Path
+import sys
+from . import __version__
+from .workspace import TRACKS, discover, initialize
+
+
+def selection(value):
+    groups = {'openloop': ['nuscenes', 'navsim', 'wod']}
+    names = list(TRACKS) if value == 'all' else [track for item in value.split(',') for track in groups.get(item, [item])]
+    if not names or len(set(names)) != len(names) or any(n not in TRACKS for n in names):
+        raise argparse.ArgumentTypeError('Use all or comma-separated carla,realsim,openloop (or individual nuscenes,navsim,wod)')
+    return names
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog='language2drive', description='One model adapter. Five instruction-following evaluation tracks.')
+    parser.add_argument('--version', action='version', version=__version__)
+    sub = parser.add_subparsers(dest='command', required=True)
+    init = sub.add_parser('init', help='Extract verified backends from the wheel into a workspace')
+    init.add_argument('--workspace', required=True)
+    config = sub.add_parser('configure', help='Generate one five-backend configuration using the downloaded resource layout')
+    config.add_argument('--workspace')
+    config.add_argument('--output', default='.l2d/evaluation.json')
+    config.add_argument('--gpu', type=int, default=0)
+    for name in ('nuscenes-root', 'navsim-root', 'navsim-sidecars', 'wod-release', 'realsim-bundle', 'realsim-scenes', 'realsim-work-dir', 'ego-hood-dir'):
+        config.add_argument('--' + name)
+    setup = sub.add_parser('setup', help='Install selected isolated environments and optional resources')
+    setup.add_argument('--workspace')
+    setup.add_argument('--tracks', type=selection, default=selection('all'))
+    setup.add_argument('--network', choices=('auto', 'official', 'mirror'), default='auto')
+    setup.add_argument('--transport', choices=('auto', 'direct', 'environment'), default='auto', help='Automatically bypass a broken proxy, or explicitly select transport')
+    setup.add_argument('--runtime', action='store_true', help='Also provision CARLA/AlpaSim runtime dependencies')
+    setup.add_argument('--realsim-work-dir', help='Place the pinned RealSim runtime on a chosen disk; also pass this path to configure')
+    setup.add_argument('--download', action='store_true')
+    setup.add_argument('--source-root')
+    setup.add_argument('--package', help='Use this local wheel or checkout when installing evaluator environments')
+    setup.add_argument('--dry-run', action='store_true')
+    serve = sub.add_parser('serve', help='Run your adapter in its existing model environment')
+    serve.add_argument('--adapter', required=True)
+    serve.add_argument('--config', help='Model configuration JSON')
+    serve.add_argument('--host', default='127.0.0.1')
+    serve.add_argument('--port', type=int, default=8090)
+    run = sub.add_parser('evaluate', help='Infer, export and score selected tracks; save a coverage report')
+    run.add_argument('--config', required=True)
+    run.add_argument('--tracks', type=selection, default=selection('all'))
+    run.add_argument('--output', default='outputs/my-model')
+    run.add_argument('--dry-run', action='store_true')
+    live = sub.add_parser('run', help='Start one model service and run GPU campaigns across three runtime groups')
+    live.add_argument('--config', required=True)
+    live.add_argument('--tracks', type=selection, default=selection('all'))
+    live.add_argument('--adapter')
+    live.add_argument('--model-config')
+    live.add_argument('--model-python')
+    live.add_argument('--output', default='outputs/my-model')
+    live.add_argument('--dry-run', action='store_true')
+    gpu = sub.add_parser('gpu-check', help='Check host GPU, evaluator interpreters and configured resources')
+    gpu.add_argument('--config', required=True)
+    gpu.add_argument('--tracks', type=selection, default=selection('all'))
+    worker = sub.add_parser('_worker', help=argparse.SUPPRESS)
+    worker.add_argument('--config', required=True)
+    worker.add_argument('--track', required=True, choices=TRACKS)
+    worker.add_argument('--output', required=True)
+    demo = sub.add_parser('adapter-check', help='Validate one adapter against all five output contracts, without datasets')
+    demo.add_argument('--adapter', required=True)
+    demo.add_argument('--config')
+    doctor = sub.add_parser('doctor', help='Check workspace and per-track interpreter availability')
+    doctor.add_argument('--workspace')
+    args = parser.parse_args(argv)
+    try:
+        if args.command == 'init':
+            result = {'workspace': str(initialize(args.workspace))}
+        elif args.command == 'configure':
+            from .configure import configure
+            if args.gpu < 0:
+                raise ValueError('--gpu must be a non-negative host GPU index')
+            names = ('nuscenes_root', 'navsim_root', 'navsim_sidecars', 'wod_release', 'realsim_bundle', 'realsim_scenes', 'realsim_work_dir', 'ego_hood_dir')
+            result = configure(args.workspace, args.output, args.gpu, **{name: getattr(args, name) for name in names})
+        elif args.command == 'setup':
+            from .setup import bootstrap
+            result = bootstrap(args.workspace, args.tracks, args.network, args.runtime, args.download, args.source_root, args.dry_run, args.package, args.transport, args.realsim_work_dir)
+        elif args.command == 'serve':
+            from .service import serve
+            serve(args.adapter, json.loads(Path(args.config).read_text()) if args.config else {}, args.host, args.port)
+            return 0
+        elif args.command == 'run':
+            from .live import launch
+            result = launch(args.config, args.tracks, args.output, args.adapter, args.model_config, args.model_python, args.dry_run)
+        elif args.command == 'gpu-check':
+            from .live import check
+            result = check(args.config, args.tracks)
+        elif args.command in ('evaluate', '_worker'):
+            from .pipeline import run, worker
+            result = run(args.config, args.tracks, args.output, args.dry_run) if args.command == 'evaluate' else worker(args.config, args.track, args.output)
+        elif args.command == 'adapter-check':
+            from .adapter import Request, SPECS, load_adapter, predict
+            config = json.loads(Path(args.config).read_text()) if args.config else {}
+            result = {'mode': 'synthetic_interface_check', 'tracks': {}}
+            for track, spec in SPECS.items():
+                adapter = load_adapter(args.adapter, config)
+                predict(adapter, Request(track, 'Maintain your current speed.', {'cameras': {}, 'speed_m_s': 2.0}, spec))
+                result['tracks'][track] = 'valid'
+                close = getattr(adapter, 'close', None)
+                if close: close()
+        else:
+            root = discover(args.workspace)
+            result = {'workspace': str(root), 'interpreters': {t: (root / '.l2d/envs' / t / 'bin/python').is_file() for t in TRACKS}, 'data_access': 'See docs/INSTALLATION.md; doctor does not assert dataset/runtime readiness'}
+        print(json.dumps(result, indent=2, allow_nan=False))
+        if args.command in ('evaluate', 'run') and any(v.get('status') == 'failed' for v in result['tracks'].values()):
+            return 1
+        if args.command == 'gpu-check' and not result['ready']:
+            return 1
+        return 0
+    except Exception as error:
+        parser.exit(2, f'language2drive: {error}\n')
+
+
+if __name__ == '__main__':
+    sys.exit(main())

l2d_benchmark/configure.py

@@ -0,0 +1,33 @@
+"""Generate one evaluation configuration from the standard downloaded layout."""
+import json
+from pathlib import Path
+from .workspace import TRACKS, discover
+
+
+def configure(workspace, destination, gpu=0, **paths):
+    root = discover(workspace)
+    def chosen(name, default):
+        return str(Path(paths.get(name) or default).expanduser().resolve())
+    real = root / TRACKS['realsim']
+    real_work = Path(chosen('realsim_work_dir', real / '.runtime-env'))
+    bundle = Path(chosen('realsim_bundle', real / 'assets/langauge2drive.RealSim'))
+    scenes = chosen('realsim_scenes', real / 'scenes')
+    cfg = dict(workspace=str(root), endpoint='http://127.0.0.1:8090',
+               model=dict(name='custom', seed=0), tracks={
+        'carla': dict(managed_runtime=True, gpu=gpu, tier='base', splits=['dev', 'test'], seeds='1', host='127.0.0.1', port=2000),
+        'realsim': dict(managed_runtime=True, gpu=gpu, python=str(real_work / 'venv/bin/python'),
+                        bundle=str(bundle), scene_root=scenes, ego_hood_dir=chosen('ego_hood_dir', real / 'assets/ego-hoods'),
+                        public_workload=str(bundle / 'compiled/public_workload.json'), sidecar=str(bundle / 'compiled/sidecar.json'),
+                        pcus=str(bundle / 'pcus.json'), eval_config=str(bundle / 'runtime/eval.json'), usdz_glob=scenes+'/*.usdz', concurrency=1),
+        'nuscenes': dict(sensor_root=chosen('nuscenes_root', root / TRACKS['nuscenes'] / 'assets/nuscenes'), split='heldout', conditions=['canonical'], seed=0),
+        'navsim': dict(sensor_root=chosen('navsim_root', root / TRACKS['navsim'] / 'assets/openscene-v1.1/sensor_blobs/test'),
+                       sidecars=chosen('navsim_sidecars', root / TRACKS['navsim'] / 'assets/private_sidecars'), scorer='corrected',
+                       conditions=['canonical', 'paraphrase_1', 'paraphrase_2', 'paraphrase_3']),
+        'wod': dict(release_dir=chosen('wod_release', root / TRACKS['wod'] / 'prerelease/v0.1.0'),
+                    contracts_dir=str(root / TRACKS['wod'] / 'contracts/wod-e2e-p0-v0.1.0'))})
+    path = Path(destination).resolve()
+    if path.exists():
+        raise ValueError('Configuration already exists; preserve it or choose another --output')
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(cfg, indent=2)+'\n')
+    return dict(config=str(path), gpu=gpu, next='language2drive gpu-check --config ' + str(path))

l2d_benchmark/installed_wheel.py

@@ -0,0 +1,46 @@
+"""Reuse the installed distribution when provisioning isolated runtime environments."""
+import base64
+import csv
+import hashlib
+from importlib.metadata import distribution
+import io
+from pathlib import Path, PurePosixPath
+import zipfile
+
+
+def cached_wheel(root, dry_run=False):
+    dist = distribution('language2drive')
+    destination = Path(root) / '.l2d/wheels' / ('language2drive-' + dist.version + '-py3-none-any.whl')
+    if dry_run:
+        return destination
+    payload, records = {}, []
+    for item in dist.files or []:
+        name = str(item)
+        # Generated launchers live outside site-packages and are regenerated by pip.
+        if '..' in PurePosixPath(name).parts or item.suffix == '.pyc' or name.endswith('.dist-info/RECORD'):
+            continue
+        source = Path(dist.locate_file(item))
+        if not source.is_file():
+            raise FileNotFoundError('Installed distribution is incomplete: ' + name)
+        data = source.read_bytes()
+        if item.hash and item.hash.mode == 'sha256':
+            digest = base64.urlsafe_b64encode(hashlib.sha256(data).digest()).decode().rstrip('=')
+            if digest != item.hash.value:
+                raise ValueError('Installed package was modified: ' + name + '; provide --package explicitly')
+        payload[name] = data
+    if not any(name.endswith('.dist-info/WHEEL') for name in payload):
+        raise ValueError('Cannot reuse an editable distribution; supply --package /path/to/checkout')
+    for name, data in payload.items():
+        digest = base64.urlsafe_b64encode(hashlib.sha256(data).digest()).decode().rstrip('=')
+        records.append([name, 'sha256=' + digest, len(data)])
+    record = next(n.rsplit('/', 1)[0] + '/RECORD' for n in payload if n.endswith('.dist-info/WHEEL'))
+    records.append([record, '', ''])
+    stream = io.StringIO(); csv.writer(stream, lineterminator='\n').writerows(records)
+    payload[record] = stream.getvalue().encode()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_suffix('.tmp')
+    with zipfile.ZipFile(temporary, 'w', compression=zipfile.ZIP_DEFLATED) as archive:
+        for name, data in payload.items():
+            archive.writestr(name, data)
+    temporary.replace(destination)
+    return destination

l2d_benchmark/live.py

@@ -0,0 +1,136 @@
+"""Host-side orchestration; native runtime and scoring authorities are preserved."""
+from contextlib import contextmanager, nullcontext
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+from urllib.parse import urlparse
+from .pipeline import environment, load_config, run
+from .processes import Services
+from .workspace import TRACKS
+
+
+def check(config_path, selected):
+    config = load_config(config_path)
+    root = Path(config['workspace'])
+    checks = []
+    def record(name, valid, remedy):
+        checks.append(dict(name=name, ready=bool(valid), remedy=None if valid else remedy))
+    try:
+        gpu = subprocess.run(['nvidia-smi', '--query-gpu=index,name,memory.free,utilization.gpu',
+                              '--format=csv,noheader'], capture_output=True, text=True, timeout=15)
+        record('NVIDIA driver', gpu.returncode == 0, gpu.stderr.strip() or 'Run on the GPU host, outside a sandbox that hides NVIDIA devices.')
+        gpu_inventory = gpu.stdout.strip().splitlines() if gpu.returncode == 0 else []
+    except (OSError, subprocess.TimeoutExpired) as error:
+        record('NVIDIA driver', False, str(error)); gpu_inventory = []
+    for track in selected:
+        cfg = config['tracks'][track]
+        default = root / (TRACKS[track] + '/.runtime-env/venv/bin/python') if track == 'realsim' else root / '.l2d/envs' / track / 'bin/python'
+        python = str(cfg.get('python', default))
+        installed = Path(python).is_file()
+        remedy = 'Run language2drive setup --tracks ' + track + (' --runtime' if track in ('carla', 'realsim') else '')
+        record(track + ' interpreter', installed, remedy)
+        if installed:
+            modules = 'numpy, shapely, PIL'
+            if track == 'carla':
+                modules += ', carla, py_trees'
+            elif track == 'realsim':
+                modules += ', grpc, alpasim_runtime, alpasim_physics, alpasim_controller, language2drive_realsim'
+            try:
+                imported = subprocess.run([python, '-c', 'import ' + modules], capture_output=True,
+                                          text=True, timeout=30, env=environment(root, track))
+                ready = imported.returncode == 0
+                detail = imported.stderr.strip()[-1200:]
+            except (OSError, subprocess.TimeoutExpired) as error:
+                ready, detail = False, str(error)
+            record(track + ' runtime imports', ready, remedy + '. ' + detail)
+        for key in ('sensor_root', 'sidecars', 'release_dir', 'contracts_dir', 'public_workload', 'sidecar', 'pcus', 'eval_config', 'bundle', 'scene_root', 'ego_hood_dir'):
+            if key in cfg:
+                record(track + ' ' + key, Path(cfg[key]).exists() and 'PATH/TO' not in cfg[key], 'Provide the authorized resource path in tracks.' + track + '.' + key)
+        if track == 'carla':
+            record('CARLA 0.9.16 binary', (root / TRACKS[track] / 'carla_runtime/CarlaUE4/Binaries/Linux/CarlaUE4-Linux-Shipping').is_file(), 'Run setup --tracks carla --runtime --download')
+            if cfg.get('managed_runtime'):
+                record('CARLA release launcher authority', os.geteuid() == 0, 'The native release launcher requires a root-owned deployment and a non-root sim user. Use the native host guide or an already-running authorized server.')
+                record('CARLA frozen runtime manifest', (root / TRACKS[track] / '.runtime/carla_runtime_assets.current.json').is_file(), 'Bootstrap the native server, then run l2d freeze-runtime-assets. See docs/GPU_EVALUATION.md.')
+        if track == 'realsim' and cfg.get('managed_runtime'):
+            try:
+                driver = subprocess.run(['nvidia-smi', '--query-gpu=driver_version',
+                    '--format=csv,noheader', '--id=' + str(cfg.get('gpu', 0))],
+                    capture_output=True, text=True, timeout=15)
+                versions = driver.stdout.strip().splitlines()
+                supported = driver.returncode == 0 and bool(versions) and all(
+                    int(version.split('.')[0]) >= 570 for version in versions)
+                detail = ', '.join(versions) or driver.stderr.strip()
+            except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+                supported, detail = False, str(error)
+            record('RealSim pinned renderer driver requirement', supported,
+                'Pinned AlpaSim/NuRec declares NVIDIA driver >= 570.x; detected: ' + detail
+                + '. CUDA visibility alone does not verify renderer compatibility.')
+            try:
+                result = subprocess.run(['docker', 'info', '--format', '{{json .Runtimes}}'], capture_output=True, text=True, timeout=15)
+                valid = result.returncode == 0 and 'nvidia' in result.stdout
+            except (OSError, subprocess.TimeoutExpired):
+                valid = False
+            record('RealSim Docker NVIDIA runtime', valid, 'Install NVIDIA Container Toolkit and authorize Docker access on the GPU host.')
+    return dict(ready=all(row['ready'] for row in checks), checks=checks, gpu_inventory=gpu_inventory,
+                gpu_experiments_executed=False)
+
+
+@contextmanager
+def carla_server(root, cfg, target):
+    if not cfg.get('managed_runtime'):
+        yield
+        return
+    if os.geteuid() != 0:
+        raise RuntimeError('Native CARLA release launcher requires root; see docs/GPU_EVALUATION.md. An external server can use managed_runtime=false.')
+    backend = root / TRACKS['carla']
+    env = environment(root, 'carla')
+    env['L2D_PYTHON'] = str(cfg.get('python', root / '.l2d/envs/carla/bin/python'))
+    port = int(cfg.get('port', 2000))
+    with Services(target / 'services') as services:
+        services.start('carla', ['bash', str(backend / 'tools/start_external_carla.sh'),
+                               '--port', str(port), '--gpu-rank', str(cfg.get('gpu', 0))],
+                       backend, env, port, int(cfg.get('startup_timeout_s', 240)))
+        yield
+
+
+def launch(config_path, selected, output, adapter=None, model_config=None, model_python=None, dry_run=False):
+    config = load_config(config_path)
+    root, output = Path(config['workspace']), Path(output).resolve()
+    model = config.get('model_service', {})
+    adapter = adapter or model.get('adapter')
+    if not adapter:
+        raise ValueError('run requires --adapter or model_service.adapter; use evaluate for an external model service')
+    python = model_python or model.get('python', sys.executable)
+    parsed = urlparse(config.get('endpoint', 'http://127.0.0.1:8090'))
+    if parsed.scheme != 'http' or parsed.hostname != '127.0.0.1':
+        raise ValueError('Managed model service requires an http://127.0.0.1:PORT endpoint')
+    command = [str(python), '-m', 'l2d_benchmark.cli', 'serve', '--adapter', str(Path(adapter).resolve()), '--port', str(parsed.port or 8090)]
+    model_config = model_config or model.get('config')
+    if model_config:
+        command.extend(['--config', str(Path(model_config).resolve())])
+    if dry_run:
+        plan = run(config_path, selected, output, True)
+        plan['model_service'] = command
+        plan['runtime_groups'] = {g: [t for t in ts if t in selected] for g, ts in
+                                  {'carla': ['carla'], 'realsim': ['realsim'], 'openloop': ['nuscenes', 'navsim', 'wod']}.items()}
+        return plan
+    readiness = check(config_path, selected)
+    if not readiness['ready']:
+        output.mkdir(parents=True, exist_ok=True)
+        (output / 'preflight.json').write_text(json.dumps(readiness, indent=2))
+        raise RuntimeError('GPU/resource preflight failed; see ' + str(output / 'preflight.json'))
+    combined = dict(tracks={}, runtime_groups=['carla', 'realsim', 'openloop'], cross_track_aggregate=None)
+    with Services(output / 'model-service') as services:
+        services.start('model', command, root, environment(root, 'carla'), parsed.port or 8090)
+        for track in selected:
+            manager = carla_server(root, config['tracks'][track], output / track) if track == 'carla' else nullcontext()
+            try:
+                with manager:
+                    report = run(config_path, [track], output)
+                combined['tracks'].update(report['tracks'])
+            except Exception as error:
+                combined['tracks'][track] = dict(status='failed', error=str(error))
+            (output / 'summary.json').write_text(json.dumps(combined, indent=2))
+    return combined