@hypersoniclabs/helix-mcp 0.2.5 → 0.2.12

package/skills/helix-vehicles/references/publish.md

@@ -0,0 +1,214 @@
+# Publishing a vehicle and its add-ons
+
+Publication is **Package-first**: each tool seals a public Continuum Package, then makes the item
+from that exact sealed Version, and reads everything back. Every step that writes goes to the live
+platform. Packages and versions cannot be deleted, and a mistake costs a version number, so finish
+every offline gate first.
+
+## 0. Preflight (offline)
+
+```
+validate_vehicle({ vehiclePackage: "/abs/car/vehicle-package.json", glb: "/abs/car/model.glb" })   # exit 0
+simulate_vehicle({ target: "/abs/car" })              # every target met within tolerance
+import_vehicle_audio({ source: "<sim mod>", out: "/abs/car", sim: "beamng" })   # the car's sound, from the most accurate sim mod, with provenance
+check_vehicle_audio({ target: "/abs/car" })           # every sample resolves, is PCM WAV, is audible, is SOURCED (provenance printed)
+preview_vehicle({ target: "/abs/car" })  # the real runtime: stance, cabin, poses, every seat occupied, the inspection sheets (helix-gauntlet)
+check_vehicle_addon({ dir: "/abs/addons/<part>" })    # per add-on (against a published host)
+publish_vehicle({ dir: "/abs/car", dryRun: true })    # all of the car's gates, in the publish order
+```
+
+**A dry run also runs the seal's own refusals**, nothing uploaded: `provenance.source` over 256
+characters, a missing or invalid `contentRating` (a new item needs one of `everyone`, `teen`,
+`mature`, `adult`), title/description/tag limits, and the Package Version shape and closure the
+real publish builds. It names each one (`SEAL_*`), so a dry run that passes will not be refused at
+the seal. Keep `provenance.source` to a short citation; put the long credit in `description`.
+
+The car's directory holds:
+
+- `vehicle-package.json`;
+- `model.glb` (or name it with `glb`), carrying **`asset.extras.HELIX_vehicle`** with every socket
+  (the `host-manifest` reference);
+- the WAVs beside it or in `audio/`;
+- `publish.json`:
+
+  ```json
+  { "title": "…", "description": "…", "tags": ["…"], "version": "1.0.0", "contentRating": "everyone",
+    "provenance": { "kind": "authored", "source": "<where the mesh and data came from>" },
+    "hostGrantExtensions": { "whl.wheel": { "hide": ["rim_*"] }, "pwr.exhaust": { "hide": ["exhaust"] } } }
+  ```
+
+  `provenance.kind` is `authored`, `imported` or `generated`. **`hostGrantExtensions`** lets your
+  add-ons hide your real nodes: the standard board lets them hide only `*_stock_*` globs, so a
+  wheel set hiding `rim_*` or an exhaust hiding `exhaust` fits no host until the car grants it.
+  Each pattern must match a node of your GLB. List every hide your planned add-ons need.
+
+**If `publish_vehicle` or `publish_vehicle_addon` answers NOT AVAILABLE**, the CLI bundled with
+this MCP has no vehicle mint: nothing was done. Run `check_for_updates`; if no newer MCP has it,
+finish every gate, keep the directory ready, and **report the mint as blocked**. Never improvise it
+(raw API calls, an older CLI, `publish_item`).
+
+## 1. Publish the car
+
+```
+publish_vehicle({ dir: "/abs/car" })
+```
+
+In order, it:
+
+1. validates the package and GLB exactly as `validate_vehicle` does (host manifest and the drive
+   against `targets` included), and checks every local WAV, **refusing synthesised or generated
+   audio (`AUDIO_SYNTHESISED`) and a car with no sourced engine audio (`AUDIO_ENGINE_UNSOURCED`)**.
+   Any error stops it; nothing is uploaded;
+2. uploads the GLB and every WAV as public objects, and uses a content URL only once it serves the
+   exact bytes;
+3. builds the root: the package with `mesh.ref: "$self"`, the drawn `mesh.visual` rendition pinned
+   to the uploaded GLB (what Try Now, the customizer and visual QA draw), every audio row pinned,
+   and your `hostGrantExtensions` (`.helix-publish/vehicle-package.json` is the finished package);
+4. seals a public `vehicle` Package Version (contract `helix.vehicle/2`);
+5. makes the item from that exact Version. It opens no offer;
+6. reads back the pin, the package identity, the bound and pinned mesh, every audio URL (fetched
+   and decoded), and the slot board (`readBack.board`: host kind, sockets, paths, grants).
+
+Exit 0 means published **and** verified. A failure after the seal names the step: fix it and
+re-run the same call; it resumes from its ledger in `<dir>/.helix-publish/`. **Never publish a
+second copy**: round 1's F40 re-ran a mint to change its model and left a duplicate item behind.
+**Ship one drawn GLB**: the seal sums draws and triangles over the closure.
+
+## 2. What the first mint fixes for good
+
+- `groundToBodyOrigin` and the other identity fields (contract section 12).
+- **The slot board**: host kind, sockets, node names, tunable paths and hide grants, derived once
+  from the GLB's `asset.extras.HELIX_vehicle`, the package's physics and your
+  `hostGrantExtensions`. **A version move does not rebuild it.** New sockets or grants need a fresh
+  car today, so plan the add-on set and its grants before the first mint.
+
+Then `check_vehicle_host({ itemId })` must show `hostKind vehicle` with non-zero sockets, nodes and
+paths, and your grants.
+
+## 3. A new version of an existing car
+
+**Changing a minted car is always a new Package Version of the same item.**
+
+1. **Pause sales first** if the live version is broken: `disable_item_distribution`.
+2. **Edit the directory.** Start from `.helix-publish/vehicle-package.json`. **Copy every locked
+   field byte for byte**: the backend compares each locked `Sourced` value as a whole object,
+   `value`, `unit`, `sources`, `derivedFrom` **and `note`** (round 1's F40 edited only a note and
+   the move was refused with a 409). A changed model is fine: it is uploaded and pinned as in a
+   first publish.
+3. `publish_vehicle({ dir, itemId, version: "<next patch>", reason: "<1–500 chars>" })` seals a
+   **staged** version into the car's own Package and moves the item to it. On a listed car the
+   move waits for visual QA: it stops at `staged-awaiting-visual-qa` and prints the two steps,
+   `visual_qa_item({ itemId, packageVersion, vehiclePackage: "<dir>/.helix-publish/vehicle-package.json" })`
+   with a QA sign-in, then the same `publish_vehicle` call again, which resumes at the move
+   (`helix vehicle publish <dir> --item <id> --package-version <v> --reason ...`: pin and vehicle
+   package move together). **Never activate a car version with `helix item set-version`**: it moves
+   the pin but not `properties.vehiclePackage`, so the car keeps serving its old package.
+4. Check every surface that draws it: hosted world, customizer, Try Now and thumbnail.
+
+What a new version must keep is in contract section 12: identity fields identical; parts,
+sockets, renditions, panels, seats, actions and signals only grow. **If you re-frame the host,
+re-publish every host-frame add-on against the new frame**, and run visual QA with the add-ons
+fitted on it.
+
+## 4. Visual QA (required before selling)
+
+```
+visual_qa_item_hosted({ itemId })            # the platform renders the current version; no sign-in needed
+visual_qa_item_status({ itemId })            # read the verdict + reasons
+```
+
+The verdict binds to the exact item, Package Version and manifest CID. On a FAIL, read every
+reason, open the contact sheet, fix the cause, publish a new version (section 3) and re-run.
+Hosted runs are capped per day, so do not spin on it. **Never request an admin override.** The
+full list of required asserts and critic checks is in the `qa` reference. Only a submitted or
+hosted verdict counts; a local run is not a gate result. Read the numeric asserts and the frames
+before changing anything, and **never distort the car to satisfy a gate artefact** ("When the
+gate, not the car, is wrong" in `qa`).
+
+A freshly sealed model is public at once but the CDN the runtime draws from can lag it by minutes.
+The hosted runner now waits for the CDN to serve the pinned model before it renders (up to about 10
+minutes) and hands the attempt back when it never does, so a lagging CDN no longer burns the three
+attempts; a failure reading "never presented" or "no fetched asset URL contains <sha>" is not the
+car's fault, so do not change the model for it. A job that did end `error` is re-run with
+`visual_qa_item_hosted({ itemId, retry: true })`, which **requeues** it as a fresh job (attempts
+start again; it waits out the server's cooldown, about 10 minutes after the last run, instead of
+failing). Requeue only after a failure that is not the car's, or after a fix has been published as
+a new version.
+
+## 5. Sell
+
+```
+create_item_distribution({ itemId, channel: "marketplace", priceLix: <n> })
+```
+
+Run it with `dryRun` first, then for real. The server enforces a minimum price. **MCP cannot
+grant public-listing authority**; a Vault listing for the Package needs `--confirm-public-listing`
+on a human's CLI run.
+
+**The car is not finished until it is listed and priced.** A `NOT CURRENTLY LISTED / NOT FOR
+SALE` car is not obtainable — the owner literally cannot buy it, so the customizer's base is
+`NOT SOLD` and the whole vehicle is a demo, not a product. Round 7 shipped exactly that: the
+builder left the base and all nine add-ons dry and handed pricing "to the owner". **Never leave
+the listing or the price to the owner; create the distribution yourself as the last step of
+publishing.** A dry run of `create_item_distribution` is only ever a preview of the call that
+must follow.
+
+## 6. Add-ons, per part
+
+Each add-on is a directory: `addon.json` and `model.glb`. Tune-only parts (ECU, gearbox,
+driveline, suspension, brakes, anti-roll bars, steering) and clip-set slots ship no model.
+
+1. `check_vehicle_addon({ dir })`: the contract, the anchoring, the host's hubs, the host's hide
+   grants and tunable paths, the backend's own fit count, and the drive effect of every `tune` op.
+   It must say it fits every host and does something.
+2. `preview_vehicle({ item: <host id>, addon: [<dir>] })` for any part with a model: it fits the
+   unpublished part in the real runtime and checks it lands on its anchor.
+3. `publish_vehicle_addon({ dir })`: the full check, then it uploads the model, seals a public
+   `addon` Package (contract `helix.addon/1`), makes the item from it (pinned, unlisted, no
+   offer), and reads back that every host lists it as a fit and on its add-on rail. A hide the
+   host has not granted stops it (`HOST_GRANT_MISSING`): the host car must seal the grant.
+   A dry run (`dryRun: true`) also runs the seal's refusals (`provenance.source` over 256
+   characters, missing `contentRating`, title and tag limits, Package shape), so run it before
+   the real call.
+4. `visual_qa_item_hosted({ itemId: <add-on id> })` renders it fitted on every host. Open the
+   contact sheet and look at each close-up and the x-ray.
+   **Changing a published part:** `publish_vehicle_addon({ dir, itemId: <add-on id>, version:
+   "<next patch>", reason: "<1–500 chars>" })` seals a **staged** new Version of that part's own
+   Package and moves the *same* item to it, with the same checks and read-back as the first
+   publish (owners, offers and the item id are unchanged). Run from the directory that first
+   published the part, `version` alone is enough. A part's slot cannot change; a version name that
+   is already sealed with different bytes is refused (`VERSION_CLASH`), so take the next number.
+   A listed meshed part is held by visual QA: the call stages the version and says so; run
+   `visual_qa_item({ itemId, packageVersion: "<v>", submit: true })` (or hosted), then repeat the
+   same call to finish the move. Never hand-build a descriptor.
+5. **List and price it** with `create_item_distribution` — the same hard requirement as the base
+   (section 5). A published-but-unlisted add-on is `NOT LISTED` on the car's page and the owner
+   cannot buy it; the customizer shows it "ALL COMPATIBLE" yet unobtainable. Round 7 left all nine
+   add-ons dry (`--dry-run` only) and handed pricing to the owner — that is a defect, not a
+   handoff. The final distribution step lists every add-on; a dry run is only a preview of the
+   real call.
+6. `check_vehicle_host({ itemId })` must show **every required part fitting and for sale** — each
+   minimum-set slot with a `distributionId` and a price, not `(not for sale)` — and the
+   "Web customizer guard" section must pass for every add-on: it runs the customizer's own check on
+   each part's exact Package pin, so a part the rail lists but the customizer refuses to equip
+   fails the host check with the customizer's message.
+
+## If the mint is unavailable: sealing a version by hand
+
+Only when `publish_vehicle` (or, for a part, `publish_vehicle_addon`) answers NOT AVAILABLE and
+something that **already exists** must change:
+write a staged Package Version descriptor, seal it with `publish_continuum_package({ input })`, pass
+`visual_qa_item` on that version, then activate it by re-running
+`helix vehicle publish <dir> --item <itemId> --package-version <v> --reason "<why>"` (`publish_vehicle` with
+`itemId`, `version`, `reason`) once the bundled CLI has it: the resume moves the Continuum pin and
+`properties.vehiclePackage` **together**. **Never `helix item set-version` for a vehicle**: it moves
+the pin but not `properties.vehiclePackage`, so the car keeps serving its old package (the 993 and
+the R34 both hit this). The CLI lane is fixing `set-version`; until the CLI says so, do not use it
+on a car. Copy the shape of the
+car's last `.helix-publish/descriptor-<v>.json`: `"stage": true`; the root is the package as
+canonical JSON (keys sorted, no whitespace, UTF-8, `mesh.ref` the item id) with role
+`vehicle-definition`; the GLB is the `target-balanced` variant with role
+`vehicle.model.web.medium`; each WAV is a `vehicle-audio` variant; every `cid` is
+`cid:sha256:<sha256 of the exact bytes>`; `expectedClosure` counts the objects and sums their
+bytes. Point `mesh.visual`'s derived `artifactRef` and each audio row's `url` at
+`<origin>/content/sha256/<first two hex>/<sha>`, on the origin the existing rows use.

