@inventure71/paddockjs 4.1.0 → 4.3.0

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 4.3.0
+
+### Minor Changes
+
+- baed285: Compose package mounting, theme resolution, environment results/sensors, track indexing, wheel sampling, pit service and shared race policies through focused owners while preserving public export surfaces and deterministic numerical behavior. Share component actions and per-surface bindings so repeated controls/overviews operate correctly; preserve callback isolation and reject restart while startup owns mounted DOM.
+
+  Add cooperative controller cancellation through optional context.signal, configurable evaluation lapScope using recorded lap times, consistent contact metrics/rewards, and reliable per-driver episode horizons. Reject collisions among resolved driver numbers, including automatic fallbacks. Honor partial sensor overrides while preserving explicit per-ray lengths and keep runtime query diagnostics isolated per simulation.
+
+  Restore compact JSON track geometry for external browser rendering, retain authoritative live observations, and cancel stale frame/action lifetimes.
+
+  Keep driver overview custom fields compatible with both object and array forms, and give constrained demo panels definite heights so their internal scrolling contains content.
+- 679e650: Add opt-in Grid Walk discovery with preparing crew, full entry names, the shared race project banner and ordinary host-provided links. Adapt the camera to actual wide/tall component dimensions while preserving the same world, selected entry and exact paused race progress. Include keyboard/touch selection, focus restoration, reduced motion and static/hidden rendering suspension. Existing consumers retain Race defaults.
+
+  Use the race UI controls and project banner for Grid Walk, add walking grid visitors and support mouse/touch dragging and wheel/keyboard camera browsing. Lock dragging to the camera orientation, keep the selector at the top and project details at the bottom without an extra inspector. Respect reduced motion and host ambient settings without a motion toggle.
+
+  Compose camera input, controls, labels, banner and chrome layout as focused components. Constrain every input to the active camera axis, retain framing/label visibility on selection and dismissal, pack labels without collisions in constrained containers, and use opaque themed label surfaces. Honor shared banner sizing/visibility/mute options and snap staging display headings without changing Race smoothing.
+
+  Complete loading for fresh Grid Walk surfaces on restart so entry banners never retain startup placeholders after the renderer is ready.
+
+  Use compact labels in short vertical scenes as well as horizontal scenes, keeping long-named entries reachable between the shared controls and project banner.
+
+  Move view switching outside the scene with separately mountable package controls. Release wheel scrolling to the page at grid limits and preserve browser pinch/zoom. Extend visitors' routes beyond every reachable camera view without moving existing people on resize, and vary preparation crew counts, positions and activity.
+
+  Add `ui.viewControls: 'toggle'` as an alternative to the default Grid Walk / Race switch: a single Start race / Stop race button pauses to the original display grid and resumes saved progress. Center the project selector and its text, fill the available camera-control row, and keep adjacent controls stable when action labels change. Maintain a continuous visitor flow with stable per-lane spacing, bounded gait variation and offscreen-only additions when routes grow.
+
+  Color the single Start/Stop action with semantic green/red flag colors in both themes. Give visitors visibly irregular gaps, broader lateral paths and independent bounded pace/sway while retaining continuous coverage and offscreen recycling.
+
+  Preserve host/page scroll ownership: release wheel events at Race zoom limits, enable native Race touch scrolling, and leave browser/host-owned input untouched. Fix the main demo output scroll handoff and scope Playable keyboard input to its focused running scene.
+- 5bd5875: Rebuild the opt-in advanced vehicle dynamics and both built-in racing controllers around physical tire-force, braking-envelope, recovery, and traffic behavior. Advanced-mode trajectories and grip distributions change, so hosts should reevaluate or retrain existing advanced controllers and checkpoints.
+
+  Harden browser and composable-controller lifecycle behavior, add a package-default product demo and release smoke gate, bound procedural-track caching, preserve host-owned driver-model metadata across supported input forms, optimize replay/collision/render and observation hot paths, and unify shared public team types.
+
+  Refresh PixiJS and the release toolchain onto patched dependency lines, add high-severity release audits, verify the minimum supported Node version in CI, and require the exhaustive release gate before automated npm publishing.
+
+## 4.2.0
+
+### Minor Changes
+
+- Tighten the package boundary around supported simulator, environment, display, data, and Python policy-server example surfaces. Local JavaScript training experiments now live outside the published package surface, and release-facing docs no longer advertise the removed local starter trainer as packaged guidance.
+- Keep browser expert resets aligned with the resolved `physicsMode` and harden unsupported physics-mode handling so documented hosts continue to use only `arcade` or `advanced`.
+- Add stricter CLI validation for release and diagnostic scripts. Browser smoke, consumer smoke, bundle-boundary checks, runtime benchmarks, track-query benchmarks, and hotspot profiling now provide clean help output and reject unknown or conflicting arguments before running expensive work.
+- Clean up showcase/package-boundary examples so rendered snippets import only public package symbols and leave preview-local policy adapters as host-owned code.
+
+### Performance And Runtime
+
+- Reduce hot-loop allocations in built-in driver control by reusing racing-line profiles, traffic scan entries, lookahead sample objects, and target-point scratch while preserving the same steering/throttle/brake action contract.
+- Add allocation-light track sampling helpers and a prepared sample-index lookup table so repeated `pointAt`/heading/curvature queries avoid binary-search and temporary-object churn on the common simulation paths.
+- Reuse vehicle geometry, body AABB, swept AABB, and interpolated body-shape containers across collision and render paths instead of rebuilding geometry wrappers and axis objects every step.
+- Reuse participant-interaction serialization for render snapshots and avoid repeated spread/object reconstruction in participant interaction resolution.
+- Reduce per-step race/rules/timing churn by replacing transient race-order maps, steward review spreads, repeated inactive-steward state objects, and sector serialization maps with pooled or direct loop paths.
+- Keep advanced/simulator-mode checks behind one helper so browser expert resets, red-flag release, collision damping, driver stabilization, and external state placement stay aligned with the documented `physicsMode` contract.
+
+### Fixes And Hardening
+
+- Preserve the resolved advanced physics mode when the browser expert adapter resets its environment, so expert-controlled browser runs do not silently fall back to arcade behavior.
+- Keep unsupported browser and headless `physicsMode` values normalized to `arcade`, including explicit regression coverage for both surfaces.
+- Carry optional `driverModel` metadata from driver or vehicle input into runtime car state for host-owned model/controller bookkeeping without adding a package-owned model loader.
+- Tighten the environment performance characterization threshold for vector/object observation runs so ray-enabled physical-driver observations remain under the fixed local timing budget.
+
+### Showcase And Tooling
+
+- Add a playable-preview physics selector so the keyboard workbench can switch between arcade and advanced physics through the same documented query-parameter path as the rest of the preview.
+- Add the `scripts/profile-hotspots.mjs` local profiling helper for advanced-mode race hot spots, with validated `--steps`, `--help`, and extra-argument handling.
+- Split browser-smoke and runtime-benchmark argument parsing into focused helpers with direct unit coverage, and extend script coverage across consumer smoke, bundle-boundary, track-query benchmark, and profiler entrypoints.
+- Keep the packed release contents focused on published package assets, docs, Python policy-server examples, source modules, public styles, and placeholder assets.
+
+### Migration Notes
+
+- No breaking host migration is required from `4.1.0`.
+- Supported browser mounts, composable mounts, `@inventure71/paddockjs/environment`, `@inventure71/paddockjs/data`, and `@inventure71/paddockjs/placeholder` keep their documented public import contracts.
+- Hosts should not depend on removed repository-local JavaScript training scripts or preview-only policy helper names. Use the documented environment API, custom model controller guide, or Python policy-server bridge for external training and policy integration.
+
+### Verification Notes
+
+- The final release gate is `npm run check:release`.
+
 ## 4.1.0
 
 ### Minor Changes

