onroute-policy-engine 2.18.1 → 2.20.0

package/dist/enum/policy-check.d.ts

@@ -1,8 +1,10 @@
 export declare enum PolicyCheckResultType {
     Pass = "pass",
-    Fail = "fail"
+    Fail = "fail",
+    Warning = "warning"
 }
 export declare enum PolicyCheckId {
+    AxleGroupMaximumLegalWeightThreshold = "axle-group-maximum-legal-weight-threshold",
     BoosterAxleLimit = "booster-axle-limit",
     BridgeFormula = "bridge-formula",
     CheckPermittableWeight = "check-permittable-weight",
@@ -14,5 +16,5 @@ export declare enum PolicyCheckId {
     NumberOfAxles = "number-of-axles",
     NumberOfWheelsPerAxle = "number-of-wheels",
     PickerTruckTractorWeightRestrictions = "picker-truck-tractor-weight-restrictions",
-    TruckTractorWheelbase = "truck-tractor-wheelbase"
+    WheelbaseLegalLimits = "wheelbase-legal-limits"
 }

package/dist/enum/policy-check.js

@@ -5,9 +5,11 @@ var PolicyCheckResultType;
 (function (PolicyCheckResultType) {
     PolicyCheckResultType["Pass"] = "pass";
     PolicyCheckResultType["Fail"] = "fail";
+    PolicyCheckResultType["Warning"] = "warning";
 })(PolicyCheckResultType || (exports.PolicyCheckResultType = PolicyCheckResultType = {}));
 var PolicyCheckId;
 (function (PolicyCheckId) {
+    PolicyCheckId["AxleGroupMaximumLegalWeightThreshold"] = "axle-group-maximum-legal-weight-threshold";
     PolicyCheckId["BoosterAxleLimit"] = "booster-axle-limit";
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
     PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";
@@ -19,5 +21,5 @@ var PolicyCheckId;
     PolicyCheckId["NumberOfAxles"] = "number-of-axles";
     PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";
     PolicyCheckId["PickerTruckTractorWeightRestrictions"] = "picker-truck-tractor-weight-restrictions";
-    PolicyCheckId["TruckTractorWheelbase"] = "truck-tractor-wheelbase";
+    PolicyCheckId["WheelbaseLegalLimits"] = "wheelbase-legal-limits";
 })(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

package/dist/helper/ctr-717.helper.d.ts

@@ -0,0 +1,2 @@
+/** Returns the authoritative CTR 7.17 table value for a spread in centimetres. */
+export declare function getCtr717TableValue(spreadCm: number): number | undefined;

package/dist/helper/ctr-717.helper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCtr717TableValue = getCtr717TableValue;
+const CTR_717_WEIGHT_BANDS = [
+    { minimumSpreadCm: 800, maximumWeightKg: 34000 },
+    { minimumSpreadCm: 760, maximumWeightKg: 33000 },
+    { minimumSpreadCm: 720, maximumWeightKg: 32000 },
+    { minimumSpreadCm: 690, maximumWeightKg: 31000 },
+    { minimumSpreadCm: 650, maximumWeightKg: 30000 },
+    { minimumSpreadCm: 610, maximumWeightKg: 29000 },
+    { minimumSpreadCm: 570, maximumWeightKg: 28000 },
+    { minimumSpreadCm: 530, maximumWeightKg: 27000 },
+    { minimumSpreadCm: 500, maximumWeightKg: 26000 },
+    { minimumSpreadCm: 460, maximumWeightKg: 25000 },
+    { minimumSpreadCm: 420, maximumWeightKg: 24000 },
+    { minimumSpreadCm: 380, maximumWeightKg: 23000 },
+    { minimumSpreadCm: 340, maximumWeightKg: 22000 },
+    { minimumSpreadCm: 300, maximumWeightKg: 21000 },
+    { minimumSpreadCm: 260, maximumWeightKg: 20000 },
+    { minimumSpreadCm: 230, maximumWeightKg: 19000 },
+    { minimumSpreadCm: 190, maximumWeightKg: 18000 },
+    { minimumSpreadCm: 120, maximumWeightKg: 17000 },
+    { minimumSpreadCm: 100, maximumWeightKg: 16500 },
+    { minimumSpreadCm: 0, maximumWeightKg: 9100 },
+];
+/** Returns the authoritative CTR 7.17 table value for a spread in centimetres. */
+function getCtr717TableValue(spreadCm) {
+    var _a;
+    if (!Number.isFinite(spreadCm) || spreadCm < 0) {
+        return undefined;
+    }
+    return (_a = CTR_717_WEIGHT_BANDS.find(({ minimumSpreadCm }) => spreadCm >= minimumSpreadCm)) === null || _a === void 0 ? void 0 : _a.maximumWeightKg;
+}

package/dist/helper/policy-check.helper.d.ts

@@ -14,6 +14,13 @@ import { Policy } from 'onroute-policy-engine';
  * @returns Array of PolicyCheckResult objects representing the outcomes of the policy check
  */
 type PolicyCheck = (policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>) => Array<PolicyCheckResult>;
+/** Applies the standard lower-of rule or the exact 7.16(g) exception. */
+export declare function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum: number, ctr717TableValue: number, isTandemDriveSingleJeepException: boolean): number;
+/**
+ * Validates every contiguous axle-unit group within 8 m, excluding groups
+ * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
+ */
+export declare function CheckAxleGroupMaximumLegalWeightThreshold(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<AxleGroupPolicyCheckResult>;
 /**
  * Validates the number of axles in each axle unit.
  *
@@ -266,12 +273,9 @@ export declare function CheckMaxTireLoad(_policy: Policy, _vehicleConfiguration:
  */
 export declare function CheckBoosterAxleLimit(_policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
- * Validates derived wheelbase for single steer, tandem drive truck tractors.
- *
- * Wheelbase is derived from the spacing between axle units 1 and 2 plus half
- * of axle unit 2 spread. Axle dimensions are stored in centimetres.
+ * Validates wheelbase legal limits for supported power unit vehicle sub-types.
  */
-export declare function CheckTruckTractorWheelbase(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+export declare function CheckWheelbaseLegalLimits(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates that the drive axle unit and first jeep axle unit are load equalized
  * within 1000 kg when they have the same number of axles.
@@ -295,6 +299,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * this map with additional entries.
  *
  * Currently includes:
+ * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
  * - CheckPermittableWeight: Validates total vehicle weight against permit limits
  * - MaxTireLoad: Validates tire load capacity for each axle unit
@@ -305,7 +310,8 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer
- * - TruckTractorWheelbase: Validates derived wheelbase for single steer, tandem drive truck tractors
+ * - TruckTractorWheelbaseLegalLimits: Validates derived wheelbase for single steer, tandem drive truck tractors
+ * - WheelbaseLegalLimits: Validates wheelbase against legal limits
  * - DriveJeepLoadEqualization: Validates drive and jeep axle unit load equalization
  *
  * @see PolicyCheck

package/dist/helper/policy-check.helper.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyCheckMap = void 0;
+exports.getMaximumLegalAxleGroupWeightThreshold = getMaximumLegalAxleGroupWeightThreshold;
+exports.CheckAxleGroupMaximumLegalWeightThreshold = CheckAxleGroupMaximumLegalWeightThreshold;
 exports.CheckNumberOfAxles = CheckNumberOfAxles;
 exports.CheckBridgeFormula = CheckBridgeFormula;
 exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
@@ -11,10 +13,123 @@ exports.CheckPickerTruckTractorWeightRestrictions = CheckPickerTruckTractorWeigh
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
 exports.CheckMaxTireLoad = CheckMaxTireLoad;
 exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
-exports.CheckTruckTractorWheelbase = CheckTruckTractorWheelbase;
+exports.CheckWheelbaseLegalLimits = CheckWheelbaseLegalLimits;
 exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 const dimensions_helper_1 = require("./dimensions.helper");
+const ctr_717_helper_1 = require("./ctr-717.helper");
 const enum_1 = require("../enum");
+/** Applies the standard lower-of rule or the exact 7.16(g) exception. */
+function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
+    const tandemDriveSingleJeepMinimumKg = 24000;
+    return isTandemDriveSingleJeepException
+        ? Math.max(tandemDriveSingleJeepMinimumKg, ctr717TableValue)
+        : Math.min(individualLegalWeightSum, ctr717TableValue);
+}
+function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex) {
+    var _a;
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const axle = axleConfiguration[axleIndex];
+    if (!vehicleType || !axle) {
+        return undefined;
+    }
+    const weights = vehicleIndex === 0
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
+            axleConfiguration[1].numberOfAxles)
+        : policy.getDefaultTrailerWeight(vehicleType, axle.numberOfAxles);
+    if (weights.length === 0) {
+        return undefined;
+    }
+    return (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a.legal;
+}
+/**
+ * Validates every contiguous axle-unit group within 8 m, excluding groups
+ * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
+ */
+function CheckAxleGroupMaximumLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration) {
+    var _a, _b;
+    const ctr717MaxSpreadCm = 800;
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold;
+    if (axleConfiguration.length < 3) {
+        return policyCheckResults;
+    }
+    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
+    const axleUnitVehicleIndexes = hasVehicleIndexes
+        ? (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration)
+        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
+    const legalWeightThresholds = axleConfiguration.map((_, axleIndex) => getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex));
+    for (let startAxleIndex = 1; startAxleIndex < axleConfiguration.length - 1; startAxleIndex++) {
+        const firstAxle = axleConfiguration[startAxleIndex];
+        const firstAxleSpread = (_a = firstAxle.axleSpread) !== null && _a !== void 0 ? _a : 0;
+        let groupSpread = firstAxleSpread;
+        let actualWeight = firstAxle.axleUnitWeight;
+        let individualLegalWeightSum = legalWeightThresholds[startAxleIndex];
+        if (!Number.isFinite(firstAxleSpread) ||
+            firstAxleSpread < 0 ||
+            !Number.isFinite(actualWeight)) {
+            continue;
+        }
+        for (let endAxleIndex = startAxleIndex + 1; endAxleIndex < axleConfiguration.length; endAxleIndex++) {
+            const endAxle = axleConfiguration[endAxleIndex];
+            const endAxleSpread = (_b = endAxle.axleSpread) !== null && _b !== void 0 ? _b : 0;
+            const interaxleSpacing = endAxle.interaxleSpacing;
+            const endAxleLegalWeight = legalWeightThresholds[endAxleIndex];
+            if (!Number.isFinite(interaxleSpacing) ||
+                interaxleSpacing <= 0 ||
+                !Number.isFinite(endAxleSpread) ||
+                endAxleSpread < 0 ||
+                !Number.isFinite(endAxle.axleUnitWeight)) {
+                break;
+            }
+            groupSpread += interaxleSpacing + endAxleSpread;
+            actualWeight += endAxle.axleUnitWeight;
+            if (individualLegalWeightSum === undefined ||
+                endAxleLegalWeight === undefined) {
+                individualLegalWeightSum = undefined;
+            }
+            else {
+                individualLegalWeightSum += endAxleLegalWeight;
+            }
+            if (groupSpread > ctr717MaxSpreadCm) {
+                break;
+            }
+            const ctr717TableValue = (0, ctr_717_helper_1.getCtr717TableValue)(groupSpread);
+            const isTandemDriveSingleJeepException = startAxleIndex === 1 &&
+                endAxleIndex === 2 &&
+                vehicleConfiguration[0] === 'TRKTRAC' &&
+                vehicleConfiguration[1] === enum_1.AccessoryVehicleType.Jeep &&
+                axleUnitVehicleIndexes[1] === 0 &&
+                axleUnitVehicleIndexes[2] === 1 &&
+                axleConfiguration[1].numberOfAxles === 2 &&
+                axleConfiguration[2].numberOfAxles === 1;
+            if (ctr717TableValue === undefined ||
+                (!isTandemDriveSingleJeepException &&
+                    individualLegalWeightSum === undefined)) {
+                continue;
+            }
+            const thresholdWeight = getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum !== null && individualLegalWeightSum !== void 0 ? individualLegalWeightSum : 0, ctr717TableValue, isTandemDriveSingleJeepException);
+            const passes = actualWeight <= thresholdWeight;
+            const startAxleUnit = startAxleIndex + 1;
+            const endAxleUnit = endAxleIndex + 1;
+            const overloadAmount = Math.max(0, actualWeight - thresholdWeight);
+            policyCheckResults.push({
+                id: policyId,
+                result: passes
+                    ? enum_1.PolicyCheckResultType.Pass
+                    : enum_1.PolicyCheckResultType.Fail,
+                message: passes
+                    ? ''
+                    : `Axle Group ${startAxleUnit} to ${endAxleUnit} exceeds the maximum legal weight threshold of ${thresholdWeight} kg by ${overloadAmount} kg.`,
+                startAxleUnit,
+                endAxleUnit,
+                actualWeight,
+                thresholdWeight,
+            });
+        }
+    }
+    return policyCheckResults;
+}
 function meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, minimumPercentage) {
     return (steerAxle.axleUnitWeight >= driveAxle.axleUnitWeight * minimumPercentage);
 }