package/skills/helix-vehicles/references/qa.md

@@ -0,0 +1,177 @@
+# Vehicle QA: what to look at, what to measure
+
+**The rule:** nothing ships until you have looked at the rendered result in a real HELIX runtime.
+That covers the base car, each add-on fitted on it, every opening and every seat. Measure
+positions against known landmarks; a platform self-report is not evidence.
+
+On the 993, `parts-seated: 1, parts-offvehicle: 0` was reported while all four wheel copies sat at
+(0, 0, 0). Every boarded check passed while the parked tyres were 8–10 cm into the road.
+
+## Before publishing: render your GLB
+
+This is your only look before the first mint, and **the first mint locks `groundToBodyOrigin`**.
+So do it properly. `preview_vehicle({ target: <dir> })` loads the unpublished directory into the real HELIX
+runtime (headless), boards and settles it, and prints ride height per wheel against
+`groundToBodyOrigin`, wheel-to-hub offsets, arch clearance and the measured rolling radius, with a
+contact sheet. It seats an avatar in every seat by default and measures the cabin the way the gate will
+(the `cabin` reference), and writes the gauntlet inspection sheets under `<out>/inspection/` (read the
+`helix-gauntlet` skill: every sheet, beside the reference photos, before any publish). It always writes the fixed
+appearance poses (`front`, `side`, `rear`, `top`, `front34`, `rear34`, `cockpit`) under
+`<out>/poses/` and `poses.jpg`; put them beside your reference photos (the `appearance`
+reference). Fix, re-run, and compare its frames with the reference photos at matched angles:
+
+- front, rear, both sides, and both 3/4 views, at eye height;
+- a close-up of each wheel, plus one from **inboard or x-ray**, because a culled far-side rim
+  shows only a tyre ring;
+- all four arches from the 3/4 views and from below;
+- the cabin from the driver's eye point;
+- each door and lid at its declared open angle;
+- the lamps lit and unlit, at night.
+
+Measure these, and fix anything outside the threshold:
+
+| Check | Threshold |
+| --- | --- |
+| Overall length, width, height, wheelbase, track | Within 2 % of the real car |
+| Wheel node origin to its tyre-cylinder centre | ≤ 2 mm |
+| Tyre bottoms at rest | Y = 0 ± 1 cm |
+| Tyre to arch, liner and bumper at rest, 0.07 m bump, full lock, lock + bump | ≥ 10 mm (the 993 achieved 14 mm) |
+| Lowest body point | ≥ 5 cm above the road |
+| Seat H-point to roof lining, upright adult (crown about 0.83 m above the hip) | ≥ 10 mm |
+| Driver's hand to rim | ≤ 7 cm |
+| Feet | On the floor, not through it |
+
+**Camber.** Fit the tread cylinder's axis against the hub axis. Never use a PCA of the rim, which
+fakes 2–3° on a straight wheel.
+
+## The platform gate (visual QA)
+
+**Only the backend's verdict is a gate result.** `visual_qa_item` (with a QA sign-in; it submits
+by default) and `visual_qa_item_hosted` record it: the backend re-derives pass or fail from the
+measured asserts and runs the vision critic. A local run (`submit: false`, or `helix item
+visual-qa` without `--submit`) measures but never runs the critic, so its "PASS" is not a gate
+result: round 1's F40 read five local passes as progress
+while every submitted run failed on the critic. Each submitted or hosted run is binding and capped
+per day, so use local runs and `preview_vehicle` to iterate, and submit when they are clean.
+
+A run **passes** only when there is no harness error, every required assert is present at
+severity `block` and passes, no other `block` assert fails, and the vision critic answers `pass` to
+every check. A missing required assert ("not measured") and a critic `cannot_judge` both fail;
+`warn` never blocks. Required measured asserts:
+
+| Assert | Pass condition |
+| --- | --- |
+| `vehicle.wheels.at_hubs` | each drawn wheel within 3 cm of its hub |
+| `vehicle.wheels.arch_clearance` | no body inside the tyre volume; lowest body point ≥ 5 cm |
+| `vehicle.wheels.spin_with_speed` | rolling ratio 0.8–1.25 per wheel, against the radius that wheel rolls on (its axle's `tyreByAxle` radius, so staggered tyres are judged correctly) |
+| `vehicle.steering.wheel_rotates` | front wheels ≥ 10°, steering wheel ≥ 30° |
+| `vehicle.articulation.reaches_limits` | each panel within 5° of its declared travel |
+| `vehicle.seats.addressable` | every declared seat can be boarded |
+| `vehicle.occupants.penetration` | every occupant run: no body surface more than 8 mm through the cabin over ≥ 4 cm², or more than 25 mm over ≥ 1.5 cm² (the `cabin` reference) |
+| `frame.non_empty` | no flat or empty frame |
+| `scene.no_nan_or_invisible` | no NaN transform, no invisible drawn part |
+| `render.textured` | materials resolve; no missing texture or placeholder grey |
+| `scale.sane_for_category` | 1.2–30 m for a vehicle |
+
+- **Blocking whenever present** (always on an occupant run): `vehicle.occupants.engine_current`,
+  `boarded`, `head_clearance` (crown ≥ 10 mm under the lining), `hips_on_seat` (≤ 120 mm over the
+  cushion, ≤ 20 mm through the base), `feet_on_floor` (−50 to +300 mm) and `hands_on_wheel`
+  (driver, ≤ 70 mm).
+- **Blocking whenever present:** `vehicle.lamps.each_function_lights`. The run presses the lamp
+  keys as the seated driver (low beam, fog, high beam, each indicator, hazards, reverse, handbrake)
+  and reads the emissive of every mesh your `componentBuild` lamp rows resolve to. A lens that
+  stays dark fails naming it. An indicator must blink and, per side and on hazards, light geometry
+  that reaches both the front and the rear quarter of the car; tail lamps are read while reversing
+  with the low beam on, so the brake lens cannot stand in for them. A car that cannot be put in
+  reverse (a manual gearbox) reports reverse as not measured. The reads are in
+  `bundle.json` `facts.lamps`. It is absent when the package has no lamp rows.
+- **Brake lamp lit at a standstill is expected, not a defect.** A seated driver with no input gets
+  the platform's auto-hold (the brake is held, the lamp follows it, as on a car with Auto Hold);
+  an unoccupied parked car's lamp is off, and the lamp drops when the car is driven or reversed.
+  Do not file it or strip the brake rows. (Platform nit: it also stays lit with the ignition off
+  and the driver still seated.)
+- **Warn only:** `vehicle.wheels.radius_matches_physics`, `vehicle.occupants.hips_sink_depth`,
+  `vehicle.occupants.near_contact`, `render.flat_shaded`.
+- **Every other declared rendition** (low, medium, …) must pass `at_hubs`, `arch_clearance`,
+  `articulation`, `occupants.penetration`, `no_nan`, `textured` and `scale` again.
+- **The vision critic**, every check must pass: `item.matches_title`, `frame.nonempty` (no frame
+  shows only the environment), `render.textured`, `render.intact`, `scale.plausible`,
+  `vehicle.wheels.seated`, `vehicle.wheels.count`, `vehicle.ride_height`, `vehicle.symmetry`,
+  `vehicle.cabin`, `vehicle.articulation`, `vehicle.steering` and `vehicle.motion`. With occupant
+  frames it also checks `vehicle.occupant.head_clearance`, `seat_contact`, `no_clipping` (counted
+  only when two failing votes name the same seat, body part and cabin part) and `hands_on_wheel`.
+- The listing gate (Marketplace and Vault listings, distributions, version moves) reads only the
+  server's recorded run for that exact Package Version.
+
+Also: the gate passes vacuously on a car with no declared panels, never plays audio, and never
+compares physics with the real car. It sweeps only the panels the package DECLARES, so a car whose
+bonnet and boot are fixed passes it; `validate_vehicle` is what warns about the missing lids
+(`PANEL_ROLE_*`), so read its warnings, do not ship them unread. A passing preview with
+`PANEL_ROLE_NO_NODE_*` warnings means the car opens only what it declares, not what the real car
+opens. `preview_vehicle` and a local `--local-critic` dry run never
+produce a verdict either.
+
+### When the gate, not the car, is wrong
+
+**Accuracy wins.** If a gate failure comes from the harness (a camera inside a wall, a probe that
+misreads your mesh, an assert that cannot represent a real feature such as staggered tyres), do
+not change the car to satisfy it:
+
+1. Prove it: open the frame and the numbers, and show the failure would occur on a correct car.
+2. Record it in your ledger with the verdict id, the frame and the measurement.
+3. Report it as a platform defect, with that evidence, in your final report.
+4. Keep the car true to the real one: real dimensions, ride height and tyre sizes.
+
+Round 1's F40 raised its body 36 mm, off the real car's figures, to lift an occupant camera above
+a test wall. It still failed, and the car got less accurate. (That camera is fixed: the drive now
+keeps clear of the walls and the occupant cameras clip scenery between lens and car.) Never request
+an admin override. After a harness fix lands, re-queue the **same** version with
+`visual_qa_item_hosted({ itemId, retry: true })`, and read the verdict and its frames
+(`visual_qa_item_status`, the contact sheet) before changing anything.
+
+## After publishing: the live car
+
+1. **Platform visual QA.** Use `visual_qa_item_hosted`. It must pass for the car and for every
+   add-on on every host. Read the reasons and **open the contact sheet**.
+2. **Owner pass on the live item.** Use a fresh QA account, as a buyer would:
+   1. Find the car in the Marketplace and buy it through the UI.
+   2. Spawn it in a hosted world **with kerbs** as well as in a flat test world.
+   3. **Parked:** walk around it. Are the tyres on the road, is it at the right ride height, and
+      are there no gaps?
+   4. **Driver:** board, take the first-person and chase views, and check that the hands are on
+      the wheel, the head clears the roof, there is no black band (headrest back faces), and the
+      steering wheel turns with the steering.
+   5. **Passenger:** board every declared seat from a second account.
+   6. **Drive:**
+      - wheels spin with speed and steer with input;
+      - 0–100 in a median of 3 runs, beside a control car in the same world, against `targets`;
+      - discard any sample after a wheel leaves the ground;
+      - it climbs a 15 cm kerb.
+   7. **Controls:** doors and lids open (O, P, `-`, `=`), headlights, indicators and hazards
+      work, and brake and reverse lamps light at night.
+   8. **Listen:** ignition, idle, a rev sweep under load, shifts, the limiter, the horn, and tyres,
+      beside a real recording of the car; read each slot's provenance from `check_vehicle_audio`.
+   9. **Customizer:** fit each add-on, save, and check that the wheel copies sit within ±1 cm of
+      the stock hubs. Then drive with each part. For performance parts, run a live A/B against
+      stock.
+3. **Judge against the reference, blind where you can.** Put matched before and after views next
+   to real photos, pick the better one before scoring, and judge the whole set. A single view
+   misleads: the 993's final build won stance and arches but still lost on front 3/4 ride height
+   and on the steering-wheel rake.
+
+## What numbers missed and eyes caught (the 993 and Subaru record)
+
+- Four wheel add-ons stacked at the car's centre, while the flags said seated.
+- A sunk body with tyres flattened into the arches: arch gaps of −8.5 and −14.1 cm.
+- Torn, jagged arch liners after raising the body. A matte-black liner tub per wheel fixed it.
+- A far-side wheel that showed only a tyre ring, because its rim faces were culled.
+- Black tyres, from glTF's default metallic 1.
+- An exhaust tip through the bumper, with the stock muffler still visible.
+- Flat grey add-ons: a neutral paint mask, missing UVs, or base-game textures that were never
+  supplied.
+- Heads 11 cm into the roof, a first-person black band, and feet through the floor and arch.
+- Parked tyres 8–10 cm into the road while every boarded check passed.
+- 26 of 26 lamp scenarios passing numerically on a car nobody had looked at.
+- Indicators that flashed at the front only (the rear lens was painted into the body), and a bonnet,
+  engine cover and boot that never opened: every node, row and panel the package declared was
+  valid; only the hazard key and the bonnet key, pressed by someone looking at the car, showed it.