package/INSTALL_AND_UPDATE.md

@@ -1,5 +1,7 @@
 # PaddockJS Install and Update Guide
 
+For opt-in setup and lifecycle recovery, see [Grid Walk](docs/grid_walk.md). Retry must explicitly invoke `mountF1Simulator()` or `start()` after a failed attempt settles; importing a cached module does not remount. Restore host Retry controls in `finally`. Validate unpublished changes in the package showcase or a temporary packed consumer before a separate host update.
+
 This guide explains how host websites consume the published PaddockJS npm package. For the normal browser integration path, start with [Getting Started](docs/getting-started.md). For split package-owned surfaces, use [Composable Layouts](docs/composable-layouts.md).
 
 ## Install
@@ -114,16 +116,31 @@ npm run check
 Install a specific version when the host needs a controlled upgrade:
 
 ```bash
-npm install @inventure71/paddockjs@4.1.0
+npm install @inventure71/paddockjs@4.3.0
 npm run check
 ```
 
 After updating, smoke-test the page that mounts the simulator. Browser behavior changes should be checked in the consuming host, because host CSS, container size, and route handling are outside the package.
 
+### 4.3.0 Migration Notes
+
+- Existing browser and composable mounts retain Race as their default view. Enable Grid Walk with `gridWalk: { enabled: true, initialView: 'grid-walk' }`. Choose `ui: { viewControls: 'toggle' }` for the green Start race / red Stop race button; the default is the two-button switch. See [Grid Walk](docs/grid_walk.md) for host metadata, external controls, camera sizing and paused-progress behavior.
+- The opt-in `advanced` physics and built-in driving controllers have changed trajectories and grip behavior. Reevaluate or retrain advanced controllers/checkpoints before relying on their previous results; the default physics mode remains `arcade`.
+- Mounting rejects duplicate resolved driver numbers, including an explicit number that collides with another entry's automatic fallback. Supply unique numbers when host data produces a collision.
+- Evaluation defaults to measuring laps completed after evaluation starts. Set `lapScope: 'include-history'` to include an already-recorded lap; see the [data contract](docs/data_contract.md).
+- Retry a failed renderer startup by calling the mount/start API again after the failed attempt settles, and restore host Retry controls in `finally`. Reimporting a cached side-effect entry module does not remount it. See [Startup Loading](docs/loading.md).
+- Browser mounts, public subpath imports and ordinary host-provided project links keep their existing contracts. Test the real host at wide/tall sizes, through live resizing, selection and Grid Walk/Race transitions, and with native page scrolling.
+
+### 4.2.0 Migration Notes
+
+- No breaking host migration is required from `4.1.0`.
+- Browser mounts, composable mounts, `@inventure71/paddockjs/environment`, `@inventure71/paddockjs/data`, and `@inventure71/paddockjs/placeholder` keep their documented public import contracts.
+- Do not rely on repository-local JavaScript trainer scripts or preview-only policy helper names as package API. Local model experiments belong outside the package surface; production integrations should use the documented environment API, custom model controller guide, or Python policy-server bridge.
+
 ### 4.1.0 Migration Notes
 
 - No breaking host migration is required from `4.0.0`.
-- Hosts that want visible simulator startup UI before the full PaddockJS browser bundle downloads can render the new `@inventure71/paddockjs/placeholder` HTML helper with the optional `@inventure71/paddockjs/placeholder.css` stylesheet. This placeholder subpath is intentionally independent of PixiJS, simulator assets, root runtime CSS, and the browser mount.
+- Hosts that want visible simulator startup UI before the full PaddockJS browser bundle downloads can render the new `@inventure71/paddockjs/placeholder` HTML helper with the optional `@inventure71/paddockjs/placeholder.css` stylesheet. This placeholder subpath is intentionally independent of PixiJS, simulator assets, root runtime CSS, and the browser mount. Static HTML hosts should generate the placeholder HTML during their build and copy the CSS into their static output; see [Startup Loading](docs/loading.md).
 - Existing `mountF1Simulator()` and composable `mount*()` integrations keep their normal automatic package loading overlays after PaddockJS JavaScript starts.
 
 ### 4.0.0 Migration Notes
@@ -147,16 +164,25 @@ After updating, smoke-test the page that mounts the simulator. Browser behavior
 
 The package repo owns its release process:
 
+For a fresh checkout or linked worktree, run `npm ci` in the package before the checks below. Root tests resolve repository-site package imports to the current source through the Vitest configuration, so they do not depend on a previous website installation. The package gates install/build the single website once and verify a packed package in fresh consumers. Keep the package, website and private release-tool lockfiles complete, including optional peer dependencies; do not use a warm dependency tree as clean-install evidence.
+
 - `npm run docs:check` validates documentation links and consumer-guidance guardrails.
-- `npm run check` runs docs checks, fast runtime tests, public type verification, dry-pack verification, packed-consumer install/build verification, the tracked showcase build, and a quick Chromium browser smoke test.
-- `npm run check:release` runs the exhaustive release gate, including slow characterization tests and the full Chromium browser smoke matrix.
+- `npm run check` runs docs checks, fast runtime tests, public type verification, dry-pack verification, packed-consumer install/build verification, the single tracked website build, the quick Chromium engineering-showcase smoke, and the complete product-demo smoke.
+- `npm run check:release` installs the locked private release tools, audits the package, website and release tools at high severity, then runs the exhaustive release gate, including slow characterization tests, the full Chromium engineering-showcase matrix, and the complete product-demo smoke. Use a supported release-tool Node version, such as Node 24.
+- The ten-car, three-lap advanced-race characterization has a 90-second wall-clock timeout for shared CI runners. Its simulated-time, finishing, contact and off-road assertions remain the behavior gate; the timeout is only a bounded hang guard.
+- The demo keyboard smoke asserts input capture immediately and allows up to 15 seconds for the rendered physics response on software-rendered CI. It still verifies steering direction, return to stable on-track behavior and input release when focus moves away.
+- `npm run audit:release` installs and audits the private release tools and runs the same three high-severity dependency audits without the rest of the release gate.
 - `npm run consumer:smoke` packs the package, installs the tarball into a fresh temporary Vite app, and builds that app through public package imports.