@@ -503,6 +618,7 @@ function CheckPickerTruckTractorWeightRestrictions(policy, vehicleConfiguration,
  * @see PolicyCheck
  * @see AxleGroupPolicyCheckResult
  */
+// TODO this evaluation should only be applied to certain vehicle subtypes, await spec update
 function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfiguration) {
     const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.MinDriveAxleWeight;
@@ -535,6 +651,7 @@ function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
         id: policyId,
         message: message,
         result: result,
+        // TODO both start and end axle units should be the drive axle, is this always the second axle unit in the configuration? Or is it the last axle unit of the power unit configuration?
         startAxleUnit: 1,
         endAxleUnit: axleConfiguration.length,
     });
@@ -790,54 +907,126 @@ function CheckBoosterAxleLimit(_policy, vehicleConfiguration, axleConfiguration)
     return policyCheckResults;
 }
 /**
- * Validates derived wheelbase for single steer, tandem drive truck tractors.
- *
- * Wheelbase is derived from the spacing between axle units 1 and 2 plus half
- * of axle unit 2 spread. Axle dimensions are stored in centimetres.
+ * Validates wheelbase legal limits for supported power unit vehicle sub-types.
  */
-function CheckTruckTractorWheelbase(policy, vehicleConfiguration, axleConfiguration) {
-    const policyId = enum_1.PolicyCheckId.TruckTractorWheelbase;
-    const powerUnitSubtype = vehicleConfiguration[0];
-    const steerAxle = axleConfiguration[0];
-    const driveAxle = axleConfiguration[1];
-    if (powerUnitSubtype !== 'TRKTRAC' ||
-        !steerAxle ||
-        !driveAxle ||
-        steerAxle.numberOfAxles !== 1 ||
-        driveAxle.numberOfAxles !== 2 ||
-        driveAxle.interaxleSpacing === undefined ||
-        driveAxle.axleSpread === undefined) {
-        return [];
-    }
-    const wheelbase = driveAxle.interaxleSpacing + driveAxle.axleSpread / 2;
+function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfiguration) {
+    var _a, _b, _c;
     const resultBase = {
-        id: policyId,
+        id: enum_1.PolicyCheckId.WheelbaseLegalLimits,
         startAxleUnit: 1,
         endAxleUnit: 2,
     };
-    if (wheelbase > 720) {
+    const powerUnitSubtype = vehicleConfiguration[0];
+    const steerAxle = Object.assign(Object.assign({}, axleConfiguration[0]), { axleSpread: (_a = axleConfiguration[0].axleSpread) !== null && _a !== void 0 ? _a : 0 });
+    const driveAxle = Object.assign(Object.assign({}, axleConfiguration[1]), { axleSpread: (_b = axleConfiguration[1].axleSpread) !== null && _b !== void 0 ? _b : 0, interaxleSpacing: (_c = axleConfiguration[1].interaxleSpacing) !== null && _c !== void 0 ? _c : 0 });
+    // TODO we need to add Truck with PME and Truck Tractor with PME when ready
+    const isSupportedVehicleSubtype = (value) => {
+        return (value === 'REGTRCK' ||
+            value === 'TRKTRAC' ||
+            value === 'PICKRTT' ||
+            value === 'OGBEDTK');
+    };
+    const isSingleSteer = steerAxle.numberOfAxles === 1;
+    const isTandemSteer = steerAxle.numberOfAxles === 2;
+    const isTandemDrive = driveAxle.numberOfAxles === 2;
+    const isTridemDrive = driveAxle.numberOfAxles === 3;
+    const isTruckTractor = powerUnitSubtype === 'TRKTRAC';
+    const isPickerTruckTractor = powerUnitSubtype === 'PICKRTT';
+    const isOilfieldBedTruck = powerUnitSubtype === 'OGBEDTK';
+    const wheelbase = isSingleSteer
+        ? driveAxle.interaxleSpacing + driveAxle.axleSpread / 2
+        : steerAxle.axleSpread / 2 +
+            driveAxle.interaxleSpacing +
+            driveAxle.axleSpread / 2;
+    // the following logic covers the ASW 6.2 to 7.2m feature, we are grouping it with CheckWheelBaseLegalLimits because of feature overlap
+    if ((isTruckTractor || isPickerTruckTractor) &&
+        isSingleSteer &&
+        isTandemDrive &&
+        wheelbase > 620) {
+        if (wheelbase > 720) {
+            return [
+                Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 and Axle Unit 2 is greater than 7.2m.' }),
+            ];
+        }
+        if (wheelbase >= 620) {
+            const hasDisallowedTrailer = vehicleConfiguration.slice(1).some((v) => {
+                const trailer = policy.getTrailerDefinition(v);
+                const isSemiTrailer = (trailer === null || trailer === void 0 ? void 0 : trailer.id) === 'SEMITRL';
+                return !isSemiTrailer;
+            });
+            const hasTrailer = vehicleConfiguration.length > 1;
+            return [
+                Object.assign(Object.assign({}, resultBase), { result: hasDisallowedTrailer
+                        ? enum_1.PolicyCheckResultType.Fail
+                        : enum_1.PolicyCheckResultType.Warning, message: hasTrailer && !hasDisallowedTrailer
+                        ? 'Wheelbase for Axle Unit X and Axle Unit Y is between 6.2m and 7.2m. Semi-Trailer wheelbase must be within dimensions table found in CTPM 5.3.7.A.'
+                        : 'Wheelbase for Axle Unit 1 and Axle Unit 2 is between 6.2m and 7.2m. See CTPM 5.3.7.A.' }),
+            ];
+        }
         return [
-            Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 and Axle Unit 2 is greater than 7.2m.' }),
+            Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Pass, message: '' }),
         ];
     }
