@helix3/helix-cli 0.1.14-helix3.201 → 0.1.14-helix3.202

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helix3/helix-cli",
-  "version": "0.1.14-helix3.201",
+  "version": "0.1.14-helix3.202",
   "description": "helix — the HELIX creator CLI: scaffold, validate, and publish Instant Worlds",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
@@ -63,7 +63,7 @@
     "@gltf-transform/extensions": "^4.4.0",
     "@gltf-transform/functions": "^4.4.0",
     "@hypersoniclabs/helix-manifest": "npm:@helix3/helix-manifest@0.3.25-helix3.68",
-    "@hypersoniclabs/helix-sdk": "npm:@helix3/helix-sdk@0.1.5-helix3.99",
+    "@hypersoniclabs/helix-sdk": "npm:@helix3/helix-sdk@0.1.6-helix3.101",
     "commander": "^13.0.0",
     "ktx2-encoder": "^0.5.3",
     "meshoptimizer": "^0.22.0",

package/plugins/beamng-vehicle/README.md

@@ -43,8 +43,12 @@ The converter reads all four BeamNG material stages. Later authored stages win,
 
 Each successful terminal package emits six assets: the canonical GLB, `<vehicle>.vehicle-source.json`, the versioned `<vehicle>.vehicle-lowering.json` diagnostic aggregate, `<vehicle>.vehicle-package.json`, `<vehicle>.vehicle-addons.json`, and `<vehicle>.vehicle-build.json`. The lowering aggregate makes source semantics, structural exclusions, runtime blockers, functional-domain status, and provenance available to CLI and agent consumers instead of discarding them after packaging. The source manifest remains embedded in GLB extras and records the exact configuration and slot closure, fingerprints, material-resolution provenance, and coverage ledger.
 
-`lower-beamng.py` compiles the exact selected `.pc` and admitted JBeam closure into `helix.vehicle-package/2`, stable add-on records, and a source Build. Source literals cover the torque curve, idle/limiter, engine losses, gearbox and final drive, differentials, selected front/rear `pressureWheels` brake and parking-brake values, lights/electrics, audio event references, seats/cameras, and rigid openables when present. Brake and suspension expressions use a bounded data-only resolver for selected numeric variables, arithmetic, comparisons, boolean conditionals, and `case()`; direct selected-variable references are supported, source code is never evaluated, and unknown variables, calls, or tokens remain explicitly unsupported. HELIX total brake torque is derived from BeamNG's per-wheel axle values and the exact `.pc` variable overrides take precedence over selected JBeam defaults.
+`lower-beamng.py` compiles the exact selected `.pc` and admitted JBeam closure into `helix.vehicle-package/2`, stable add-on records, and a source Build. Source literals cover the torque curve, idle/limiter, engine losses, gearbox and final drive, differentials, selected front/rear `pressureWheels` tire/brake values, lights/electrics, audio event references, seats/cameras, and rigid openables when present. Brake, suspension, tire, and differential expressions use a bounded data-only resolver for selected numeric variables, arithmetic, comparisons, boolean conditionals, and `case()`; direct selected-variable references are supported, source code is never evaluated, and unknown variables, calls, or tokens remain explicitly unsupported. HELIX total brake torque is derived from BeamNG's per-wheel axle values and the exact `.pc` variable overrides take precedence over selected JBeam defaults.
 
-Selected suspension evidence is lowered only from the chosen strut/coilover leaf part on each axle. Matching left/right spring, slow/fast bump, slow/fast rebound, velocity-split, precompression, and bound rows are retained with beam-space frequency and damping-ratio derivations. Structural parent/subframe beams and swaybar construction beams are explicitly excluded by part custody. Selected torsionbar stiffness is retained in `N.m/rad`, but the runtime suspension remains fail-closed: BeamNG element rates need motion-ratio geometry to become HELIX wheel rates, and the current package has one global damping triplet with no axle-specific fast/slow channels. The emitted HELIX suspension therefore remains an explicit fallback and `functionalDomains.suspension` remains false until those exact runtime mappings exist. Tyres, raw Lua/controller, and other unsupported expressions remain explicit provenance instead of being presented as literal runtime parity. Soft-body deformation, fluids, wear, and detailed damage remain out of scope. Rigid panel poses are semantic on every device, physical bodies begin at `medium`, and detachment remains disabled on every production tier while source break groups are retained as future eligibility. Simulation, authority, package identity, and Build selection are quality-invariant.
+Driveline topology is derived from the selected device graph: each connected wheel is traced upstream to the exact selected gearbox, so FWD and RWD packages contain only their driven axle and AWD requires an actual common centre differential. Duplicate devices, cycles, half-connected axles, missing final drives, unknown differential types, invalid fields, and ambiguous output ports retain source receipts but suppress runtime differentials instead of inventing a topology. Open, locked, LSD, and unit-exponent viscous devices lower exactly when every selected behavior field is representable. Nonzero BeamNG torque-loss, virtual-inertia, speed-limit, active-lock/controller, and non-unit viscous-exponent semantics remain explicit parity blockers; a topology-safe approximation stays runnable with `runtimeStatus=approximate` while `functionalDomains.differentials=false`.
+
+Selected tires lower one exact common or vehicle-local leaf per axle. Pressure, radius, width, friction, sliding friction, and load-sensitivity values keep literal/derived/unsupported receipts. HELIX's engine-wide exponential load kernel is deterministically sampled at 24 log-spaced points from 100 N to 40 kN for its compact `muLut`; Pacejka-style shape coefficients remain explicitly identified HELIX priors. Complete selected extraction sets `extractionComplete=true` and uses the selected radius/load data, but remains `functionalDomains.wheelsTyres=false` because the current runtime has no pressure or tire-width fields and still uses shape priors. Missing, duplicate, invalid, or unresolved tire semantics instead produce a complete prior runtime fallback, never a parity claim.
+
+Selected suspension evidence is lowered only from the chosen strut/coilover leaf part on each axle. Matching left/right spring, slow/fast bump, slow/fast rebound, velocity-split, precompression, and bound rows are retained with beam-space frequency and damping-ratio derivations. Structural parent/subframe beams and swaybar construction beams are explicitly excluded by part custody. Selected torsionbar stiffness is retained in `N.m/rad`, but the runtime suspension remains fail-closed: BeamNG element rates need motion-ratio geometry to become HELIX wheel rates, and the current package has one global damping triplet with no axle-specific fast/slow channels. The emitted HELIX suspension therefore remains an explicit fallback and `functionalDomains.suspension` remains false until those exact runtime mappings exist. Raw Lua/controller and other unsupported expressions remain explicit provenance instead of being presented as literal runtime parity. Soft-body deformation, fluids, wear, and detailed damage remain out of scope. Rigid panel poses are semantic on every device, physical bodies begin at `medium`, and detachment remains disabled on every production tier while source break groups are retained as future eligibility. Simulation, authority, package identity, and Build selection are quality-invariant. Bridge currently seals one canonical source GLB and truthfully maps every tier to it; optimized mesh/texture rendition IDs must not be selected until the optimizer has materialized and sealed those artifacts.
 
 The engine consumer seam is `vehiclePackageToTuning(package, { landSolver: 'v2' })`. The source Build intentionally contains stable source identities rather than invented Continuum CIDs; after publication resolves immutable Package references, the existing `createPrivateBuildDraft` → `freezeBuildDraft` workflow is the canonical Build seam.

package/plugins/beamng-vehicle/bin/beamng-vehicle.mjs