-- `npm run browser:smoke` builds `local-preview`, starts a local preview server, and checks desktop/mobile canvas rendering, overflow constraints, API buttons, and visual policy-runner stepping in Chromium. Use `npm run browser:smoke:quick` for the smaller local browser pass and `npm run browser:smoke:full` for the full matrix.
+- `npm run consumer:bundle-boundaries` packs the package, installs the tarball into a fresh temporary Vite app, and verifies the root browser import remains the CSS/asset-owning simulator bundle while `/placeholder`, `/data`, and `/environment` stay CSS-free or lightweight according to their documented roles.
+- `npm run site:install` installs the single website; `npm run site:dev` starts its Demo, Guide, Labs and Reference sections on one URL. `npm run site:ci` installs and builds it once, including public-feature inventory validation. Existing `demo:*` and `showcase:*` install/dev/build/ci commands are compatibility aliases to these same commands.
+- `npm run browser:smoke` builds `site`, starts its local preview server, and checks desktop/mobile canvas rendering, overflow constraints, API buttons, and visual policy-runner stepping in Chromium. Use `npm run browser:smoke:quick` for the smaller local browser pass and `npm run browser:smoke:full` for the full matrix.
 - `npm run changeset` records the next version bump and changelog note.
 - `npm run version-packages` applies pending Changesets locally.
 - `.github/workflows/ci.yml` verifies the package on push and pull request.
 - `.github/workflows/release.yml` opens a release PR from Changesets and publishes to npm after merge through npm trusted publishing.
 
+Changesets is release-only tooling, installed separately with `npm run tools:release:ci` in the private `tools/release/` package. It is not an npm workspace and does not change PaddockJS's public Node `>=20.19.0` support. The pinned Changesets 3 toolchain requires Node `^22.11 || ^24 || >=26`; Node 24 is used by the release workflow. The root Changesets launcher keeps the repository root as its working directory and forwards arguments to the isolated tool. For a read-only preflight, run `npm run changeset -- status`. The release workflow uses Changesets action v2 with explicit version/publish scripts and still publishes through `npm publish --provenance`. That publisher does not return Changesets' structured publication output, so automatic published-package reporting and tag/release creation are not established by local validation. Any publishing-flow redesign needs separate verification and authorization.
+
 For trusted publishing on npm, configure the package settings to trust:
 
 - organization or user: `Inventure71`

package/README.md

@@ -58,6 +58,8 @@ PaddockJS CSS is scoped under package mount/component roots and uses system font
 
 `mountF1Simulator(root, options)` writes a lightweight package-owned HTML shell into `root` before it awaits PixiJS setup, asset loading, control binding, simulation creation, and the first canvas frame. That shell includes package loading overlays for the race controls, timing tower, race canvas, race-data panel, telemetry stack, and any other startup-capable package surface in the selected template. The overlays are removed only after the runtime has initialized and the initial readouts/frame are ready.
 
+One host root may own only one live all-in-one simulator. Call the returned controller's `destroy()` before mounting into that root again. If initialization fails, PaddockJS destroys the partial runtime, clears the root, and releases it so the host can retry.
+
 Composable hosts get the same behavior per mounted root: every public `simulator.mount*()` surface renders static package markup plus its own loading overlay before `await simulator.start()`.
 
 This is a client-side startup shell, not server rendering. If a host wants visible content before the PaddockJS JavaScript bundle has downloaded and executed, use the tiny placeholder subpath and CSS:
@@ -82,11 +84,12 @@ if ('requestIdleCallback' in window) {
 }
 ```
 
-`@inventure71/paddockjs/placeholder` does not import PixiJS, simulator assets, package runtime CSS, or the root browser mount. It is intended for the pre-JS/network gap. The full simulator mount replaces that placeholder and then uses the built-in package overlays while PixiJS and the race runtime finish booting.
+`@inventure71/paddockjs/placeholder` does not import PixiJS, simulator assets, package runtime CSS, or the root browser mount. It is intended for the pre-JS/network gap. The full simulator mount replaces that placeholder and then uses the built-in package overlays while PixiJS and the race runtime finish booting. Static HTML hosts should run the placeholder helper in their build step and copy `@inventure71/paddockjs/placeholder.css` into their static output instead of expecting a plain browser page to resolve bare npm imports.
 
 Start here:
 
 - [Getting Started](docs/getting-started.md): install, browser mount, CSS, assets, host responsibilities, and container sizing.
+- [Startup Loading](docs/loading.md): pre-JS placeholders, package loading overlays, and static-host build-time integration.
 - [Data Contract](docs/data_contract.md): driver, entry, callback, rules, and option shapes.
 - [Troubleshooting](docs/troubleshooting.md): common integration failures and supported checks.
 
@@ -109,6 +112,8 @@ simulator.mountRaceDataPanel(document.getElementById('sim-race-data'));
 await simulator.start();
 ```
 
+Each composable surface key owns one host root. Mounting the same surface into a replacement root clears the previous root, while mounting two different surfaces into the same root is rejected. Concurrent `start()` callers await the same initialization; a failed start destroys the partial app and may be retried on the same controller.
+
 The controller methods are the canonical composable API. See [Composable Layouts](docs/composable-layouts.md) for the available surfaces, lifecycle, restart behavior, and sizing contract.
 
 ## Headless And Data Subpaths
@@ -167,6 +172,17 @@ Normal consumers should start with the task docs above. These reference docs are
 - [Architecture](docs/architecture.md): module ownership and data/control flow for package contributors.
 - [Component Inventory](docs/component_inventory.md): package-owned UI surfaces and template ownership.
 
+## Demo, Guide And Labs
+
+[`site/`](site/README.md) is the repository's single website and package integration host. One server and build provide:
+
+- `/`: the live product demo, starting in Grid Walk, with Race controls, composable surfaces, presets, advanced physics, a headless example and searchable feature inventory.
+- `/guide/`: focused integration guides for templates, components, customization, API, Grid Walk and race rules.
+- `/labs/`: playable controls, behavior and stewarding fixtures, collision diagnostics and Policy Runner.
+- `/reference/`: readable pages generated from the repository's package documentation.
+
+Shared navigation connects every section. Old root-level showcase URLs redirect to their canonical Guide or Labs route while preserving query parameters and fragments. The site installs this checkout through the package boundary. Its explicitly labeled collision and Policy Runner tools also use private geometry and presentation diagnostics; those modules are not supported consumer exports. Website files are excluded from the npm package.
+
 ## Package Workflow
 
 Useful local commands:
@@ -175,13 +191,28 @@ Useful local commands:
 npm run docs:check
 npm run check
 npm run check:release
+npm run audit:release
 npm run consumer:smoke
+npm run consumer:bundle-boundaries
 npm run browser:smoke:quick -- --skip-build
-npm run showcase:dev
+npm run site:install
+npm run site:dev
+npm run demo:smoke
 ```
 
-`npm run check` is the normal local gate: docs checks, fast runtime tests, public declarations, dry package contents, packed-package consumption in a fresh Vite app, the showcase build, and a quick Chromium smoke against the showcase. `npm run check:release` adds slow characterization tests and the full browser smoke matrix.
+`npm run check` is the normal local gate: docs checks, fast runtime tests, public declarations, dry package contents, packed-package consumption in a fresh Vite app, packed subpath bundle-boundary checks, one website install/build, the quick Guide/Labs browser smoke, and the complete demo smoke. `npm run check:release` installs the locked private release tools and audits the package, website and release-tool dependency graphs, then adds slow characterization tests and the full Guide/Labs browser matrix while retaining the demo smoke. Run release checks/Changesets commands on a supported release-tool Node version, such as Node 24; the simulator package and ordinary checks still support Node 20.19. See [Install and Update](INSTALL_AND_UPDATE.md) for the tooling boundary and release workflow.
+
+## Grid Walk (opt-in)
+
+Pass `gridWalk: { enabled: true }` to either mounting API to explore the starting grid before racing. Supply entry `presentation` metadata for full names, summaries and ordinary links in the same bottom project banner used by Race. The arrow selector sits centered at the top, with centered entry text; Grid Walk adds no separate project details panel.
+
+Its package-styled Grid Walk / Race switch lives outside the scene: mount `simulator.mountViewControls(viewControlsRoot)` before `start()` alongside a composable `mountRaceCanvas()`, or use the equivalent `mountViewControls(viewControlsRoot, simulator)` helper. The all-in-one shell and race telemetry drawer include these controls above the scene automatically. Choose `ui: { viewControls: 'toggle' }` for one green **Start race** / red **Stop race** button instead of the default two-button switch. Stop pauses the race and returns to its original display grid; Start resumes saved progress. The main demo demonstrates this single-button option.
+
+`setView('grid-walk' | 'race')` switches presentation without resetting progress; the same grid camera rotates for actual component dimensions and supports drag, touch and wheel browsing. Wheel browsing scrolls the host page when the grid reaches an end; Ctrl/Meta wheel retains browser zoom. Race wheel zoom also yields at its limits, and Race touch gestures keep native page scrolling. Input interception stays on simulator surfaces; the package does not lock body/document scrolling. Grid Walk reuses race controls and panels, with varied preparation crews and a continuous flow of visitors entering and leaving beyond the camera bounds. Existing consumers retain Race defaults. See [Grid Walk](docs/grid_walk.md) for the API, lifecycle and example, or open `/guide/grid-walk.html` on the website. The main demo also starts with Grid Walk.
 
 ## License
 
 PaddockJS is released under `Apache-2.0`. See [LICENSE](LICENSE).
+
+
+Advanced physics remains opt-in with `physicsMode: 'advanced'`; ordinary mounts and demos default to arcade. Advanced mode uses a planar Formula-style tire-force model with load transfer, yaw inertia and aerodynamic forces. Its keyboard lab is available in the demo's Advanced physics chapter. See [physics rules](docs/rules.md#physics-modes) and [model scope and validation](docs/advanced_physics_rebuild.md) for the calibration, approximations and verification evidence.

package/docs/advanced_ai_pace.md

@@ -0,0 +1,131 @@
+# Advanced AI pace improvement
+
+This records the first September 9 improvement. The subsequent [both-mode racing AI report](racing_ai_improvements.md) uses this implementation as its baseline.
+
+## Goal and boundaries
+
+Improve the built-in advanced driver through measurable lap-time gains under unchanged vehicle physics. Arcade remains the default. This is not a claim of globally optimal driving or a change to model-facing observations/actions. Preserve traffic, recovery, safety-car, pit and deterministic replay contracts.
+
+## Checkable plan
+
+- [x] Inspect current Git and advanced controller; preserve all existing work in place.
+- [x] Run baseline `npm run check` and record any pre-existing failures.
+- [x] Measure identical single-car stints across development and held-out track seeds, plus complete representative demo fields. Record lap times, off-road time, DNFs and repeat hashes.
+- [x] Diagnose pace losses and compare bounded controller candidates without changing physics.
+- [x] Integrate the smallest coherent improvement, add behavioral regression coverage and update authoritative docs.
+- [x] Run `npm run check`, `npm run check:release`, browser flows and paired runtime benchmarks.
+- [x] Log results in Linear and report read-only Git status and proposed next steps.
+
+## Ownership before implementation
+
+`advancedRacingControls` owns race pace and traffic-aware target selection, reading track geometry and existing lane plans. `advancedPathControls` owns physical steering/longitudinal action conversion and is shared with recovery/safety-car driving, so racing-only changes must remain explicit. The vehicle modules own tire, force, aero and integration rules; they are read-only dependencies for this task. The race facade owns car lifecycle and state; the driver returns only steering/throttle/brake, with no pose writes or extra grip.
+
+Inputs are current vehicle capability/state, track geometry and traffic. Outputs are existing bounded physical controls. Failure modes include optimistic future grip, braking too late, rear saturation on corner exit, off-road excursions, tire-wear regressions, traffic collisions, recovery stalls and slower CPU execution. Verification combines fixed-step production simulation, independent handling/contract tests, complete races and browser smoke.
+
+## Baseline
+
+Source snapshot: `/tmp/paddockjs-ai-pace-20260909/baseline`. Branch `v11`, HEAD `fedff4e`; index empty, extensive pre-existing working changes. No remote refresh or Git mutation.
+
+## Investigation evidence and rejected approaches
+
+Baseline `npm run check` passed: 1015 fast tests, 84 slow skips, types, packing/consumer builds, showcase/demo builds and Chromium smoke. Baseline eight development and eight held-out single-car three-lap stints had zero off-road time or DNFs. Six complete demo fields finished 60/60 with zero DNFs.
+
+- `advancedPathControls.js`: proportional pedal demand drops to zero at the target, so drag creates steady speed error. Actual straight tests at targets 40/60/80 m/s settled at 39.194/57.534/74.672 m/s. Physical resistance compensation fixes this without adding grip.
+- `advancedRacingControls.js`: the old preview uses current-speed downforce for future corners and a fixed 7 m/s² braking envelope. A force-based preview can be faster, but the controller response must be fast enough to follow its braking ramp. Early candidates caused two reproducible barrier retirements; evolve's slip began while braking on healthy tires, with no preceding collision. These candidates are rejected.
+- Raising the old corner margin alone gave faster solo laps but worse full fields. Steering gain/lookahead changes were negligible; inverse-brush steering and extra per-wheel traction budgeting did not solve the braking regression. Their extra code is not retained.
+- Existing traffic penalties subtract a fixed speed amount without matching a slower car's actual speed. A same-lane following target based on physical gap and closing speed reduced the difficult field's contacts from 18 to 9 in an intermediate comparison.
+- A fixed-point corner solver left up to 10.15 km/h unused in a representative 200 m radius corner. A bounded chord solve in speed squared uses the physical model's concavity to approach the limit conservatively. Independent comparison across 7728 curvature/tire/surface/DRS cases found no overshoot, maximum error 0.000237 m/s and mean 2.85 capacity evaluations. These are numerical call counts, not a runtime speedup claim.
+
+All experiments and frozen source copies are under `/tmp/paddockjs-ai-pace-20260909/`. Final acceptance must use the complete combined candidate, not cherry-picked single-car results.
+
+## Accepted implementation
+
+The final candidate preserves the 60% corner-grip share and steering/lookahead calibration. It uses a conservative candidate-speed corner solve, a backward braking envelope and force feedback with a 62.5 ms response target. A slower response missed the braking envelope; a separate target-acceleration feedforward term caused premature braking and was discarded. Drag/rolling compensation eliminates the straight-line steady-speed deficit while the existing longitudinal tire budget limits the pedals.
+
+Following speed uses chassis-center lateral positions, physical longitudinal gap and the other car's speed. Selection filters actual lateral overlap before choosing a blocker; a nearby adjacent car cannot hide a farther blocker. Retired and non-colliding participants do not impose this additional physical following constraint. Existing shared lane planning and traffic penalties remain intact. Production tests cover same-lane braking, adjacent masking and overlapping cars on opposite sides of the centerline. The centerline point/normal already retained by wheel-surface state supplies center offsets; representative wheel offsets are not used as chassis coordinates. Pit-route state retains `mainTrackSignedOffset`, which keeps pit and main-road comparisons in the same coordinate system. Regression tests cover both a separate pit lane and an overlapping merge.
+
+The drag-factor helper extraction preserves the exact force expression. No physics constants, grip, mass, power, contacts, public actions, observation precision, arcade defaults, pit ownership or timing-board dimensions change.
+
+## Driving measurements
+
+Environment: Node v24.13.0, Darwin arm64, fixed simulation step 1/60 s. Each before/after comparison uses identical seeds, vehicles, rules and track generation. Driving times are simulated seconds, not wall-clock execution times. Artifacts and source snapshots are in the task directory above.
+
+Solo trials use seed 100, the first bundled project driver, three laps, standing-start sequencing disabled and tire degradation disabled. Reported flying time is the mean of laps two and three. The first eight seeds are development cases; the last eight are held-out tracks. All 16 complete with zero off-road time and zero DNFs, before and after.
+
+| Track seed | Before flying lap (s) | After flying lap (s) | Quicker |
+| --- | ---: | ---: | ---: |
+| 7109 | 153.492 | 144.167 | 6.08% |
+| 7110 | 178.742 | 168.150 | 5.93% |
+| 7200 | 159.705 | 150.284 | 5.90% |
+| 7201 | 180.262 | 169.517 | 5.96% |
+| 12 | 147.950 | 139.349 | 5.81% |
+| 26 | 130.580 | 123.000 | 5.80% |
+| 61 | 191.017 | 179.783 | 5.88% |
+| 20260427 | 165.217 | 155.567 | 5.84% |
+| 28 | 187.593 | 176.150 | 6.10% |
+| 62 | 171.430 | 161.267 | 5.93% |
+| 69 | 168.767 | 158.598 | 6.03% |
+| 7202 | 147.717 | 138.433 | 6.28% |
+| 7203 | 111.000 | 104.033 | 6.28% |
+| 101 | 145.533 | 136.767 | 6.02% |
+| 9099 | 211.382 | 199.017 | 5.85% |
+| 12345 | 159.267 | 149.667 | 6.03% |
+
+Full fields use the exact six demo configurations, ten normalized driver/entry pairs, existing wear, pits, rules and participant interactions. Hero runs five laps; the others run three. All 60 cars finish before and after; zero DNFs. Race completion improves 2.85–4.04%, and contacts fall from 123 to 44 (64.2%). These are complete race times including race flow and service, not isolated hot laps.
+
+| Field | Before race (s) | After race (s) | Quicker | Contacts | Aggregate off-road (s) |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| hero | 900.433 | 864.083 | 4.04% | 23 → 10 | 0.000 → 5.650 |
+| components | 623.467 | 601.567 | 3.51% | 22 → 7 | 0.000 → 0.100 |
+| dashboard | 554.217 | 532.883 | 3.85% | 24 → 5 | 0.000 → 0.000 |
+| timing-overlay | 630.683 | 609.700 | 3.33% | 26 → 6 | 0.000 → 0.100 |
+| compact-race | 510.667 | 491.167 | 3.82% | 10 → 7 | 8.783 → 0.000 |
+| full-dashboard | 381.683 | 370.817 | 2.85% | 18 → 9 | 1.417 → 3.917 |
+
+Aggregate off-road time falls slightly from 10.20 to 9.77 seconds across the six fields, although hero and full-dashboard individually have more excursions. These excursions recover without retirements. This is not a claim of perfect or globally optimal driving, nor a guarantee over every procedural track, setup or external policy. More aggressive candidates were rejected when race quality worsened substantially or a DNF appeared.
+
+## CPU runtime measurements
+
+Six paired runs of the existing standard 22-workload benchmark, alternating before/after order, all with `--verify`. Same host, Node, profile and workload settings; no concurrent benchmark/test process during these pairs. The accepted simulation/data source matches the measured candidate.
+
+- Advanced 16-car, 180-step field: median 161.720 → 170.199 ms, +5.24%; ranges 157.316–181.689 and 168.306–174.461 ms. Five of six paired comparisons were slower; one baseline outlier overlaps the ranges. This is roughly 0.898 → 0.946 ms per simulation step for that workload, not a browser frame-time claim.
+- Headless vector workload: median 133.194 → 135.363 ms, +1.63%; overlapping ranges 130.515–137.456 and 134.654–137.080 ms. Treat this small median difference as noise, not a demonstrated throughput change.
+
+The improvement is racing pace and control quality, not CPU throughput. The added deterministic planning has a measured cost; no speculative cache or unrelated optimization was introduced. See `runtime-comparison.json` and `benchmarks/` for all workload results.
+
+## Verification and changed ownership
+
+- Baseline package gate passed with no pre-existing failures.
+- Raw advanced handling acceleration/braking/cornering values match the saved baseline exactly; only source-root metadata and measurement runtime differ.
+- All six ordinary arcade demo snapshot hashes match baseline exactly.
+- Independent recovery/safety control comparisons match across 840 speed/target/surface/tire/yaw cases.
+- Independent corner solver comparison: 7728 cases, no overshoot, maximum root error 0.000237 m/s.
+- Final fast suite: 1043 passed, 88 slow tests skipped. Added coverage includes same-lane following, adjacent blockers, chassis-center overlap, separate pit corridors and pit merges.
+- All 16 final solo records exactly match the accepted lap/result/trajectory records. Hero and full-dashboard each repeat twice with identical result, trajectory, event and options hashes and lap histories.
+- Final `npm run check` passed: docs, 1043 fast tests (88 slow skips), public types, dry pack, packed consumers/bundle boundaries, showcase/demo builds and quick Chromium smoke.
+- Final `npm run check:release` passed: all 1131 tests across 61 files, types/pack/consumer/build gates, full Chromium matrix and demo smoke (desktop runtime, public surfaces, presets, expert, headless, search and mobile layout).
+- `git diff --check` passed. No pre-existing gate failure was found.
+
+Changed runtime files: `src/simulation/driver/advancedRacingControls.js`, `advancedPathControls.js`, new `advancedRacePace.js`; `src/simulation/vehicle/advancedVehicleModel.js` and `advancedVehiclePhysics.js` for the identical drag-factor extraction. Added `src/__tests__/advancedRacePace.test.js` and `advancedAIRacing.test.js`, plus reproducible `scripts/benchmark-advanced-ai.mjs` and `benchmark-advanced-ai-fields.mjs`. Updated `docs/rules.md`, `docs/architecture.md`, a follow-up pointer in `docs/advanced_physics_rebuild.md`, and this report. Existing dirty work is preserved; this is an advanced-AI change, not a repository-wide clean audit.
+
+Reproduce driving checks:
+
+```sh
+node scripts/benchmark-advanced-ai.mjs
+node scripts/benchmark-advanced-ai.mjs . 28,62,69,7202,7203,101,9099,12345
+node scripts/benchmark-advanced-ai-fields.mjs . --repeats=2
+npm run check
+npm run check:release
+```
+
+A source-root argument lets the same harness compare a preserved baseline. No Git/GitHub mutation is authorized or performed. Review the combined dirty diff before proposing exact staging/commit actions; do not stage whole mixed files without reviewing their earlier work.
+
+## Closeout
+
+Read-only Git status: branch `v11`, HEAD `fedff4e`, recorded upstream `origin/v11` at 0 ahead/0 behind without fetching. The index is empty; 122 tracked paths are modified and 46 untracked entries are present. Most are earlier ongoing work, which is preserved. No branch, index, commit, remote or GitHub state was changed.
+
+Proposed next step: review the bounded AI diff against the saved task baseline and the combined working diff, then request exact staging/commit approval if desired. No Git next step has been executed.
+
+Work log: [Advanced AI pace measured controller improvements](https://linear.app/mgiorgetti/document/advanced-ai-pace-measured-controller-improvements-884b829d9aac).
+
+Subsequent skill-dependent physical-envelope tuning, timing-line boundary repair and measured limitations are documented in [limit driving, 2026-10-14](limit_driving_2026-10-14.md). Earlier results above describe their recorded candidate.

package/docs/advanced_physics_rebuild.md

@@ -0,0 +1,166 @@
+# Advanced physics rebuild
+
+> Historical implementation report. Website source paths below predate the single-site migration. Current demo and engineering examples live under `site/src/demo/` and `site/src/showcase/`; see [Architecture](architecture.md) for current ownership.
+
+Follow-up: the [advanced AI pace report](advanced_ai_pace.md) records the September 9 controller changes and current driving measurements. The vehicle force model from this rebuild is unchanged.
+
+Status: implementation complete; local package and exhaustive release gates passed. Driving feel remains subject to user feedback and the documented model approximations. Arcade remains the default and its trajectories must remain unchanged.
+
+## Target and scope
+
+Build a deterministic planar Formula-style racing car using the existing 3.6 m wheelbase, 798 kg baseline setup and DRS-era package contract. This is a handling model, not a claim of matching a particular team's confidential tire/aero data. The model must earn its realism through measured response, not a label. Suspension travel, vertical jumps, tire carcass/temperature simulation and detailed gearbox/electrical deployment are outside this planar model.
+
+## Checkable plan
+
+- [x] Inspect dirty Git state and preserve a separate pre-change source snapshot under `/tmp/paddockjs-advanced-rebuild-20260908/baseline`.
+- [x] Audit vehicle, AI, external controls, telemetry and lifecycle boundaries; start the existing package baseline gate.
+- [x] Replace the advanced integrator with four contact-patch forces, yaw inertia, longitudinal/lateral load transfer, nonlinear combined tire forces, rear drive and physically scaled aerodynamic resistance/load. Keep arcade integration byte-for-byte intact.
+- [x] Measure straight-line acceleration/braking, steady cornering, transient steering, force saturation, coast-down, rest/reverse behavior and timestep convergence. Add meaningful regression bounds and an executable characterization report.
+- [x] Adapt advanced-only AI steering/pace/recovery to physical wheel angles and tire capacity; validate actual multi-car demo seeds, safety-car and pit transitions.
+- [x] Check advanced contacts and manual keyboard lifecycle; preserve public normalized actions and exact model-sense visualization ownership.
+- [x] Update authoritative rules/architecture/contracts and the advanced demo description. Record results in Linear.
+- [x] Run `npm run check` and `npm run check:release`, packed-consumer and browser checks, repeat representative runtime measurements, and report every remaining failure honestly.
+
+## Ownership and data flow
+
+`vehiclePhysics.js` selects the public physics mode and retains arcade implementation. Feature-owned advanced modules own physical setup, tire/contact forces and rigid-body integration. Inputs are the current vehicle state, physical wheel-angle/throttle/brake commands, four sampled road surfaces and timestep; outputs update the existing world pose/velocity, yaw rate, speed, tire energy and physics telemetry. Calculations use SI internally, converting world coordinates/velocity at the boundary.
+
+Tire forces come from local contact velocity and normal load. Their force/moment sums accelerate the body; yaw is not assigned from an ideal turn radius. Surface forces are per wheel rather than an averaged surface. Public vehicle setup fields retain their units: `powerNewtons` is a force parameter used to derive a bounded engine-force curve; it is not relabeled as watts. Setup and model constants must have documented units.
+
+Driver policy owns desired path/speed and actuator commands, never pose correction or extra grip. Browser keyboard conditioning belongs at the human input boundary and must not alter environment policy actions. Race/pit/reset/contact modules retain lifecycle ownership; any new persistent state must have explicit reset rules. Prefer forces derived from the existing current state over hidden history.
+
+## Verification criteria and risks
+
+Require exact arcade replay checks, deterministic advanced replays, finite zero-speed behavior, no braking-induced reverse launch, passive force energy dissipation, left/right symmetry, force capacity and load conservation, smoother timestep convergence, faster/harder high-speed braking from aero load, and reduced combined cornering authority under throttle/braking. Compare countersteer against a matched initial slip/yaw state rather than assuming an arbitrary old full-lock sequence must end stable.
+
+Record acceleration/braking distances, speeds and G values before selecting final calibration bounds. Use published performance only as broad plausibility context, since tracks, tires, aero and driver actions differ. Full-field completion, legal-surface time and progress matter alongside unit dynamics. Existing old-model steering-scrub/status assertions may need intentional replacement by these physical behaviors; do not simply delete failing coverage or weaken lifecycle/API assertions.
+
+## Physical references
+
+- [MathWorks Vehicle Body 3DOF](https://www.mathworks.com/help/vdynblks/ref/vehiclebody3dof.html): force/moment balance, wheel-frame transformations and normal-load transfer.
+- [Project Chrono tire models](https://api.chrono.projectchrono.org/wheeled_tire.html): nonlinear tire models, combined slip and the importance of low-speed treatment. The implementation here is a simplified force-based brush approximation, not a calibrated Chrono/Fiala tire dataset.
+- [Formula 1 braking performance explanation](https://www.formula1.com/en/latest/article/rob-smedley-explains-how-the-new-aws-braking-performance-graphic-works-and.3A8cnQLZGXFbMjCR2fFBnB): downforce-dependent braking and peak deceleration context.
+
+
+## Calibration and verification evidence
+
+The baseline `npm run check` passed: 955 fast tests, 84 intentional slow skips, types, package/consumer/build checks and both browser smokes. After the rebuild, the fast test stage passes 1011 tests with the same 84 slow skips; complete package/release results are pending below.
+
+Run `node scripts/characterize-advanced-physics.mjs` for deterministic open-loop handling measurements. Pass a source-root argument to run the same maneuvers against a preserved implementation. At 60 Hz with tire wear disabled, the default 798 kg setup (43000 N power rating, 59000 N braking, 6.1 aero, 0.33 drag, 2.35 grip) gives these local characterization results:
+
+| Maneuver | Previous advanced | Rebuilt advanced |
+|---|---:|---:|
+| 0–100 km/h, DRS closed | 1.83 s | 2.82 s |
+| 0–200 km/h, DRS closed | 3.85 s | 5.10 s |
+| 0–300 km/h, DRS closed | 7.78 s | 13.42 s |
+| 100–below 1 km/h braking | 16.6 m / 1.25 s | 20.0 m / 1.52 s |
+| 200–below 1 km/h braking | 59.4 m / 2.28 s | 59.7 m / 2.48 s |
+| 300–below 1 km/h braking | 120.6 m / 3.18 s | 99.0 m / 3.07 s |
+
+
+These are measured simulation outcomes, not claims of matching a named real car or performance optimizations. No traction-control/ABS system or wheel rotational state is modeled. Tire-force saturation and sliding-brake direction are approximations. Human keyboard steering/pedals are conditioned outside physics; human feel still needs driving feedback.
+
+The new unit coverage verifies static load conservation, transfer direction, load sensitivity, combined adhesion bounds, braking slip direction, near-rest force/energy stability, passive forward/reverse/sideways motion, default simultaneous throttle/brake holding, left/right symmetry, low-speed wheelbase curvature, 60/120 Hz convergence, actual velocity/G telemetry, and deterministic replay. The old arbitrary full-lock zig-zag-stays-stable and fixed-countersteer-sequence expectations were intentionally replaced with actual slip reporting and matched initial oversteer recovery. Kerb/mixed-surface comparisons now separate coasting/straight-line traction from turning: lower lateral grip can reduce turning-induced speed loss, so speed ordering under unrelated trajectories was not a sound physical invariant.
+
+Advanced contacts pass normal-impulse, momentum, yaw-energy, symmetry, fixed pit ownership and existing contact-event/render-pose checks, including 64 deterministic oblique contacts. A separate 20,000-case seeded passive vehicle probe found no energy increase. A review found and fixed double-spending of the low-speed stopping impulse by braking and rolling resistance; track/gravel brake+steer+yaw tests now cover that case.
+
+All six actual ten-car demo fields survive 180 simulated seconds without DNFs; existing advanced legal-surface/recovery tests also pass. The new controller accounts for its intended passing/correction curvature, not only centerline curvature. An independent ten-car safety-car workload stays on legal surfaces with zero DNFs. Longer-race results are recorded separately when available. All six arcade public snapshot hashes match the pre-rebuild states, and the arcade integrator/controller body remain unchanged.
+
+
+The rigid-body origin is the same centered chassis point used by wheel sampling, rendering, collisions and public pose/velocity. The model therefore uses a centered 50/50 static mass approximation and derives its 3.6 m wheelbase / 1.52 m tire-center track width from canonical geometry. Front aero balance (44%) and brake balance (57%) remain independent. This is deliberately not a strict F1 weight-distribution replica; introducing an offset CG would require consistent transforms across all pose/velocity/contact/sensor boundaries. A direct wheel-center equality regression protects this alignment.
+
+
+Final extended-race characterization: all 60 cars finished across the six actual demo configurations, with zero DNFs. Hero completed in 900.43 simulated seconds; other races finished within 631 seconds. This exercises standing starts, tire wear and pit service, and remains a finite six-seed acceptance set. The first long run exposed worn-gravel AI drive demand below rolling resistance; the fix compensates at low speed within remaining rear-tire adhesion and has a regression that failed before the correction.
+
+
+## Changed files in this rebuild
+
+Existing ongoing changes were preserved. This rebuild changed these pre-existing files relative to its own source snapshot:
+
+- `README.md`
+- `demo/README.md`
+- `demo/index.html`
+- `demo/src/data/featureCatalog.js`
+- `demo/src/runtime/expertLab.js`
+- `docs/architecture.md`
+- `docs/concepts.md`
+- `docs/data_contract.md`
+- `docs/rules.md`
+- `docs/system_specs.md`
+- `smoke/demo-smoke.mjs`
+- `src/__tests__/physicsMode.test.js`
+- `src/__tests__/vehiclePhysics.test.js`
+- `src/simulation/driver/driverController.js`
+- `src/simulation/driver/racingControls.js`
+- `src/simulation/driver/rejoinControls.js`
+- `src/simulation/driver/safetyCarControls.js`
+- `src/simulation/vehicle/contactResolution.js`
+- `src/simulation/vehicle/vehiclePhysics.js`
+
+New files:
+
+- `demo/src/runtime/expertKeyboard.js`
+- `docs/advanced_physics_rebuild.md`
+- `scripts/characterize-advanced-physics.mjs`
+- `src/__tests__/advancedContactResponse.test.js`
+- `src/__tests__/advancedDriverControls.test.js`
+- `src/__tests__/advancedTireForces.test.js`
+- `src/__tests__/advancedVehicleDynamics.test.js`
+- `src/__tests__/expertKeyboard.test.js`
+- `src/simulation/driver/advancedPathControls.js`
+- `src/simulation/driver/advancedRacingControls.js`
+- `src/simulation/vehicle/advancedContactResponse.js`
+- `src/simulation/vehicle/advancedTireForces.js`
+- `src/simulation/vehicle/advancedVehicleModel.js`
+- `src/simulation/vehicle/advancedVehiclePhysics.js`
+
+
+Compatibility note: advanced trajectories and grip-response distributions intentionally change. Previously trained advanced policies need reevaluation or retraining; preserving the observation/action schema does not promise identical policy behavior. Arcade remains the compatibility/default mode.
+
+
+## Final package and browser verification
+
+The final `npm run check` passed: 1,015 fast tests with 84 intentional slow skips, public types, dry-pack, fresh packed-consumer installation/build and subpath boundaries, showcase/demo builds, quick Chromium and demo smoke. The final `npm run check:release` passed all 1,099 tests across 59 files with no skips/failures, plus the exhaustive Chromium matrix and demo smoke. The previous task's resource-related test/browser failures did not recur in this baseline or final verification.
+
+A separate live demo check launched the Advanced physics lab, focused the race, applied throttle and steering, observed active controls and speed response, and confirmed zero held keys after blur with no runtime errors. This validates input wiring/lifecycle, not a substitute for subjective driving feedback. The local preview remains available at `http://127.0.0.1:4173/#expert`.
+
+Logs and characterization artifacts are under `/tmp/paddockjs-advanced-rebuild-20260908/`; long-race and arcade-equivalence JSONL evidence is under `/tmp/paddockjs-demo-crashes-20260908/`. No original source file was removed. This rebuild changed 19 pre-existing files and added 14 files, separate from the substantial changes already present when it began.
+
+
+## Runtime measurements
+
+Six paired standard benchmark runs used the same Darwin/arm64 host, Node v24.13.0, benchmark script/profile, seeds and settings; before/after execution order alternated. All 22 benchmark workloads and invariant checks passed for all 12 runs. The before source snapshot uses unchanged package metadata and showcase policy helpers needed by the existing benchmark. These whole-workload totals include setup and changed simulation trajectories, so they are not isolated per-function costs or browser FPS predictions.
+
+The advanced-field workload median rose from 96.47 to 108.33 ms (+12.3%); the headless vector workload from 74.71 to 90.82 ms (+21.6%). The non-overlapping ranges show real added work in these workloads. This is an intentional richer-model cost, not a speed improvement. No unrelated optimization was introduced to mask it. The full browser matrix and separate live keyboard workload passed; browser throughput was not compared against a separately rebuilt old bundle.
+
+| Existing benchmark workload | Before median [min–max], ms | After median [min–max], ms |
+|---|---:|---:|
+| simulation.step advanced field | 96.47 [94.32–100.27] | 108.33 [105.51–112.18] |
+| simulation phase profile | 65.33 [64.37–66.58] | 77.09 [75.19–80.49] |
+| timing history and line maintenance | 13.67 [12.94–15.12] | 14.35 [13.79–14.92] |
+| timing-line gap without stored crossings | 0.27 [0.25–0.30] | 0.32 [0.27–0.40] |
+| lap telemetry in-progress sync | 11.93 [11.41–12.99] | 14.49 [14.04–16.26] |
+| pit route transition geometry | 3.74 [3.46–3.86] | 3.83 [3.64–4.05] |
+| collision candidate and narrowphase | 20.93 [20.21–23.33] | 22.45 [21.91–23.93] |
+| nearest track query index | 72.31 [70.09–74.25] | 72.67 [70.57–128.58] |
+| sensor ray road and surface channels | 10.39 [10.08–10.74] | 11.37 [11.06–17.60] |
+| batch-training sensor surface channels | 5.55 [5.29–5.86] | 5.33 [5.18–5.44] |
+| sensor ray barrier illegal-surface validation | 3.54 [3.15–3.80] | 4.06 [3.89–4.50] |
+| sensor ray barrier off-track recovery | 4.52 [4.38–4.73] | 4.81 [4.34–5.11] |
+| sensor ray pit-lane direct boundary | 1.23 [1.04–1.44] | 1.33 [1.16–1.59] |
+| wheel surface near pit connector | 3.81 [3.71–4.14] | 4.10 [3.86–4.65] |
+| wheel surface connector local-refresh path | 0.95 [0.76–1.02] | 0.91 [0.77–1.04] |
+| wheel surface main-track analytic | 0.63 [0.59–0.74] | 0.63 [0.54–1.03] |
+| headless environment vector step | 74.71 [74.25–80.27] | 90.82 [88.62–94.95] |
+| snapshot construction | 10.24 [10.07–11.17] | 14.05 [13.87–14.62] |
+| snapshot JSON serialization | 129.32 [128.66–140.25] | 130.38 [128.74–133.94] |
+| policy server compact JSON transport | 94.07 [91.18–100.21] | 94.99 [92.80–100.15] |
+| render snapshot interpolation | 5.26 [4.78–5.89] | 6.00 [5.65–6.51] |
+| timing tower row markup | 9.39 [8.93–10.67] | 11.31 [10.57–12.25] |
+
+
+## Read-only Git handoff
+
+Branch `v11` at `fedff4e`; locally recorded upstream `origin/v11`, ahead/behind `0/0`. No fetch was performed, so remote freshness is unknown. The index is empty. There are 122 modified tracked paths and 40 untracked status entries, including the ongoing work that predated this rebuild. No Git/GitHub mutation was performed.
+
+Next Git/GitHub step is review of the bounded rebuild diff alongside existing changes. Staging, branch/commit/push/PR actions remain unexecuted and require the exact action/target approval specified in AGENTS.md. Remaining product work is subjective driving feedback and any later decision to add full wheel rotation, suspension/vertical dynamics, calibrated real-car datasets or offset-CG transforms; none is silently claimed here.