-    if (wheelbase >= 620) {
-        const hasDisallowedTrailer = vehicleConfiguration.slice(1).some((v) => {
-            if (v === enum_1.AccessoryVehicleType.Jeep ||
-                v === enum_1.AccessoryVehicleType.Booster) {
-                return true;
+    if (isSupportedVehicleSubtype(powerUnitSubtype)) {
+        if (isSingleSteer && isTridemDrive) {
+            // TODO we need to add Truck with PME and Truck Tractor with PME when ready
+            if (isTruckTractor || isPickerTruckTractor) {
+                if (wheelbase < 660) {
+                    return [
+                        Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 6.6 m.' }),
+                    ];
+                }
+                if (wheelbase > 680) {
+                    return [
+                        Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is greater than 6.8 m.' }),
+                    ];
+                }
             }
-            const trailer = policy.getTrailerDefinition(v);
-            return (trailer === null || trailer === void 0 ? void 0 : trailer.category) !== 'semi';
-        });
+            else {
+                if (wheelbase < 660) {
+                    return [
+                        Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 6.6 m.' }),
+                    ];
+                }
+            }
+        }
+        if (isTandemSteer && isTridemDrive) {
+            if (wheelbase < 770) {
+                if (isOilfieldBedTruck) {
+                    if (driveAxle.axleSpread >= 280 &&
+                        driveAxle.axleSpread < 300 &&
+                        wheelbase < 780) {
+                        return [
+                            Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 7.8 m.' }),
+                        ];
+                    }
+                    if (driveAxle.axleSpread >= 300 &&
+                        driveAxle.axleSpread <= 310 &&
+                        wheelbase < 790) {
+                        return [
+                            Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 7.9 m.' }),
+                        ];
+                    }
+                }
+                if (!isOilfieldBedTruck &&
+                    driveAxle.axleSpread >= 240 &&
+                    driveAxle.axleSpread < 280) {
+                    return [
+                        Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 7.7 m.' }),
+                    ];
+                }
+            }
+            if (isOilfieldBedTruck && wheelbase > 1000) {
+                return [
+                    Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is greater than 10.0 m.' }),
+                ];
+            }
+        }
         return [
-            Object.assign(Object.assign({}, resultBase), { result: hasDisallowedTrailer
-                    ? enum_1.PolicyCheckResultType.Fail
-                    : enum_1.PolicyCheckResultType.Pass, message: 'Wheelbase for Axle Unit 1 and Axle Unit 2 is between 6.2m and 7.2m. See CTPM 5.3.7.A.' }),
+            Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Pass, message: '' }),
         ];
     }