@@ -529,7 +529,7 @@ function assertValidFunctionalLowering(lowering, boundary) {
   const nonempty = (value) => typeof value === 'string' && value.length > 0;
   const explicitUnsupported = (value) => record(value) && value.status === 'unsupported' && nonempty(value.reason);
   const semanticReceipt = (value) => record(value)
-    && ['literal', 'derived', 'unsupported'].includes(value.status) && nonempty(value.unit)
+    && ['literal', 'derived', 'defaulted', 'unsupported'].includes(value.status) && nonempty(value.unit)
     && Array.isArray(value.variables)
     && (value.status === 'unsupported' ? nonempty(value.reason) : Number.isFinite(value.value));
   const selectedReceipt = (value) => semanticReceipt(value) && (value.status === 'unsupported'
@@ -559,6 +559,198 @@ function assertValidFunctionalLowering(lowering, boundary) {
   const antiRollAxle = (value) => explicitUnsupported(value) || (record(value)
     && nonempty(value.slotType) && nonempty(value.partName) && nonempty(value.source)
     && torsionReceipt(value.torsionSpring) && value.runtimeStatus === 'unsupported' && nonempty(value.reason));
+  const tyreFields = ['pressurePSI', 'radius', 'tireWidth', 'frictionCoef', 'slidingFrictionCoef',
+    'noLoadCoef', 'fullLoadCoef', 'loadSensitivitySlope'];
+  const tyreAxle = (value) => {
+    if (explicitUnsupported(value) && Array.isArray(value.candidates)) return true;
+    if (!record(value) || !nonempty(value.partName) || !nonempty(value.source)
+      || !tyreFields.every((name) => semanticReceipt(value[name]) && Object.hasOwn(value[name], 'raw'))) return false;
+    const expectedStatus = tyreFields.every((name) => value[name].status !== 'unsupported')
+      ? 'functional' : 'unsupported';
+    return value.status === expectedStatus;
+  };
+  const tyres = semantics?.wheelsTyres;
+  const tyreFormula = 'frictionCoef * (fullLoadCoef + (noLoadCoef - fullLoadCoef) * exp(-loadSensitivitySlope * fz))';
+  const expectedTyreLoads = Array.from({ length: 24 }, (_, index) => Math.round(Math.exp(
+    Math.log(100) + ((Math.log(40000) - Math.log(100)) * index) / 23,
+  ) * 1e9) / 1e9);
+  const selectedTyresComplete = ['front', 'rear'].every((axle) => record(tyres?.axles?.[axle])
+    && tyres.axles[axle].status === 'functional'
+    && tyreFields.every((name) => tyres.axles[axle][name]?.status !== 'unsupported'));
+  const runtimeTyres = lowering?.vehiclePackage?.simulation?.land?.tyreByAxle;
+  const approximately = (left, right, epsilon = 1e-8) => Number.isFinite(left) && Number.isFinite(right)
+    && Math.abs(left - right) <= epsilon;
+  const tyreShapePrior = { alphaPeakRad: 0.139626, cxMult: 1.05, sigmaX: 0.048,
+    sigmaY: 0.08, camberGain: 0.15, dxOverDy: 1, sFall: 0.3,
+    rollingResistance: 0.013, angularInertia: 1.3 };
+  const validRuntimeTyre = (runtime, axle) => {
+    const source = tyres?.axles?.[axle];
+    if (!record(runtime) || !record(source) || !record(runtime.loadSensitivity)
+      || !record(runtime.muLut) || runtime.calibration !== 'prior'
+      || !approximately(runtime.radius, source.radius?.value)
+      || !Array.isArray(runtime.muLut.fz) || !equalJson(runtime.muLut.fz, tyres?.lut?.fz)
+      || !Array.isArray(runtime.muLut.mu) || runtime.muLut.mu.length !== runtime.muLut.fz.length
+      || !Object.entries(tyreShapePrior).every(([name, value]) => approximately(runtime[name], value))) return false;
+    for (const field of ['frictionCoef', 'slidingFrictionCoef', 'noLoadCoef', 'fullLoadCoef', 'loadSensitivitySlope']) {
+      if (!approximately(runtime.loadSensitivity[field], source[field]?.value)) return false;
+    }
+    const slideRatio = source.slidingFrictionCoef.value / source.frictionCoef.value;
+    if (!approximately(runtime.muLut.slideRatio, Math.round(slideRatio * 1e6) / 1e6)) return false;
+    return runtime.muLut.fz.every((load, index) => approximately(runtime.muLut.mu[index],
+      Math.round((source.frictionCoef.value * (source.fullLoadCoef.value
+        + (source.noLoadCoef.value - source.fullLoadCoef.value)
+        * Math.exp(-source.loadSensitivitySlope.value * load))) * 1e9) / 1e9));
+  };
+  const validFallbackTyre = (runtime) => record(runtime) && record(runtime.loadSensitivity)
+    && record(runtime.muLut) && runtime.calibration === 'prior'
+    && approximately(runtime.radius, 0.3466)
+    && Object.entries(tyreShapePrior).every(([name, value]) => approximately(runtime[name], value))
+    && equalJson(runtime.muLut.fz, tyres?.lut?.fz)
+    && Array.isArray(runtime.muLut.mu) && Array.isArray(runtime.muLut.fz)
+    && runtime.muLut.mu.length === runtime.muLut.fz.length
+    && runtime.muLut.mu.every((value) => approximately(value, 1.1))
+    && approximately(runtime.muLut.slideRatio, 0.85)
+    && equalJson(runtime.loadSensitivity, { frictionCoef: 1, slidingFrictionCoef: 0.85,
+      noLoadCoef: 1.1, fullLoadCoef: 1.1, loadSensitivitySlope: 0 });
+  const validTyres = record(tyres) && tyres.status === 'unsupported'
+    && record(tyres.axles) && tyreAxle(tyres.axles.front) && tyreAxle(tyres.axles.rear)
+    && record(tyres.variables) && record(tyres.lut) && Array.isArray(tyres.lut.fz)
+    && equalJson(tyres.lut.fz, expectedTyreLoads) && tyres.lut.formula === tyreFormula
+    && Array.isArray(tyres.runtimeBlockers) && tyres.runtimeBlockers.length > 0
+    && typeof tyres.extractionComplete === 'boolean'
+    && tyres.extractionComplete === selectedTyresComplete
+    && Array.isArray(runtimeTyres) && runtimeTyres.length === 2
+    && (tyres.extractionComplete
+      ? validRuntimeTyre(runtimeTyres[0], 'front') && validRuntimeTyre(runtimeTyres[1], 'rear')
+      : runtimeTyres.every(validFallbackTyre));
+  const driveline = semantics?.driveline;
+  const differentialFields = ['lockTorque', 'activeLockTorque', 'viscousCoef', 'viscousTorque', 'lsdPreload',
+    'lsdLockCoef', 'lsdRevLockCoef', 'friction', 'dynamicFriction', 'torqueLossCoef',
+    'defaultVirtualInertia', 'speedLimitCoef', 'diffTorqueSplit'];
+  const differential = (value) => record(value) && nonempty(value.deviceName)
+    && nonempty(value.partName) && nonempty(value.source) && nonempty(value.type)
+    && differentialFields.every((name) => semanticReceipt(value.fields?.[name])
+      && Object.hasOwn(value.fields[name], 'raw'))
+    && Array.isArray(value.controllers) && value.controllers.every(nonempty)
+    && Array.isArray(value.overlaySources) && value.overlaySources.every(nonempty)
+    && record(value.overlayFieldSources)
+    && Object.values(value.overlayFieldSources).every((sources) => Array.isArray(sources)
+      && sources.length > 0 && sources.every(nonempty))
+    && Array.isArray(value.overlayConflicts)
+    && value.overlayConflicts.every((conflict) => record(conflict) && nonempty(conflict.field)
+      && Array.isArray(conflict.sources) && conflict.sources.length > 1 && conflict.sources.every(nonempty))
+    && (value.type !== 'viscous' || (semanticReceipt(value.fields?.viscousExponent)
+      && Object.hasOwn(value.fields.viscousExponent, 'raw')))
+    && semanticReceipt(value.gearRatio) && record(value.outputPorts)
+    && [value.outputPorts.a, value.outputPorts.b].every((port) => port === 1 || port === 2)
+    && value.outputPorts.a !== value.outputPorts.b;
+  const drivenAxles = Array.isArray(driveline?.drivenAxles) ? driveline.drivenAxles : [];
+  const differentialEntries = record(driveline?.differentials)
+    ? Object.entries(driveline.differentials) : [];
+  const runtimeDriveline = lowering?.vehiclePackage?.simulation?.land?.driveline;
+  const hasRuntimeDiff = (name) => record(runtimeDriveline) && record(runtimeDriveline[name]);
+  const expectedDiffCount = drivenAxles.length + (drivenAxles.length === 2 ? 1 : 0);
+  const expectedLocations = [...drivenAxles, ...(drivenAxles.length === 2 ? ['centre'] : [])].sort();
+  const semanticLocations = differentialEntries.map(([location]) => location).sort();
+  const runtimeLocations = ['front', 'rear', 'centre'].filter(hasRuntimeDiff).sort();
+  const runtimeFields = {
+    lockTorque: 'lockTorque', viscousCoef: 'viscousCoef', viscousTorque: 'viscousTorque',
+    lsdPreload: 'lsdPreload', lsdLockCoef: 'lsdLockCoef', lsdRevLockCoef: 'lsdRevLockCoef',
+    friction: 'friction', dynamicFriction: 'dynamicFriction',
+  };
+  const runtimeCriticalDifferentialFields = new Set([
+    'type', 'name', 'inputName', 'inputIndex', 'diffType', 'gearRatio', 'viscousExponent',
+    ...differentialFields,
+  ]);
+  const axleWheels = { front: ['FL', 'FR'], rear: ['RL', 'RR'] };
+  const expectedWheels = drivenAxles.flatMap((axle) => axleWheels[axle]).sort();
+  const wheelPathEntries = record(driveline?.wheelPaths) ? Object.entries(driveline.wheelPaths) : [];
+  const validWheelPaths = nonempty(driveline?.transmissionDevice)
+    && equalJson(wheelPathEntries.map(([wheel]) => wheel).sort(), expectedWheels)
+    && wheelPathEntries.every(([, path]) => Array.isArray(path) && path.length > 0
+      && path.every(nonempty) && new Set(path).size === path.length
+      && path.at(-1) === driveline.transmissionDevice)
+    && drivenAxles.every((axle) => axleWheels[axle].every((wheel) =>
+      driveline.wheelPaths[wheel].includes(driveline.differentials[axle]?.deviceName)))
+    && (drivenAxles.length !== 2 || expectedWheels.every((wheel) =>
+      driveline.wheelPaths[wheel].includes(driveline.differentials.centre?.deviceName)))
+    && expectedWheels.every((wheel) => {
+      const path = driveline.wheelPaths[wheel];
+      const axle = wheel.startsWith('F') ? 'front' : 'rear';
+      const axleIndex = path.indexOf(driveline.differentials[axle].deviceName);
+      const gearboxIndex = path.indexOf(driveline.transmissionDevice);
+      if (drivenAxles.length !== 2) return axleIndex >= 0 && axleIndex < gearboxIndex;
+      const centreIndex = path.indexOf(driveline.differentials.centre.deviceName);
+      return axleIndex >= 0 && axleIndex < centreIndex && centreIndex < gearboxIndex;
+    });
+  const gearboxKinds = { manualGearbox: 'manual', sequentialGearbox: 'sequential',
+    dctGearbox: 'dct', cvtGearbox: 'cvt', automaticGearbox: 'automatic' };
+  const validRuntimeGearbox = record(driveline?.gearbox) && driveline.gearbox.status === 'derived'
+    && nonempty(driveline.gearbox.deviceName) && nonempty(driveline.gearbox.deviceType)
+    && nonempty(driveline.gearbox.partName) && nonempty(driveline.gearbox.source)
+    && gearboxKinds[driveline.gearbox.deviceType] === driveline.gearbox.kind
+    && runtimeDriveline?.gearbox?.kind === driveline.gearbox.kind
+    && driveline.transmissionDevice === driveline.gearbox.deviceName;
+  const expectedDriveBias = driveline?.runtimeStatus === 'unsupported' ? 0.5
+    : drivenAxles.length === 1 ? (drivenAxles[0] === 'front' ? 1 : 0)
+      : runtimeDriveline?.centre?.torqueSplit;
+  const validLegacyDriveline = semanticReceipt(driveline?.legacyFinalDrive)
+    && approximately(lowering?.vehiclePackage?.physics?.driveBiasFront?.value, expectedDriveBias)
+    && (driveline.legacyFinalDrive.status === 'unsupported'
+      || approximately(lowering?.vehiclePackage?.physics?.gearbox?.finalDrive?.value,
+        driveline.legacyFinalDrive.value));
+  const validRuntimeDiff = ([location, source], requireParity) => {
+    const runtime = runtimeDriveline?.[location];
+    const fields = source.fields;
+    const supportedType = ['open', 'locked', 'viscous', 'lsd'].includes(source.type);
+    const resolved = [...differentialFields.map((name) => fields[name]), source.gearRatio]
+      .every((receipt) => receipt.status !== 'unsupported');
+    const activeController = source.controllers.some((name) => name.includes('activeCenterDiff'));
+    const runtimeConflict = source.overlayConflicts.some((conflict) =>
+      runtimeCriticalDifferentialFields.has(conflict.field));
+    const representableLosses = ['torqueLossCoef', 'defaultVirtualInertia', 'speedLimitCoef']
+      .every((name) => fields[name].value === 0);
+    const typeParametersValid = source.type !== 'locked' || fields.lockTorque.value > 0;
+    const viscousRuntimeSafe = source.type !== 'viscous'
+      || (fields.viscousCoef.value > 0 && fields.viscousTorque.value > 0
+        && Number.isFinite(fields.viscousExponent.value));
+    const viscousParity = viscousRuntimeSafe
+      && (source.type !== 'viscous'
+        || (fields.viscousExponent.status !== 'unsupported' && fields.viscousExponent.value === 1));
+    if (!record(runtime) || !supportedType || !resolved || !typeParametersValid || !viscousRuntimeSafe
+      || runtimeConflict
+      || !(source.gearRatio.value > 0)
+      || !(fields.diffTorqueSplit.value >= 0 && fields.diffTorqueSplit.value <= 1)
+      || runtime.type !== source.type
+      || !approximately(runtime.gearRatio, source.gearRatio.value)) return false;
+    if (requireParity && (activeController || !representableLosses
+      || fields.activeLockTorque.value !== 0 || !viscousParity)) return false;
+    const sourceSplit = source.fields.diffTorqueSplit.value;
+    const expectedSplit = source.outputPorts.a === 1 ? sourceSplit : Math.round((1 - sourceSplit) * 1e8) / 1e8;
+    if (!approximately(runtime.torqueSplit, expectedSplit)) return false;
+    return Object.entries(runtimeFields).every(([runtimeField, receiptField]) =>
+      approximately(runtime[runtimeField], source.fields[receiptField].value));
+  };
+  const validDriveline = record(driveline) && ['functional', 'unsupported'].includes(driveline.status)
+    && ['functional', 'approximate', 'unsupported'].includes(driveline.runtimeStatus)
+    && drivenAxles.every((name) => ['front', 'rear'].includes(name))
+    && new Set(drivenAxles).size === drivenAxles.length && record(driveline.wheelPaths)
+    && differentialEntries.every(([location, value]) => ['front', 'rear', 'centre'].includes(location)
+      && differential(value))
+    && record(driveline.variables) && Array.isArray(driveline.runtimeBlockers)
+    && (explicitUnsupported(driveline.gearbox) || validRuntimeGearbox)
+    && validLegacyDriveline
+    && (driveline.status === 'functional') === (driveline.runtimeBlockers.length === 0)
+    && (driveline.status === 'functional' ? driveline.runtimeStatus === 'functional'
+      : driveline.runtimeStatus !== 'functional')
+    && (driveline.runtimeStatus !== 'unsupported'
+      ? differentialEntries.length === expectedDiffCount
+        && equalJson(semanticLocations, expectedLocations)
+        && equalJson(runtimeLocations, expectedLocations)
+        && validRuntimeGearbox
+        && validWheelPaths
+        && differentialEntries.every((entry) => validRuntimeDiff(entry, driveline.status === 'functional'))
+      : !hasRuntimeDiff('front') && !hasRuntimeDiff('rear') && !hasRuntimeDiff('centre'));
   const sourceExtractionComplete = suspension?.axles?.front?.status === 'resolved'
     && suspension?.axles?.rear?.status === 'resolved'
     && suspension?.antiRoll?.front?.torsionSpring?.status !== 'unsupported'
@@ -601,7 +793,32 @@ function assertValidFunctionalLowering(lowering, boundary) {
       requiredSemanticTargets.set(`sourceSemantics.suspension.antiRoll.${axle}.torsionSpring`,
         expectedEvidence(suspension.antiRoll[axle].torsionSpring, suspension.antiRoll[axle].source));
     }
+    const tyre = tyres?.axles?.[axle];
+    if (record(tyre) && nonempty(tyre.partName)) {
+      for (const field of tyreFields) {
+        requiredSemanticTargets.set(`sourceSemantics.wheelsTyres.axles.${axle}.${field}`,
+          expectedEvidence(tyre[field], tyre.source));
+      }
+    }
   }
+  if (record(driveline?.gearbox) && driveline.gearbox.status === 'derived') {
+    requiredSemanticTargets.set('simulation.land.driveline.gearbox.kind',
+      { disposition: 'source-literal', source: driveline.gearbox.source });
+  }
+  for (const [location, row] of differentialEntries) {
+    requiredSemanticTargets.set(`sourceSemantics.driveline.differentials.${location}.type`, {
+      disposition: ['open', 'locked', 'viscous', 'lsd'].includes(row.type) ? 'source-literal' : 'unsupported',
+      source: row.source,
+    });
+  }
+  requiredSemanticTargets.set('simulation.land.driveline.differentials', {
+    disposition: driveline?.status === 'functional' ? 'derived' : 'unsupported',
+    source: 'selected JBeam powertrain graph',
+  });
+  requiredSemanticTargets.set('simulation.land.tyreByAxle', {
+    disposition: 'unsupported',
+    source: 'selected JBeam pressureWheels',
+  });
   const provenanceByTarget = new Map();
   if (Array.isArray(lowering?.provenance)) {
     for (const row of lowering.provenance) {
@@ -643,14 +860,16 @@ function assertValidFunctionalLowering(lowering, boundary) {
     && record(suspensionCounts)
     && requiredSuspensionCounts.every((name) => Number.isInteger(suspensionCounts[name])
       && suspensionCounts[name] >= 0 && suspensionCounts[name] === expectedSuspensionCounts[name])
-    && record(semantics.wheelsTyres) && Array.isArray(semantics.wheelsTyres.selectedParts)
-    && Array.isArray(semantics.wheelsTyres.literalRadii)
+    && validTyres && Array.isArray(semantics.wheelsTyres.selectedParts)
+    && validDriveline
     && Array.isArray(semantics.electrics)
     && Array.isArray(semantics.audioEvents)
     && Array.isArray(semantics.openableControllers);
   const validCoverage = record(coverage)
     && record(coverage.functionalDomains)
     && coverage.functionalDomains.suspension === false
+    && coverage.functionalDomains.wheelsTyres === false
+    && coverage.functionalDomains.differentials === (driveline?.status === 'functional')
     && record(suspensionProvenance)
     && requiredProvenanceCounts.every((name) => Number.isInteger(suspensionProvenance[name])
       && suspensionProvenance[name] >= 0

package/plugins/beamng-vehicle/bin/lower-beamng.py

@@ -412,6 +412,7 @@ LAMP_NODE_SEMANTICS = {
 
 TRANSMISSION_DEVICE_KINDS = {
     "manualgearbox": "manual",
+    "sequentialgearbox": "sequential",
     "dctgearbox": "dct",
     "cvtgearbox": "cvt",
     "automaticgearbox": "automatic",
@@ -419,6 +420,7 @@ TRANSMISSION_DEVICE_KINDS = {
 
 TRANSMISSION_INFO_KINDS = {
     "manual": "manual",
+    "sequential": "sequential",
     "dct": "dct",
     "cvt": "cvt",
     "automatic": "automatic",
@@ -433,17 +435,68 @@ def lamp_beam(light: str) -> dict[str, float] | None:
             "penumbra": .3, "intensity": 1}
 
 
-def selected_transmission_kind(selected: Iterable[tuple[str, str, dict[str, Any], Path]],
-                               config_info: dict[str, Any],
-                               label_source: Callable[[Path], str]) -> tuple[str | None, str, str]:
-    """Return a kind only when the selected, fingerprinted source is unambiguous."""
-    evidence: list[tuple[str, str, Path, str]] = []
-    for _, part_name, body, path in selected:
+def selected_powertrain_devices(selected: Iterable[tuple[str, str, dict[str, Any], Path]],
+                                label_source: Callable[[Path], str]) -> list[dict[str, Any]]:
+    selected_parts = list(selected)
+    base_devices: list[tuple[str, str, Path, list[str], dict[str, Any]]] = []
+    for slot_name, part_name, body, path in selected_parts:
+        controllers = sorted(str(row["fileName"]) for row in decode_jbeam_table(body.get("controller"))
+                             if isinstance(row.get("fileName"), str))
         for row in decode_jbeam_table(body.get("powertrain")):
-            device_type = str(row.get("type", ""))
-            kind = TRANSMISSION_DEVICE_KINDS.get(device_type.lower())
-            if kind is not None:
-                evidence.append((kind, part_name, path, device_type))
+            name = row.get("name")
+            if not isinstance(name, str) or not name:
+                continue
+            base_devices.append((slot_name, part_name, path, controllers, row))
+    device_names = {row[4]["name"] for row in base_devices}
+    overlay_index: dict[str, list[tuple[dict[str, Any], str]]] = {}
+    overlay_count = 0
+    for _, part_name, body, path in selected_parts:
+        for name, options in body.items():
+            if name not in device_names or not isinstance(options, dict):
+                continue
+            overlay_count += 1
+            if overlay_count > MAX_INDEX_PARTS:
+                fail(f"selected powertrain device overlays exceed {MAX_INDEX_PARTS}")
+            overlay_index.setdefault(name, []).append(
+                (options, f"{label_source(path)}#{part_name}.{name}"))
+
+    devices: list[dict[str, Any]] = []
+    for slot_name, part_name, path, controllers, row in base_devices:
+        name = row["name"]
+        merged = dict(row)
+        overlay_sources: list[str] = []
+        overlay_fields: dict[str, list[tuple[Any, str]]] = {}
+        for options, overlay_source in overlay_index.get(name, []):
+            overlay_sources.append(overlay_source)
+            for field, value in options.items():
+                overlay_fields.setdefault(field, []).append((value, overlay_source))
+        overlay_conflicts: list[dict[str, Any]] = []
+        for field, values in overlay_fields.items():
+            unique_values = {json.dumps(value, sort_keys=True, separators=(",", ":")) for value, _ in values}
+            if len(unique_values) == 1:
+                merged[field] = values[0][0]
+            else:
+                sources = [source for _, source in values]
+                merged[field] = {"ambiguousOverlaySources": sources}
+                overlay_conflicts.append({"field": field, "sources": sources})
+        devices.append({**merged, "partName": part_name, "slotType": slot_name,
+                        "source": f"{label_source(path)}#{part_name}.powertrain",
+                        "overlaySources": sorted(set(overlay_sources)),
+                        "overlayFieldSources": {field: sorted({source for _, source in values})
+                                                for field, values in sorted(overlay_fields.items())},
+                        "overlayConflicts": overlay_conflicts, "controllers": controllers})
+    return devices
+
+
+def selected_transmission_kind(devices: Iterable[dict[str, Any]],
+                               config_info: dict[str, Any]) -> tuple[str | None, str, str]:
+    """Return a kind only when the selected, fingerprinted source is unambiguous."""
+    evidence: list[tuple[str, str, str, str]] = []
+    for row in devices:
+        device_type = str(row.get("type", ""))
+        kind = TRANSMISSION_DEVICE_KINDS.get(device_type.lower())
+        if kind is not None:
+            evidence.append((kind, row["partName"], row["source"], device_type))
     kinds = {row[0] for row in evidence}
     info_value = str(config_info.get("Transmission", "")).strip()
     info_kind = TRANSMISSION_INFO_KINDS.get(info_value.lower())
@@ -451,16 +504,16 @@ def selected_transmission_kind(selected: Iterable[tuple[str, str, dict[str, Any]
         detail = ", ".join(sorted(f"{part}:{device}" for _, part, _, device in evidence))
         return None, "selected JBeam#powertrain.type", f"Ambiguous selected transmission devices: {detail}."
     if evidence:
-        kind, part_name, path, device_type = evidence[0]
+        kind, part_name, source, device_type = evidence[0]
         if info_kind is not None and info_kind != kind:
-            return None, label_source(path), \
+            return None, source, \
                 f"Selected {part_name} declares {device_type}, but configuration info declares {info_value}."
-        return kind, label_source(path), f"Selected {part_name} powertrain device type is {device_type}."
+        return kind, source, f"Selected {part_name} powertrain device type is {device_type}."
     if info_kind is not None:
         return info_kind, "selected configuration info#Transmission", \
             f"No selected JBeam transmission device row was available; exact configuration info declares {info_value}."
     return None, "selected JBeam#powertrain.type", \
-        "No recognized manualGearbox, dctGearbox, cvtGearbox, or automaticGearbox device was selected."
+        "No recognized manualGearbox, sequentialGearbox, dctGearbox, cvtGearbox, or automaticGearbox device was selected."
 
 
 def key_multimap(parts: Iterable[tuple[str, Any]], max_entries: int = 1_000_000,
@@ -531,6 +584,7 @@ def sourced(value: Any, unit: str, source: str | None = None, note: str | None =
 BRAKE_AXLE_PATTERN = re.compile(r"(?:^|_)brakes?_?([FR])(?:_|$)", re.I)
 SUSPENSION_AXLE_PATTERN = re.compile(r"(?:^|_)(?:strut|coilover)_?([FR])(?:_|$)", re.I)
 SWAYBAR_AXLE_PATTERN = re.compile(r"(?:^|_)(?:rally_)?swaybar_?([FR])(?:_|$)", re.I)
+TIRE_AXLE_PATTERN = re.compile(r"(?:^|_)tire_?([FR])(?:_|$)", re.I)
 
 
 def selected_variable_environment(selected: Iterable[tuple[str, str, dict[str, Any], Path]],
@@ -751,17 +805,11 @@ def suspension_row_side(row: dict[str, Any]) -> str | None:
 
 def resolution_receipt(raw: Any, variables: dict[str, Any], unit: str,
                        source: str, provenance: list[dict[str, Any]], target: str) -> dict[str, Any]:
-    result = numeric_resolution(raw, variables)
-    row: dict[str, Any] = {"raw": raw, "status": result.status, "unit": unit,
-                           "variables": list(result.variables)}
-    disposition = "source-literal" if result.status == "literal" else result.status
-    if result.status == "unsupported":
-        row["reason"] = result.reason
-        detail = result.reason or "Selected value did not resolve."
-    else:
-        row["value"] = result.value
-        detail = (f"Selected literal {result.value:g} {unit}." if result.status == "literal" else
-                  f"Resolved {raw!r} to {result.value:g} {unit} from selected variables.")
+    row, _ = numeric_receipt(raw, variables, unit)
+    disposition = "source-literal" if row["status"] == "literal" else row["status"]
+    detail = row.get("reason") or (f"Selected literal {row['value']:g} {unit}."
+                                   if row["status"] == "literal" else
+                                   f"Resolved {raw!r} to {row['value']:g} {unit} from selected variables.")
     provenance.append({"target": target, "source": source,
                        "disposition": disposition, "detail": detail})
     return row
@@ -1037,14 +1085,458 @@ def lower_selected_suspension(selected: list[tuple[str, str, dict[str, Any], Pat
     return suspension, semantics
 
 
-def diff(kind: str, ratio: float, preload: float, lock: float, reverse: float, torque_split: float = .5,
-         friction: float = 0, dynamic: float = 0, lock_torque: float = 0,
-         viscous_coef: float = 0, viscous_torque: float = 0) -> dict[str, Any]:
+def diff(kind: str, ratio: float, *, preload: float = 0, lock: float = 0, reverse: float = 0,
+         torque_split: float = .5, friction: float = 0, dynamic: float = 0,
+         lock_torque: float = 0, viscous_coef: float = 0,
+         viscous_torque: float = 0) -> dict[str, Any]:
     return {"type": kind, "torqueSplit": torque_split, "gearRatio": ratio, "lockTorque": lock_torque,
             "viscousCoef": viscous_coef, "viscousTorque": viscous_torque, "lsdPreload": preload,
             "lsdLockCoef": lock, "lsdRevLockCoef": reverse, "friction": friction, "dynamicFriction": dynamic}
 
 
+def numeric_receipt(raw: Any, variables: dict[str, Any], unit: str,
+                    minimum: float | None = None, positive: bool = False) -> tuple[dict[str, Any], bool]:
+    result = numeric_resolution(raw, variables)
+    row: dict[str, Any] = {"raw": raw, "status": result.status, "unit": unit,
+                           "variables": list(result.variables)}
+    valid = result.status != "unsupported"
+    if valid:
+        value = float(result.value)
+        row["value"] = value
+        if (positive and value <= 0) or (minimum is not None and value < minimum):
+            row["status"] = "unsupported"
+            row["reason"] = "resolved value is outside the admitted runtime range"
+            valid = False
+    else:
+        row["reason"] = result.reason
+    return row, valid
+
+
+MU_LUT_POINTS = 24
+MU_LUT_FZ = [round(math.exp(math.log(100) + ((math.log(40000) - math.log(100)) * index)
+                           / (MU_LUT_POINTS - 1)), 9) for index in range(MU_LUT_POINTS)]
+TYRE_SHAPE_PRIOR = {"alphaPeakRad": .139626, "cxMult": 1.05, "sigmaX": .048,
+                    "sigmaY": .08, "camberGain": .15, "dxOverDy": 1, "sFall": .3,
+                    "rollingResistance": .013, "angularInertia": 1.3}
+
+
+def lower_selected_tyres(selected: list[tuple[str, str, dict[str, Any], Path]],
+                          variables: dict[str, Any], variable_receipts: dict[str, dict[str, Any]],
+                          label_source: Callable[[Path], str],
+                          provenance: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any], bool]:
+    """Lower one exact selected pressure-wheel tire Package per axle.
+
+    BeamNG supplies load-sensitivity coefficients while HELIX consumes its
+    engine-wide exponential kernel as a compact LUT. Sampling uses the same
+    fixed 24-knot logarithmic grid as the engine; it is not a per-vehicle fit.
+    """
+    candidates: dict[str, list[dict[str, Any]]] = {"front": [], "rear": []}
+    for slot_name, part_name, body, path in selected:
+        options = pressure_wheel_options(body)
+        if not any(key in options for key in ("pressurePSI", "frictionCoef", "noLoadCoef")):
+            continue
+        axle = selected_part_axle(TIRE_AXLE_PATTERN, slot_name, part_name, body)
+        if axle is not None:
+            candidates[axle].append({"slotType": slot_name, "partName": part_name,
+                                     "source": f"{label_source(path)}#{part_name}.pressureWheels",
+                                     "options": options})
+
+    field_specs = {
+        "pressurePSI": ("psi", 0.0, False), "radius": ("m", None, True),
+        "tireWidth": ("m", None, True), "frictionCoef": ("ratio", None, True),
+        "slidingFrictionCoef": ("ratio", None, True), "noLoadCoef": ("ratio", None, True),
+        "fullLoadCoef": ("ratio", None, True), "loadSensitivitySlope": ("1/N", 0.0, False),
+    }
+    fz = MU_LUT_FZ
+    axles: dict[str, Any] = {}
+    runtime: list[dict[str, Any]] = []
+    blockers: list[str] = []
+    used_variables: set[str] = set()
+    for axle in ("front", "rear"):
+        rows = candidates[axle]
+        if len(rows) != 1:
+            reason = f"Expected one selected {axle} tire part; found {len(rows)}."
+            blockers.append(reason)
+            axles[axle] = {"status": "unsupported", "reason": reason,
+                           "candidates": [{key: row[key] for key in ("slotType", "partName", "source")}
+                                          for row in rows]}
+            continue
+        candidate = rows[0]
+        receipts: dict[str, Any] = {}
+        complete = True
+        for field, (unit, minimum, positive) in field_specs.items():
+            receipt, valid = numeric_receipt(candidate["options"].get(field), variables, unit,
+                                             minimum=minimum, positive=positive)
+            receipts[field] = receipt
+            complete = complete and valid
+            used_variables.update(receipt["variables"])
+            disposition = "source-literal" if receipt["status"] == "literal" else receipt["status"]
+            provenance.append({"target": f"sourceSemantics.wheelsTyres.axles.{axle}.{field}",
+                               "source": candidate["source"], "disposition": disposition,
+                               "detail": receipt.get("reason") or
+                               f"Selected {field} resolved to {receipt.get('value'):g} {unit}."})
+        axle_row = {key: candidate[key] for key in ("slotType", "partName", "source")}
+        axle_row.update(receipts)
+        axle_row["status"] = "functional" if complete else "unsupported"
+        axles[axle] = axle_row
+        if not complete:
+            blockers.append(f"Selected {axle} tire contains unresolved or invalid numeric semantics.")
+            continue
+        values = {field: float(receipt["value"]) for field, receipt in receipts.items()}
+        slide_ratio = values["slidingFrictionCoef"] / values["frictionCoef"]
+        if not 0 < slide_ratio <= 1:
+            receipts["slidingFrictionCoef"]["status"] = "unsupported"
+            receipts["slidingFrictionCoef"]["reason"] = "HELIX muLut.slideRatio must be in (0, 1]."
+            axle_row["status"] = "unsupported"
+            for receipt_provenance in reversed(provenance):
+                if receipt_provenance["target"] == \
+                        f"sourceSemantics.wheelsTyres.axles.{axle}.slidingFrictionCoef":
+                    receipt_provenance["disposition"] = "unsupported"
+                    receipt_provenance["detail"] = receipts["slidingFrictionCoef"]["reason"]
+                    break
+            blockers.append(f"Selected {axle} tire sliding/friction ratio is outside (0, 1].")
+            continue
+        mu = [round(values["frictionCoef"] * (values["fullLoadCoef"]
+                    + (values["noLoadCoef"] - values["fullLoadCoef"])
+                    * math.exp(-values["loadSensitivitySlope"] * load)), 9) for load in fz]
+        runtime.append({
+            **TYRE_SHAPE_PRIOR,
+            "loadSensitivity": {key: values[key] for key in ("frictionCoef", "slidingFrictionCoef",
+                                "noLoadCoef", "fullLoadCoef", "loadSensitivitySlope")},
+            "muLut": {"fz": fz, "mu": mu,
+                      "slideRatio": round(slide_ratio, 6)},
+            "radius": values["radius"],
+            "calibration": "prior",
+        })
+
+    extraction_complete = not blockers and len(runtime) == 2
+    if extraction_complete:
+        blockers.extend([
+            "Selected pressurePSI is retained but the HELIX tire runtime has no pressure field.",
+            "Selected tireWidth is retained but the HELIX tire runtime has no width field.",
+        ])
+        provenance.append({"target": "simulation.land.tyreByAxle",
+                           "source": "selected JBeam pressureWheels", "disposition": "unsupported",
+                           "detail": "Radius and load sensitivity use the selected source with the engine-wide exponential 24-knot LUT, but pressure and width have no runtime field; shape coefficients remain explicit priors."})
+    else:
+        provenance.append({"target": "simulation.land.tyreByAxle",
+                           "source": "selected JBeam pressureWheels", "disposition": "unsupported",
+                           "detail": " ".join(blockers)})
+        fallback = {**TYRE_SHAPE_PRIOR,
+                    "loadSensitivity": {"frictionCoef": 1, "slidingFrictionCoef": .85,
+                    "noLoadCoef": 1.1, "fullLoadCoef": 1.1, "loadSensitivitySlope": 0},
+                    "muLut": {"fz": fz, "mu": [1.1] * MU_LUT_POINTS, "slideRatio": .85},
+                    "radius": .3466, "calibration": "prior"}
+        runtime = [fallback, dict(fallback)]
+    functional = False
+    semantics = {"status": "unsupported", "extractionComplete": extraction_complete, "axles": axles,
+                 "variables": {name: variable_receipts[name] for name in sorted(used_variables)
+                               if name in variable_receipts},
+                 "lut": {"fz": fz,
+                         "formula": "frictionCoef * (fullLoadCoef + (noLoadCoef - fullLoadCoef) * exp(-loadSensitivitySlope * fz))"},
+                 "runtimeBlockers": blockers}
+    return runtime, semantics, functional
+
+
+def lower_selected_driveline(devices: list[dict[str, Any]],
+                             variables: dict[str, Any], variable_receipts: dict[str, dict[str, Any]],
+                             provenance: list[dict[str, Any]]) -> tuple[dict[str, dict[str, Any]], dict[str, Any], bool, float]:
+    """Trace selected devices from connected wheels to the gearbox.
+
+    Device names are BeamNG graph identities. Duplicate names, cycles,
+    disconnected halfshafts, unknown differential kinds, and runtime-unsafe
+    parameters keep receipts and suppress every runtime differential. Safe but
+    inexact behavior fields retain an explicitly approximate runtime.
+    """
+    by_name: dict[str, list[dict[str, Any]]] = {}
+    for row in devices:
+        by_name.setdefault(row["name"], []).append(row)
+    blockers = [f"Duplicate powertrain device name {name}."
+                for name, rows in sorted(by_name.items()) if len(rows) != 1]
+    runtime_safe = not blockers
+    unique = {name: rows[0] for name, rows in by_name.items() if len(rows) == 1}
+    transmission_devices = [row for row in devices
+                            if str(row.get("type", "")).lower() in TRANSMISSION_DEVICE_KINDS]
+    gearbox_name = transmission_devices[0]["name"] if len(transmission_devices) == 1 else None
+    gearbox_semantics = ({"status": "derived", "deviceName": transmission_devices[0]["name"],
+                          "deviceType": transmission_devices[0]["type"],
+                          "kind": TRANSMISSION_DEVICE_KINDS[str(transmission_devices[0]["type"]).lower()],
+                          "partName": transmission_devices[0]["partName"],
+                          "source": transmission_devices[0]["source"]}
+                         if len(transmission_devices) == 1 else
+                         {"status": "unsupported",
+                          "reason": f"Expected one selected recognized transmission device; found {len(transmission_devices)}."})
+    if len(transmission_devices) != 1:
+        blockers.append(f"Expected one selected recognized transmission device; found {len(transmission_devices)}.")
+        runtime_safe = False
+
+    def trace(start: str) -> list[str] | None:
+        path: list[str] = []
+        seen: set[str] = set()
+        current: str | None = start
+        for _ in range(128):
+            if current is None or current in seen:
+                return None
+            seen.add(current)
+            path.append(current)
+            if current == gearbox_name:
+                return path
+            row = unique.get(current)
+            if row is None:
+                return path
+            upstream = row.get("inputName")
+            current = upstream if isinstance(upstream, str) and upstream else None
+        return None
+
+    wheel_starts: dict[str, list[str]] = {}
+    for row in devices:
+        wheel = row.get("connectedWheel")
+        if isinstance(wheel, str) and wheel in ("FL", "FR", "RL", "RR"):
+            wheel_starts.setdefault(wheel, []).append(row["name"])
+    wheel_paths: dict[str, list[str]] = {}
+    for wheel in ("FL", "FR", "RL", "RR"):
+        starts = wheel_starts.get(wheel, [])
+        traced = trace(starts[0]) if len(starts) == 1 else None
+        if traced is not None and gearbox_name is not None and gearbox_name in traced:
+            wheel_paths[wheel] = traced
+        elif len(starts) > 1:
+            blockers.append(f"Ambiguous connected-wheel endpoint {wheel}; found {len(starts)} devices.")
+            runtime_safe = False
+
+    driven_axles: list[str] = []
+    axle_wheels = {"front": ("FL", "FR"), "rear": ("RL", "RR")}
+    for axle, wheels in axle_wheels.items():
+        present = [wheel in wheel_paths for wheel in wheels]
+        if all(present):
+            driven_axles.append(axle)
+        elif any(present):
+            blockers.append(f"Only one selected {axle} wheel has a complete path to gearbox.")
+            runtime_safe = False
+    if not driven_axles:
+        blockers.append("No selected axle has two complete wheel-to-gearbox paths.")
+        runtime_safe = False
+
+    differential_names = {name for name, row in unique.items() if row.get("type") == "differential"}
+    common_all: set[str] = set()
+    if driven_axles:
+        driven_paths = [set(wheel_paths[wheel]) for axle in driven_axles for wheel in axle_wheels[axle]]
+        common_all = set.intersection(*driven_paths) & differential_names
+    axle_diff_names: dict[str, str] = {}
+    for axle in driven_axles:
+        left, right = axle_wheels[axle]
+        candidates = (set(wheel_paths[left]) & set(wheel_paths[right]) & differential_names)
+        if len(driven_axles) == 2:
+            candidates -= common_all
+        if len(candidates) != 1:
+            blockers.append(f"Expected one selected {axle} axle differential; found {len(candidates)}.")
+            runtime_safe = False
+        else:
+            axle_diff_names[axle] = next(iter(candidates))
+    centre_name: str | None = None
+    if len(driven_axles) == 2:
+        candidates = common_all - set(axle_diff_names.values())
+        if len(candidates) != 1:
+            blockers.append(f"Expected one selected AWD centre differential; found {len(candidates)}.")
+            runtime_safe = False
+        else:
+            centre_name = next(iter(candidates))
+
+    selected_diffs = {axle: unique[name] for axle, name in axle_diff_names.items()}
+    if centre_name is not None:
+        selected_diffs["centre"] = unique[centre_name]
+
+    def branch_port(diff_name: str, wheels: tuple[str, ...]) -> int | None:
+        children: set[str] = set()
+        ports: set[int] = set()
+        for wheel in wheels:
+            path = wheel_paths[wheel]
+            index = path.index(diff_name)
+            if index == 0:
+                return None
+            child_name = path[index - 1]
+            child = unique.get(child_name)
+            port = child.get("inputIndex") if child else None
+            if not isinstance(port, int):
+                return None
+            children.add(child_name)
+            ports.add(port)
+        return next(iter(ports)) if len(children) == 1 and len(ports) == 1 else None
+
+    runtime: dict[str, dict[str, Any]] = {}
+    semantics_diffs: dict[str, Any] = {}
+    used_variables: set[str] = set()
+    field_specs = {
+        "lockTorque": "N.m", "activeLockTorque": "N.m",
+        "viscousCoef": "N.m/(rad/s)", "viscousTorque": "N.m", "lsdPreload": "N.m",
+        "lsdLockCoef": "ratio", "lsdRevLockCoef": "ratio", "friction": "N.m",
+        "dynamicFriction": "N.m/(rad/s)", "torqueLossCoef": "ratio",
+        "defaultVirtualInertia": "kg.m^2", "speedLimitCoef": "ratio",
+    }
+    for location, row in selected_diffs.items():
+        dtype = str(row.get("diffType", ""))
+        kind = dtype.lower()
+        if kind not in ("open", "locked", "viscous", "lsd"):
+            blockers.append(f"Selected {location} differential type {dtype or '<missing>'} is unsupported.")
+            runtime_safe = False
+        fields: dict[str, Any] = {}
+        values: dict[str, float] = {}
+        for field, unit in field_specs.items():
+            raw = row.get(field, 0)
+            receipt, valid = numeric_receipt(raw, variables, unit, minimum=0)
+            if field not in row and valid:
+                receipt["status"] = "defaulted"
+                receipt["reason"] = "BeamNG field absent; HELIX neutral value 0."
+            fields[field] = receipt
+            if valid:
+                values[field] = float(receipt["value"])
+            else:
+                blockers.append(f"Selected {location} differential field {field} is unresolved.")
+                runtime_safe = False
+            used_variables.update(receipt["variables"])
+        split_raw = row.get("diffTorqueSplit", .5)
+        split, split_valid = numeric_receipt(split_raw, variables, "ratio", minimum=0)
+        if "diffTorqueSplit" not in row and split_valid:
+            split["status"] = "defaulted"
+            split["reason"] = "BeamNG field absent; equal HELIX split 0.5."
+        if split_valid and float(split["value"]) > 1:
+            split["status"] = "unsupported"
+            split["reason"] = "torque split must be within [0, 1]"
+            split_valid = False
+        fields["diffTorqueSplit"] = split
+        used_variables.update(split["variables"])
+        if not split_valid:
+            blockers.append(f"Selected {location} differential torque split is unresolved or invalid.")
+            runtime_safe = False
+        if kind == "locked" and values.get("lockTorque", 0) <= 0:
+            blockers.append(f"Selected {location} locked differential has no positive lockTorque.")
+            runtime_safe = False
+        active_controllers = [name for name in row.get("controllers", []) if "activeCenterDiff" in name]
+        if values.get("activeLockTorque", 0) > 0 or active_controllers:
+            blockers.append(f"Selected {location} activeLockTorque/controller cannot be represented by the HELIX differential runtime.")
+        for field in ("torqueLossCoef", "defaultVirtualInertia", "speedLimitCoef"):
+            if values.get(field, 0) > 0:
+                blockers.append(
+                    f"Selected {location} differential {field} cannot be represented by the HELIX differential runtime."
+                )
+        if kind == "viscous":
+            exponent_raw = row.get("viscousExponent")
+            exponent, exponent_valid = numeric_receipt(exponent_raw, variables, "ratio", positive=True)
+            if exponent_valid and exponent.get("value") != 1:
+                exponent["status"] = "unsupported"
+                exponent["reason"] = "HELIX differential runtime has no viscousExponent field."
+                blockers.append(f"Selected {location} viscousExponent cannot be represented exactly.")
+            elif not exponent_valid:
+                blockers.append(f"Selected {location} viscousExponent is unresolved.")
+                runtime_safe = False
+            fields["viscousExponent"] = exponent
+            used_variables.update(exponent["variables"])
+            if values.get("viscousCoef", 0) <= 0 or values.get("viscousTorque", 0) <= 0:
+                blockers.append(f"Selected {location} viscous differential parameters must be positive.")
+                runtime_safe = False
+        if kind == "lsd" and any(values.get(field, -1) < 0
+                                  for field in ("lsdPreload", "lsdLockCoef", "lsdRevLockCoef")):
+            blockers.append(f"Selected {location} LSD parameters are invalid.")
+            runtime_safe = False
+        source = row["source"]
+        semantics_diffs[location] = {"deviceName": row["name"], "partName": row["partName"],
+                                     "source": source, "type": kind, "fields": fields,
+                                     "controllers": row.get("controllers", []),
+                                     "overlaySources": row.get("overlaySources", []),
+                                     "overlayFieldSources": row.get("overlayFieldSources", {}),
+                                     "overlayConflicts": row.get("overlayConflicts", [])}
+        provenance.append({"target": f"sourceSemantics.driveline.differentials.{location}.type",
+                           "source": source,
+                           "disposition": "source-literal" if kind in ("open", "locked", "viscous", "lsd") else "unsupported",
+                           "detail": f"Selected connected differential declares diffType {dtype or '<missing>'}."})
+
+        ratio_raw = row.get("gearRatio", 1 if location == "centre" else None)
+        ratio_receipt, ratio_valid = numeric_receipt(ratio_raw, variables, "ratio", positive=True)
+        if location == "centre" and "gearRatio" not in row and ratio_valid:
+            ratio_receipt["status"] = "defaulted"
+            ratio_receipt["reason"] = "BeamNG centre gearRatio absent; neutral ratio 1."
+        semantics_diffs[location]["gearRatio"] = ratio_receipt
+        used_variables.update(ratio_receipt["variables"])
+        ratio = float(ratio_receipt.get("value", 1))
+        if not ratio_valid:
+            blockers.append(f"Selected {location} differential gearRatio is absent or invalid.")
+            runtime_safe = False
+
+        if location == "centre":
+            a_port = branch_port(row["name"], ("FL", "FR"))
+            b_port = branch_port(row["name"], ("RL", "RR"))
+        elif location == "front":
+            a_port = branch_port(row["name"], ("FL",))
+            b_port = branch_port(row["name"], ("FR",))
+        else:
+            a_port = branch_port(row["name"], ("RL",))
+            b_port = branch_port(row["name"], ("RR",))
+        semantics_diffs[location]["outputPorts"] = {"a": a_port, "b": b_port}
+        if {a_port, b_port} != {1, 2}:
+            blockers.append(f"Selected {location} differential output ports are missing, duplicate, or ambiguous.")
+            runtime_safe = False
+        if kind in ("open", "locked", "viscous", "lsd"):
+            source_split = float(split.get("value", .5))
+            runtime_split = source_split if a_port == 1 else round(1 - source_split, 8)
+            runtime[location] = diff(kind, ratio, preload=values.get("lsdPreload", 0),
+                                     lock=values.get("lsdLockCoef", 0),
+                                     reverse=values.get("lsdRevLockCoef", 0), torque_split=runtime_split,
+                                     friction=values.get("friction", 0),
+                                     dynamic=values.get("dynamicFriction", 0),
+                                     lock_torque=values.get("lockTorque", 0),
+                                     viscous_coef=values.get("viscousCoef", 0),
+                                     viscous_torque=values.get("viscousTorque", 0))
+
+    functional = not blockers and len(selected_diffs) == len(driven_axles) + (1 if len(driven_axles) == 2 else 0)
+    if len(selected_diffs) != len(driven_axles) + (1 if len(driven_axles) == 2 else 0):
+        runtime_safe = False
+    if not runtime_safe:
+        runtime = {}
+    if driven_axles == ["front"]:
+        bias_front = 1.0
+    elif driven_axles == ["rear"]:
+        bias_front = 0.0
+    elif centre_name and isinstance(selected_diffs.get("centre"), dict):
+        centre = semantics_diffs["centre"]
+        centre_split = centre["fields"]["diffTorqueSplit"]
+        if centre_split["status"] != "unsupported":
+            source_split = float(centre_split["value"])
+            bias_front = source_split if centre["outputPorts"]["a"] == 1 else round(1 - source_split, 8)
+        else:
+            bias_front = .5
+    else:
+        bias_front = .5
+    if not runtime:
+        bias_front = .5
+    axle_ratios = [row["gearRatio"] for location, row in semantics_diffs.items()
+                   if location in ("front", "rear") and row["gearRatio"]["status"] != "unsupported"]
+    unique_axle_ratios = {float(row["value"]) for row in axle_ratios}
+    if len(axle_ratios) == len(driven_axles) and len(unique_axle_ratios) == 1:
+        legacy_final_drive = {"raw": [row["raw"] for row in axle_ratios], "status": "derived",
+                              "unit": "ratio", "variables": sorted({variable for row in axle_ratios
+                                                                      for variable in row["variables"]}),
+                              "value": next(iter(unique_axle_ratios))}
+    else:
+        legacy_final_drive = {"raw": [row.get("raw") for row in axle_ratios], "status": "unsupported",
+                              "unit": "ratio", "variables": sorted({variable for row in axle_ratios
+                                                                      for variable in row["variables"]}),
+                              "reason": "Driven axle ratios are missing or unequal; one legacy finalDrive cannot represent them."}
+    provenance.append({"target": "simulation.land.driveline.differentials",
+                       "source": "selected JBeam powertrain graph",
+                       "disposition": "derived" if functional else "unsupported",
+                       "detail": "Wheel endpoints traced to gearbox without synthesized axles or centre differential."
+                                 if functional else " ".join(blockers)})
+    semantics = {"status": "functional" if functional else "unsupported",
+                 "runtimeStatus": "functional" if functional else "approximate" if runtime else "unsupported",
+                 "gearbox": gearbox_semantics, "transmissionDevice": gearbox_name,
+                 "legacyFinalDrive": legacy_final_drive,
+                 "drivenAxles": driven_axles, "wheelPaths": wheel_paths,
+                 "differentials": semantics_diffs,
+                 "variables": {name: variable_receipts[name] for name in sorted(used_variables)
+                               if name in variable_receipts},
+                 "runtimeBlockers": blockers}
+    return runtime, semantics, functional, bias_front
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--source-root", required=True)
@@ -1357,12 +1849,10 @@ def main() -> None:
     published_power_rpm = range_midpoint(config_info.get("PowerPeakRPM"), peak_power_rpm)
     published_torque_rpm = range_midpoint(config_info.get("TorquePeakRPM"), peak_rpm)
 
-    power_rows: list[dict[str, Any]] = []
-    for _, _, body, _ in selected:
-        power_rows.extend(decode_jbeam_table(body.get("powertrain")))
+    power_rows = selected_powertrain_devices(selected, source_label)
     engine_device = next((r for r in power_rows if r.get("type") == "combustionEngine"), {})
     transmission_kind, transmission_source, transmission_detail = selected_transmission_kind(
-        selected, config_info, source_label)
+        power_rows, config_info)
     transmission_kind_sourced = transmission_kind is not None
     if transmission_kind_sourced:
         prov("simulation.land.driveline.gearbox.kind", transmission_source, "source-literal", transmission_detail)
@@ -1430,6 +1920,14 @@ def main() -> None:
     suspension, suspension_semantics = lower_selected_suspension(
         selected, selected_variables, selected_variable_receipts, source_label,
         chassis_mass, weight_distribution_front, provenance)
+    differential_runtime, driveline_semantics, differentials_functional, drive_bias_front = lower_selected_driveline(
+        power_rows, selected_variables, selected_variable_receipts, provenance)
+    legacy_final_drive = driveline_semantics["legacyFinalDrive"]
+    if legacy_final_drive["status"] != "unsupported":
+        final_drive = float(legacy_final_drive["value"])
+        fd_key = "selected-driveline-final-drive"
+    tyre_by_axle, tyre_semantics, tyres_functional = lower_selected_tyres(
+        selected, selected_variables, selected_variable_receipts, source_label, provenance)
     turbo_parts = [(name, body, path) for _, name, body, path in selected if isinstance(body.get("turbocharger"), dict)]
     wastegate_psi = None
     for _, name, body, _ in selected:
@@ -1464,36 +1962,14 @@ def main() -> None:
         prov("physics.induction", f"info_{config_path.stem}.json#Induction Type", "discovered-not-lowered",
              "Selected configuration declares forced induction but exact turbo and ECU literals were incomplete.")
 
-    diffs: dict[str, dict[str, Any]] = {}
-    for row in power_rows:
-        if row.get("type") not in ("differential", "shaft"):
-            continue
-        name = str(row.get("name", "")).lower()
-        key = "centre" if "transfer" in name or "center" in name or "centre" in name else "front" if "_f" in name else "rear" if "_r" in name else ""
-        if not key: continue
-        dtype = str(row.get("diffType", "open")).lower()
-        if dtype not in ("open", "locked", "viscous", "lsd"): dtype = "open"
-        diffs[key] = diff(dtype, final_drive if key != "centre" else float(row.get("gearRatio", 1) or 1),
-                          float(row.get("lsdPreload", 0) or 0), float(row.get("lsdLockCoef", 0) or 0),
-                          float(row.get("lsdRevLockCoef", 0) or 0),
-                          float(row.get("diffTorqueSplit", .5) or .5), float(row.get("friction", 0) or 0),
-                          float(row.get("dynamicFriction", 0) or 0), float(row.get("lockTorque", 0) or 0),
-                          float(row.get("viscousCoef", 0) or 0), float(row.get("viscousTorque", 0) or 0))
-    # Selected Sunburst transfer case expresses the centre diff as a shaft row.
-    for split in indexed_values(value_index, "diffTorqueSplit"):
-        if isinstance(split, (int, float)):
-            diffs["centre"] = diff("lsd", 1, 2.5, .175, .175, float(split))
-    front = diffs.get("front", diff("lsd", final_drive, 45, .175, .01))
-    rear = diffs.get("rear", diff("lsd", final_drive, 65, .175, .175))
-    centre = diffs.get("centre", diff("lsd", 1, 2.5, .175, .175, .65))
-
     # Geometry can be supplied from Blender's authoritative receipt.
     geometry: dict[str, Any] = {}
     if args.geometry:
         document = json.loads(Path(args.geometry).read_text())
         geometry = document.get("HELIX_vehicle", document)
     sockets = geometry.get("sockets") if isinstance(geometry.get("sockets"), dict) else {}
-    wheel_radius = float(geometry.get("wheelRadius", .3466))
+    selected_tyre_radius = sum(float(row["radius"]) for row in tyre_by_axle) / len(tyre_by_axle)
+    wheel_radius = float(geometry.get("wheelRadius", selected_tyre_radius))
     bounds = geometry.get("bounds", {})
     extents = bounds.get("size") if isinstance(bounds, dict) else None
     if (not isinstance(extents, list) or len(extents) != 3) and isinstance(bounds, dict):
@@ -1594,12 +2070,6 @@ def main() -> None:
         audio_slots.append({"slot": slot_name, "buffers": [sample] if sample else [], "consumed": bool(sample),
                             **({} if sample else {"reason": "No selected source event was mapped to this HELIX slot."})})
 
-    tyre = {"loadSensitivity": {"frictionCoef": 1, "slidingFrictionCoef": .85, "noLoadCoef": 1.1,
-             "fullLoadCoef": 1.1, "loadSensitivitySlope": 0},
-            "muLut": {"fz": [1000, 3000, 6000, 9000], "mu": [1.1, 1.1, 1.1, 1.1], "slideRatio": .85},
-            "alphaPeakRad": .139626, "cxMult": 1.05, "sigmaX": .048, "sigmaY": .08,
-            "camberGain": .15, "dxOverDy": 1, "sFall": .3, "rollingResistance": .013,
-            "radius": wheel_radius, "angularInertia": 1.3, "calibration": "prior"}
     engine_spec = {"torqueCurve": {"points": torque_curve}, "idleRpm": idle, "limiterRpm": limiter,
                    "revLimiterType": "soft", "inertia": inertia, "friction": friction,
                    "dynamicFriction": dyn_friction, "engineBrakeTorque": coast,
@@ -1611,9 +2081,9 @@ def main() -> None:
                                                "upRpm": max(idle + 1, limiter - 200), "downRpm": 2800}}
     land = {"version": 1, "driveline": {"engine": engine_spec,
             "clutch": {"inertia": .1, "capacity": peak_torque * 1.6, "freePlay": .2, "launchStartRpm": 2000, "launchTargetRpm": 2500},
-            "gearbox": gearbox_spec, "front": front, "rear": rear, "centre": centre},
+            "gearbox": gearbox_spec, **differential_runtime},
             "abs": {"targetSlip": .12, "releaseRate": 12, "applyRate": 5, "minSpeed": 2.5},
-            "tyreByAxle": [tyre, dict(tyre)]}
+            "tyreByAxle": tyre_by_axle}
 
     physics = {
         "chassis": {"mass": sourced(float(config_info["Weight"]), "kg", source_ref,
@@ -1640,7 +2110,10 @@ def main() -> None:
         "gearbox": {"ratios": sourced(ratios, "ratio", source_ref if ratios_sourced else None), "reverseRatio": sourced(reverse, "ratio", source_ref if reverse_key != "HELIX-default" else None),
           "finalDrive": sourced(final_drive, "ratio", source_ref if fd_key != "HELIX-default" else None), "shiftTime": sourced(shift_delay, "s", source_ref if shift_key != "HELIX-default" else None),
           "autoUpRpm": sourced(max(idle + 1, limiter - 200), "rpm", note="HELIX automatic shift prior; ignored when the selected transmission is manual."), "autoDownRpm": sourced(2800, "rpm", note="HELIX automatic shift prior; ignored when the selected transmission is manual.")},
-        "driveBiasFront": sourced(.35, "ratio", note="1 - selected centre differential rear torque split."),
+        "driveBiasFront": sourced(drive_bias_front, "ratio", source_ref if differentials_functional else None,
+                                   "Derived from selected driven-axle topology and centre rear torque split."
+                                   if differentials_functional else
+                                   "Neutral fallback because selected driveline topology is unsupported."),
         "brakes": brakes,
         "aero": {"dragCoefficient": sourced(.32, "ratio", note="Explicit sports-sedan prior."), "frontalArea": sourced(2.2, "m2", note="width*height*shape factor prior."),
           "airDensity": sourced(1.225, "kg/m3", note="ISA sea-level standard."), "downforceCoefficient": sourced(0, "ratio", note="No selected literal aerodynamic coefficient.")},
@@ -1652,14 +2125,15 @@ def main() -> None:
           "rackTime": sourced(.8, "s", note="Derived from selected steering in/out rate."), "speedSensitivity": sourced([[0, 1], [50, .45]], "m/s,ratio", note="HELIX steering assist prior.")},
         "linearDamping": sourced(.02, "ratio", note="HELIX solver stability prior."), "angularDamping": sourced(.08, "ratio", note="HELIX solver stability prior.")}
 
+    # Bridge materializes one canonical GLB today. Do not advertise planned
+    # optimization targets as selectable artifacts until the optimizer has
+    # actually sealed them into the package.
     renditions = [{"id": "source", "kind": "source", "triangleBudget": 500000, "textureMaxDimension": 4096}]
-    for rid, budget, texture in [("mobile-low", 35000, 512), ("balanced", 90000, 1024), ("desktop-high", 220000, 2048)]:
-        renditions.append({"id": rid, "kind": "derived", "sourceRenditionId": "source", "triangleBudget": budget, "textureMaxDimension": texture})
     tiers = {
-      "minimal": {"renditionId":"mobile-low","interior":"hidden","materialLayers":"base","lightBeams":False,"physicalPanels":False,"detachableParts":False},
-      "low": {"renditionId":"mobile-low","interior":"simplified","materialLayers":"base","lightBeams":False,"physicalPanels":False,"detachableParts":False},
-      "medium": {"renditionId":"balanced","interior":"simplified","materialLayers":"dynamic","lightBeams":True,"physicalPanels":True,"detachableParts":False},
-      "high": {"renditionId":"desktop-high","interior":"full","materialLayers":"full","lightBeams":True,"physicalPanels":True,"detachableParts":False},
+      "minimal": {"renditionId":"source","interior":"hidden","materialLayers":"base","lightBeams":False,"physicalPanels":False,"detachableParts":False},
+      "low": {"renditionId":"source","interior":"simplified","materialLayers":"base","lightBeams":False,"physicalPanels":False,"detachableParts":False},
+      "medium": {"renditionId":"source","interior":"simplified","materialLayers":"dynamic","lightBeams":True,"physicalPanels":True,"detachableParts":False},
+      "high": {"renditionId":"source","interior":"full","materialLayers":"full","lightBeams":True,"physicalPanels":True,"detachableParts":False},
       "ultra": {"renditionId":"source","interior":"full","materialLayers":"full","lightBeams":True,"physicalPanels":True,"detachableParts":False},
     }
     package_id = f"beamng-{slug(candidate)}-{slug(config_path.stem)}"
@@ -1741,8 +2215,9 @@ def main() -> None:
                                                and row["brakeTorque"].get("raw") is not None}),
                   **brake_semantics},
       "suspension": suspension_semantics,
+      "driveline": driveline_semantics,
       "wheelsTyres": {"selectedParts": sorted(name for name in selected_names if any(token in name.lower() for token in ("wheel", "rim", "tire", "tyre"))),
-                       "literalRadii": sorted({float(value) for value in indexed_values(value_index, "radius") if isinstance(value, (int, float))})},
+                       **tyre_semantics},
       "electrics": sorted({str(value) for value in indexed_values(value_index, "electricsName") + indexed_values(value_index, "$electric")}),
       "audioEvents": sorted({str(value) for value in indexed_values(value_index, "sampleName") + indexed_values(value_index, "deformSound")}),
       "openableControllers": [name for name in controllers if name == "advancedCouplerControl"],
@@ -1762,7 +2237,6 @@ def main() -> None:
     prov("runtime.controllers", "selected JBeam controller tables", "unsupported", f"{len(controllers)} controller types retained in capability ledger.")
     prov("runtime.softbody", "selected JBeam nodes/beams/triangles", "out-of-scope", "Not emitted into runtime contract.")
     prov("runtime.fluids", "selected JBeam energy/thermal sections", "out-of-scope", "Not emitted into runtime contract.")
-    prov("simulation.land.tyreByAxle", "selected BeamNG wheel/tyre identities", "defaulted", "Compact common corpus lacks literal tyre model rows.")
     prov("mesh.visual.tiers", "HELIX engine fidelity contract", "defaulted", "Presentation-only policy; simulation and identity are invariant.")
 
     provenance.sort(key=lambda row: (row["target"], row["source"], row["disposition"], row["detail"]))
@@ -1775,11 +2249,10 @@ def main() -> None:
         "geometrySockets": bool(sockets),
         "engine": bool(engine_parts and len(torque) >= 2 and (not turbo_declared or induction is not None)),
         "gearbox": ratios_sourced and transmission_kind_sourced,
-        "differentials": bool(diffs),
+        "differentials": differentials_functional,
         "brakes": brakes_functional,
         "suspension": False,
-        "wheelsTyres": any(value for value in indexed_values(value_index, "radius")
-                           if isinstance(value, (int, float))),
+        "wheelsTyres": tyres_functional,
         "seatsCameras": any(str(name).startswith("seat") for name in sockets),
         "lightsElectrics": light_evidence,
         "audio": bool(engine_sample or exhaust_sample),