-    return [
-        Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Pass, message: '' }),
-    ];
+    return [];
 }
 /**
  * Validates that the drive axle unit and first jeep axle unit are load equalized
@@ -895,6 +1084,7 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * this map with additional entries.
  *
  * Currently includes:
+ * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
  * - CheckPermittableWeight: Validates total vehicle weight against permit limits
  * - MaxTireLoad: Validates tire load capacity for each axle unit
@@ -905,7 +1095,8 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer
- * - TruckTractorWheelbase: Validates derived wheelbase for single steer, tandem drive truck tractors
+ * - TruckTractorWheelbaseLegalLimits: Validates derived wheelbase for single steer, tandem drive truck tractors
+ * - WheelbaseLegalLimits: Validates wheelbase against legal limits
  * - DriveJeepLoadEqualization: Validates drive and jeep axle unit load equalization
  *
  * @see PolicyCheck
@@ -915,6 +1106,10 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
 exports.policyCheckMap = new Map([
     [enum_1.PolicyCheckId.NumberOfAxles, CheckNumberOfAxles],
     [enum_1.PolicyCheckId.BridgeFormula, CheckBridgeFormula],
+    [
+        enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
+        CheckAxleGroupMaximumLegalWeightThreshold,
+    ],
     [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
@@ -926,6 +1121,6 @@ exports.policyCheckMap = new Map([
     ],
     [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],
     [enum_1.PolicyCheckId.BoosterAxleLimit, CheckBoosterAxleLimit],
-    [enum_1.PolicyCheckId.TruckTractorWheelbase, CheckTruckTractorWheelbase],
     [enum_1.PolicyCheckId.DriveJeepLoadEqualization, CheckDriveJeepLoadEqualization],
+    [enum_1.PolicyCheckId.WheelbaseLegalLimits, CheckWheelbaseLegalLimits],
 ]);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.18.1";
+export declare const version = "v2.20.0";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = 'v2.18.1';
+exports.version = 'v2.20.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.18.1"
+  "version": "v2.20.0"
 }