onroute-policy-engine 2.22.1 → 2.24.0

package/dist/constants/cost.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is the default description used for each cost object,
+ * when there is no explicit description provided (eg. Non-STWSE permit costs).
+ *
+ * NOTE: DO NOT change the value of this constant, as the value is being used elsewhere
+ * throughout the backend.
+ */
+export declare const DEFAULT_COST_DESCRIPTION = "Calculated permit cost";

package/dist/constants/cost.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_COST_DESCRIPTION = void 0;
+/**
+ * This is the default description used for each cost object,
+ * when there is no explicit description provided (eg. Non-STWSE permit costs).
+ *
+ * NOTE: DO NOT change the value of this constant, as the value is being used elsewhere
+ * throughout the backend.
+ */
+exports.DEFAULT_COST_DESCRIPTION = 'Calculated permit cost';

package/dist/constants/overload.d.ts

@@ -0,0 +1,9 @@
+export declare const BASE_OVERLOAD_LIMIT = 28000;
+export declare const EXTRA_WEIGHT_INTERVAL = 900;
+export declare const EXTRA_RATE_INCREMENT = 1.85;
+export declare const DEFAULT_MAX_RATE = 21.4;
+export declare const MINIMUM_OVERLOAD_FEE = 25;
+export declare const OVERLOAD_RATES_PER_10KM: {
+    max: number;
+    rate: number;
+}[];

package/dist/constants/overload.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OVERLOAD_RATES_PER_10KM = exports.MINIMUM_OVERLOAD_FEE = exports.DEFAULT_MAX_RATE = exports.EXTRA_RATE_INCREMENT = exports.EXTRA_WEIGHT_INTERVAL = exports.BASE_OVERLOAD_LIMIT = void 0;
+exports.BASE_OVERLOAD_LIMIT = 28000;
+exports.EXTRA_WEIGHT_INTERVAL = 900;
+exports.EXTRA_RATE_INCREMENT = 1.85;
+exports.DEFAULT_MAX_RATE = 21.4;
+exports.MINIMUM_OVERLOAD_FEE = 25;
+// Overload permit fee rate table mapping up to 28,000 kg
+exports.OVERLOAD_RATES_PER_10KM = [
+    { max: 2000, rate: 0.95 },
+    { max: 3000, rate: 1.15 },
+    { max: 4000, rate: 1.4 },
+    { max: 5000, rate: 1.6 },
+    { max: 6000, rate: 1.85 },
+    { max: 7000, rate: 2.15 },
+    { max: 8000, rate: 2.45 },
+    { max: 9000, rate: 2.95 },
+    { max: 10000, rate: 3.35 },
+    { max: 11000, rate: 3.75 },
+    { max: 12000, rate: 4.25 },
+    { max: 13000, rate: 4.95 },
+    { max: 14000, rate: 5.6 },
+    { max: 15000, rate: 6.25 },
+    { max: 16000, rate: 7.25 },
+    { max: 17000, rate: 8.25 },
+    { max: 18000, rate: 9.15 },
+    { max: 19000, rate: 10.1 },
+    { max: 20000, rate: 10.9 },
+    { max: 21000, rate: 11.85 },
+    { max: 22000, rate: 12.7 },
+    { max: 23000, rate: 13.95 },
+    { max: 24000, rate: 14.95 },
+    { max: 25000, rate: 16.1 },
+    { max: 26000, rate: 17.85 },
+    { max: 27000, rate: 19.85 },
+    { max: 28000, rate: 21.4 },
+];

package/dist/constants/stgvwi.d.ts

@@ -1,6 +1 @@
 export declare const AXLE_CALC_RESULTS_FACT = "axleCalcResults";
-export declare const BASE_OVERLOAD_LIMIT = 28000;
-export declare const EXTRA_WEIGHT_INTERVAL = 900;
-export declare const EXTRA_RATE_INCREMENT = 1.85;
-export declare const DEFAULT_MAX_RATE = 21.4;
-export declare const MINIMUM_OVERLOAD_FEE = 25;

package/dist/constants/stgvwi.js

@@ -1,9 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MINIMUM_OVERLOAD_FEE = exports.DEFAULT_MAX_RATE = exports.EXTRA_RATE_INCREMENT = exports.EXTRA_WEIGHT_INTERVAL = exports.BASE_OVERLOAD_LIMIT = exports.AXLE_CALC_RESULTS_FACT = void 0;
+exports.AXLE_CALC_RESULTS_FACT = void 0;
 exports.AXLE_CALC_RESULTS_FACT = 'axleCalcResults';
-exports.BASE_OVERLOAD_LIMIT = 28000;
-exports.EXTRA_WEIGHT_INTERVAL = 900;
-exports.EXTRA_RATE_INCREMENT = 1.85;
-exports.DEFAULT_MAX_RATE = 21.4;
-exports.MINIMUM_OVERLOAD_FEE = 25;

package/dist/enum/facts.d.ts

@@ -17,6 +17,7 @@ export declare enum CostFacts {
     CostPerKilometre = "costPerKilometre",
     CostPerMonth = "costPerMonth",
     FixedCost = "fixedCost",
-    OverloadCost = "overloadCost",
+    OverloadGvwCost = "overloadGvwCost",
+    OverloadWeightCost = "overloadWeightCost",
     RangeMatrixCostLookup = "rangeMatrixCostLookup"
 }

package/dist/enum/facts.js

@@ -22,6 +22,7 @@ var CostFacts;
     CostFacts["CostPerKilometre"] = "costPerKilometre";
     CostFacts["CostPerMonth"] = "costPerMonth";
     CostFacts["FixedCost"] = "fixedCost";
-    CostFacts["OverloadCost"] = "overloadCost";
+    CostFacts["OverloadGvwCost"] = "overloadGvwCost";
+    CostFacts["OverloadWeightCost"] = "overloadWeightCost";
     CostFacts["RangeMatrixCostLookup"] = "rangeMatrixCostLookup";
 })(CostFacts || (exports.CostFacts = CostFacts = {}));

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

@@ -7,6 +7,7 @@ export declare enum PolicyCheckId {
     AxleGroupMaximumLegalWeightThreshold = "axle-group-maximum-legal-weight-threshold",
     BoosterAxleLimit = "booster-axle-limit",
     BridgeFormula = "bridge-formula",
+    CheckLegalWeight = "check-legal-weight",
     CheckPermittableWeight = "check-permittable-weight",
     DriveJeepLoadEqualization = "drive-jeep-load-equalization",
     MaxTireLoad = "max-tire-load",

package/dist/enum/policy-check.js

@@ -12,6 +12,7 @@ var PolicyCheckId;
     PolicyCheckId["AxleGroupMaximumLegalWeightThreshold"] = "axle-group-maximum-legal-weight-threshold";
     PolicyCheckId["BoosterAxleLimit"] = "booster-axle-limit";
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
+    PolicyCheckId["CheckLegalWeight"] = "check-legal-weight";
     PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";
     PolicyCheckId["DriveJeepLoadEqualization"] = "drive-jeep-load-equalization";
     PolicyCheckId["MaxTireLoad"] = "max-tire-load";

package/dist/enum/validation-result-code.d.ts

@@ -4,6 +4,7 @@ export declare enum ValidationResultCode {
     PolicyValidationError = "policy-validation-error",
     ConfigurationInvalid = "configuration-invalid",
     GeneralResult = "general-result",
+    DimensionOversize = "dimension-oversize",
     CostValue = "cost-value",
     IsLcvCarrier = "lcv-carrier",
     NoFeeClient = "no-fee-client"

package/dist/enum/validation-result-code.js

@@ -8,6 +8,7 @@ var ValidationResultCode;
     ValidationResultCode["PolicyValidationError"] = "policy-validation-error";
     ValidationResultCode["ConfigurationInvalid"] = "configuration-invalid";
     ValidationResultCode["GeneralResult"] = "general-result";
+    ValidationResultCode["DimensionOversize"] = "dimension-oversize";
     ValidationResultCode["CostValue"] = "cost-value";
     ValidationResultCode["IsLcvCarrier"] = "lcv-carrier";
     ValidationResultCode["NoFeeClient"] = "no-fee-client";

package/dist/helper/facts.helper.js

@@ -9,6 +9,7 @@ const quarterOfYear_1 = __importDefault(require("dayjs/plugin/quarterOfYear"));
 const enum_1 = require("onroute-policy-engine/enum");
 const policy_check_helper_1 = require("./policy-check.helper");
 const stgvwi_1 = require("../constants/stgvwi");
+const overload_1 = require("../constants/overload");
 dayjs_1.default.extend(quarterOfYear_1.default);
 const getAxleCalculationInputs = async (policy, almanac) => {
     var _a, _b;
@@ -28,6 +29,28 @@ const getAxleCalculationInputs = async (policy, almanac) => {
         licensedGVW: vehicleDetails.licensedGVW || 0,
     };
 };
+const getOverloadCost = (overloadKg, totalDistance) => {
+    let ratePer10km = 0;
+    if (overloadKg <= overload_1.BASE_OVERLOAD_LIMIT) {
+        const match = overload_1.OVERLOAD_RATES_PER_10KM.find((r) => overloadKg <= r.max);
+        ratePer10km = match ? match.rate : overload_1.DEFAULT_MAX_RATE;
+    }
+    else {
+        // For overload greater than BASE_OVERLOAD_LIMIT kg
+        const extraWeight = overloadKg - overload_1.BASE_OVERLOAD_LIMIT;
+        const intervals = Math.ceil(extraWeight / overload_1.EXTRA_WEIGHT_INTERVAL);
+        ratePer10km = overload_1.DEFAULT_MAX_RATE + intervals * overload_1.EXTRA_RATE_INCREMENT;
+    }
+    // Fee calculation: rate * (totalDistance / 10)
+    const distanceUnits = Math.ceil(totalDistance / 10);
+    let totalFee = ratePer10km * distanceUnits;
+    // Apply minimum fee rule
+    if (totalFee < overload_1.MINIMUM_OVERLOAD_FEE) {
+        totalFee = overload_1.MINIMUM_OVERLOAD_FEE;
+    }
+    // Round to the nearest dollar (0.50 rounds up)
+    return Math.round(totalFee);
+};
 /**
  * Adds runtime facts for the validation. For example, adds the
  * validation date for comparison against startDate of the permit.
@@ -308,7 +331,7 @@ function addRuntimeFacts(engine, policy) {
      * Add runtime fact to calculate the overload fee for STGVWI permits
      * based on the Licensed GVW Increase and Total Distance.
      */
-    engine.addFact(enum_1.CostFacts.OverloadCost.toString(), async function (params, almanac) {
+    engine.addFact(enum_1.CostFacts.OverloadGvwCost.toString(), async function (params, almanac) {
         const actualGVW = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, 'vehicleConfiguration.actualGVW');
         const licensedGVW = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, 'vehicleDetails.licensedGVW');
         const distance = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.TotalDistance);
@@ -316,55 +339,18 @@ function addRuntimeFacts(engine, policy) {
         if (overloadKg <= 0 || !distance) {
             return 0;
         }
-        let ratePer10km = 0;
-        if (overloadKg <= stgvwi_1.BASE_OVERLOAD_LIMIT) {
-            // Overload permit fee rate table mapping up to 28,000 kg
-            const rates = [
-                { max: 2000, rate: 0.95 },
-                { max: 3000, rate: 1.15 },
-                { max: 4000, rate: 1.4 },
-                { max: 5000, rate: 1.6 },
-                { max: 6000, rate: 1.85 },
-                { max: 7000, rate: 2.15 },
-                { max: 8000, rate: 2.45 },
-                { max: 9000, rate: 2.95 },
-                { max: 10000, rate: 3.35 },
-                { max: 11000, rate: 3.75 },
-                { max: 12000, rate: 4.25 },
-                { max: 13000, rate: 4.95 },
-                { max: 14000, rate: 5.6 },
-                { max: 15000, rate: 6.25 },
-                { max: 16000, rate: 7.25 },
-                { max: 17000, rate: 8.25 },
-                { max: 18000, rate: 9.15 },
-                { max: 19000, rate: 10.1 },
-                { max: 20000, rate: 10.9 },
-                { max: 21000, rate: 11.85 },
-                { max: 22000, rate: 12.7 },
-                { max: 23000, rate: 13.95 },
-                { max: 24000, rate: 14.95 },
-                { max: 25000, rate: 16.1 },
-                { max: 26000, rate: 17.85 },
-                { max: 27000, rate: 19.85 },
-                { max: 28000, rate: 21.4 },
-            ];
-            const match = rates.find((r) => overloadKg <= r.max);
-            ratePer10km = match ? match.rate : stgvwi_1.DEFAULT_MAX_RATE;
-        }
-        else {
-            // For overload greater than BASE_OVERLOAD_LIMIT kg
-            const extraWeight = overloadKg - stgvwi_1.BASE_OVERLOAD_LIMIT;
-            const intervals = Math.ceil(extraWeight / stgvwi_1.EXTRA_WEIGHT_INTERVAL);
-            ratePer10km = stgvwi_1.DEFAULT_MAX_RATE + intervals * stgvwi_1.EXTRA_RATE_INCREMENT;
-        }
-        // Fee calculation: rate * (distance / 10)
-        const distanceUnits = Math.ceil(distance / 10);
-        let totalFee = ratePer10km * distanceUnits;
-        // Apply minimum fee rule
-        if (totalFee < stgvwi_1.MINIMUM_OVERLOAD_FEE) {
-            totalFee = stgvwi_1.MINIMUM_OVERLOAD_FEE;
+        return getOverloadCost(overloadKg, distance);
+    });
+    /**
+     * Add runtime fact to calculate the overload fee for STWSE permits
+     * based on the Weight over 27.5m and Total Distance.
+     */
+    engine.addFact(enum_1.CostFacts.OverloadWeightCost.toString(), async function (params, almanac) {
+        const overloadWeight = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, 'vehicleConfiguration.overloadWeight');
+        const totalDistance = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.TotalDistance);
+        if (overloadWeight <= 0 || !totalDistance) {
+            return 0;
         }
-        // Round to the nearest dollar (0.50 rounds up)
-        return Math.round(totalFee);
+        return getOverloadCost(overloadWeight, totalDistance);
     });
 }

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

@@ -16,6 +16,14 @@ import { Policy } from 'onroute-policy-engine';
 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 each axle unit against its legal weight maximum.
+ *
+ * The feature-defined steering and drive limits are authoritative for the
+ * standard truck/truck-tractor and PME subtypes. Other axle units retain
+ * their configured legal weight lookup.
+ */
+export declare function CheckLegalWeight(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates every contiguous axle-unit group within 8 m, excluding groups
  * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
@@ -301,6 +309,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * Currently includes:
  * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckLegalWeight: Validates axle units against legal weight limits
  * - CheckPermittableWeight: Validates total vehicle weight against permit limits
  * - MaxTireLoad: Validates tire load capacity for each axle unit
  * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyCheckMap = void 0;
 exports.getMaximumLegalAxleGroupWeightThreshold = getMaximumLegalAxleGroupWeightThreshold;
+exports.CheckLegalWeight = CheckLegalWeight;
 exports.CheckAxleGroupMaximumLegalWeightThreshold = CheckAxleGroupMaximumLegalWeightThreshold;
 exports.CheckNumberOfAxles = CheckNumberOfAxles;
 exports.CheckBridgeFormula = CheckBridgeFormula;
@@ -18,6 +19,27 @@ exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 const dimensions_helper_1 = require("./dimensions.helper");
 const ctr_717_helper_1 = require("./ctr-717.helper");
 const enum_1 = require("../enum");
+const POWER_UNIT_AXLE_CODE_MULTIPLIER = 10;
+const LEGAL_WEIGHT_MAXIMUM_KG = {
+    SINGLE_AXLE: 9100,
+    STANDARD_TRUCK_TRACTOR_STEER: 6000,
+    STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE: 7300,
+    TANDEM_AXLE: 17000,
+    STANDARD_TANDEM_STEER_WITH_TRIDEM_DRIVE: 13600,
+    PME_TANDEM_STEER_WITH_TRIDEM_DRIVE: 15200,
+    TRIDEM_AXLE: 24000,
+};
+const PERMITTABLE_WEIGHT_MAXIMUM_KG = {
+    SINGLE_STEER: 9100,
+    SINGLE_NON_STEER: 11000,
+    TANDEM: 23000,
+    STANDARD_TRIDEM: 28000,
+    QUALIFYING_TRIDEM: 29000,
+};
+const QUALIFYING_TRIDEM_SPREAD_CM = {
+    MINIMUM: 240,
+    MAXIMUM: 370,
+};
 /** Applies the standard lower-of rule or the exact 7.16(g) exception. */
 function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
     const tandemDriveSingleJeepMinimumKg = 24000;
@@ -34,7 +56,7 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
         return undefined;
     }
     const weights = vehicleIndex === 0
-        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
             axleConfiguration[1].numberOfAxles)
         : policy.getDefaultTrailerWeight(vehicleType, axle.numberOfAxles);
     if (weights.length === 0) {
@@ -42,6 +64,98 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
     }
     return (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a.legal;
 }
+function getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration) {
+    return axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined)
+        ? (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration)
+        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
+}
+function getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, threshold) {
+    var _a;
+    var _b;
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const axleUnit = axleConfiguration[axleIndex];
+    if (!vehicleType || !axleUnit) {
+        return 0;
+    }
+    const weights = vehicleIndex === 0
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
+            axleConfiguration[1].numberOfAxles)
+        : policy.getDefaultTrailerWeight(vehicleType, axleUnit.numberOfAxles);
+    if (weights.length === 0) {
+        return 0;
+    }
+    return ((_b = (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a[threshold]) !== null && _b !== void 0 ? _b : 0);
+}
+function isFeatureLegalWeightPowerUnit(vehicleType) {
+    return (vehicleType === 'REGTRCK' ||
+        vehicleType === 'TRKTRAC' ||
+        vehicleType === 'TRCKPME' ||
+        vehicleType === 'TRACPME');
+}
+function getFeatureLegalPowerUnitWeightThreshold(vehicleType, axleConfiguration, axleIndex) {
+    const steerAxle = axleConfiguration[0];
+    const driveAxle = axleConfiguration[1];
+    const hasPme = vehicleType === 'TRCKPME' || vehicleType === 'TRACPME';
+    if (axleIndex === 0) {
+        if (steerAxle.numberOfAxles === 1 &&
+            (driveAxle.numberOfAxles === 1 || driveAxle.numberOfAxles === 2)) {
+            return hasPme || vehicleType === 'REGTRCK'
+                ? LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_TRUCK_TRACTOR_STEER;
+        }
+        if (steerAxle.numberOfAxles === 1 && driveAxle.numberOfAxles === 3) {
+            return hasPme
+                ? LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE;
+        }
+        if (steerAxle.numberOfAxles === 2 && driveAxle.numberOfAxles === 2) {
+            return LEGAL_WEIGHT_MAXIMUM_KG.TANDEM_AXLE;
+        }
+        if (steerAxle.numberOfAxles === 2 && driveAxle.numberOfAxles === 3) {
+            return hasPme
+                ? LEGAL_WEIGHT_MAXIMUM_KG.PME_TANDEM_STEER_WITH_TRIDEM_DRIVE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_TANDEM_STEER_WITH_TRIDEM_DRIVE;
+        }
+    }
+    if (axleIndex === 1) {
+        return {
+            1: LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE,
+            2: LEGAL_WEIGHT_MAXIMUM_KG.TANDEM_AXLE,
+            3: LEGAL_WEIGHT_MAXIMUM_KG.TRIDEM_AXLE,
+        }[driveAxle.numberOfAxles];
+    }
+    return undefined;
+}
+/**
+ * Validates each axle unit against its legal weight maximum.
+ *
+ * The feature-defined steering and drive limits are authoritative for the
+ * standard truck/truck-tractor and PME subtypes. Other axle units retain
+ * their configured legal weight lookup.
+ */
+function CheckLegalWeight(policy, vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.CheckLegalWeight;
+    const powerUnitType = vehicleConfiguration[0];
+    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    return axleConfiguration.map((axleUnit, axleIndex) => {
+        const featureThreshold = axleUnitVehicleIndexes[axleIndex] === 0 &&
+            isFeatureLegalWeightPowerUnit(powerUnitType)
+            ? getFeatureLegalPowerUnitWeightThreshold(powerUnitType, axleConfiguration, axleIndex)
+            : undefined;
+        const legalWeight = featureThreshold !== null && featureThreshold !== void 0 ? featureThreshold : getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, 'legal');
+        const result = axleUnit.axleUnitWeight <= legalWeight;
+        const axleUnitNumber = axleIndex + 1;
+        return {
+            id: policyId,
+            message: `Weight for axle unit ${axleUnitNumber} ${result ? 'is legal' : `must not exceed ${legalWeight} kgs`}`,
+            result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
+            axleUnit: axleUnitNumber,
+            actualWeight: axleUnit.axleUnitWeight,
+            thresholdWeight: legalWeight,
+        };
+    });
+}
 /**
  * Validates every contiguous axle-unit group within 8 m, excluding groups
  * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
@@ -172,6 +286,37 @@ function CheckNumberOfAxles(_policy, _vehicleConfiguration, axleConfiguration) {
     });
     return policyCheckResults;
 }
+function getBridgeFormulaInputFailure(axleConfiguration) {
+    for (let axleIndex = 0; axleIndex < axleConfiguration.length; axleIndex++) {
+        const axleUnit = axleConfiguration[axleIndex];
+        const axleUnitNumber = axleIndex + 1;
+        let message;
+        if (!Number.isFinite(axleUnit.axleUnitWeight) ||
+            axleUnit.axleUnitWeight <= 0) {
+            message = `Axle unit weight for axle unit ${axleUnitNumber} must be a finite number greater than 0.`;
+        }
+        else if (axleUnit.numberOfAxles > 1 &&
+            (!Number.isFinite(axleUnit.axleSpread) ||
+                axleUnit.axleSpread <= 0)) {
+            message = `Axle spread for axle unit ${axleUnitNumber} must be a finite number greater than 0 when the unit has multiple axles.`;
+        }
+        else if (axleIndex > 0 &&
+            (!Number.isFinite(axleUnit.interaxleSpacing) ||
+                axleUnit.interaxleSpacing <= 0)) {
+            message = `Axle spacing before axle unit ${axleUnitNumber} must be a finite number greater than 0.`;
+        }
+        if (message) {
+            return {
+                id: enum_1.PolicyCheckId.BridgeFormula,
+                message,
+                result: enum_1.PolicyCheckResultType.Fail,
+                startAxleUnit: axleUnitNumber,
+                endAxleUnit: axleUnitNumber,
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Performs bridge formula calculations on axle groups and returns policy check results.
  *
@@ -201,6 +346,10 @@ function CheckNumberOfAxles(_policy, _vehicleConfiguration, axleConfiguration) {
 function CheckBridgeFormula(policy, _vehicleConfiguration, axleConfiguration) {
     const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.BridgeFormula;
+    const inputFailure = getBridgeFormulaInputFailure(axleConfiguration);
+    if (inputFailure) {
+        return [inputFailure];
+    }
     const bridgeCalcResults = policy.calculateBridge(axleConfiguration);
     bridgeCalcResults.forEach((br) => {
         const message = `Axle group ${br.startAxleUnit} to ${br.endAxleUnit} ${br.success ? 'passes' : 'does not pass'} bridge formula.`;
@@ -338,77 +487,51 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  * @see SingleAxleDimension
  */
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
-    const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.CheckPermittableWeight;
-    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
-    // Legacy John Fletcher implementation, restored from:
-    // git show e4a9d6badd025dec844df43379f776a4995ad75b^:src/helper/policy-check.helper.ts
-    if (!hasVehicleIndexes) {
-        const singleAxleDimensions = [];
-        vehicleConfiguration.forEach((vc, i) => {
-            let weight;
-            if (i === 0) {
-                const powerUnitAxles = axleConfiguration[0].numberOfAxles * 10 +
-                    axleConfiguration[1].numberOfAxles;
-                weight = policy.getDefaultPowerUnitWeight(vc, powerUnitAxles);
-                const steerAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 0) || {};
-                singleAxleDimensions.push(steerAxleDimension);
-                const driveAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 1) || {};
-                singleAxleDimensions.push(driveAxleDimension);
+    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    return axleConfiguration.map((axleUnit, axleIndex) => {
+        const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+        const isSingleSteer = axleIndex === 0 && vehicleIndex === 0 && axleUnit.numberOfAxles === 1;
+        const isTandemSteer = axleIndex === 0 && vehicleIndex === 0 && axleUnit.numberOfAxles === 2;
+        let permittableWeight;
+        if (isSingleSteer) {
+            permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.SINGLE_STEER;
+        }
+        else if (!isTandemSteer) {
+            if (axleUnit.numberOfAxles === 1) {
+                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.SINGLE_NON_STEER;
             }
-            else if (i + 1 < axleConfiguration.length) {
-                weight = policy.getDefaultTrailerWeight(vc, axleConfiguration[i + 1].numberOfAxles);
-                const trailerDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i + 1) || {};
-                singleAxleDimensions.push(trailerDimension);
+            else if (axleUnit.numberOfAxles === 2) {
+                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.TANDEM;
             }
-        });
-        axleConfiguration.forEach((ac, i) => {
-            const actualWeight = ac.axleUnitWeight;
-            const permittableWeight = singleAxleDimensions[i].permittable || 0;
-            const result = actualWeight <= permittableWeight;
-            const axleUnit = i + 1;
-            const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
-            policyCheckResults.push({
-                id: policyId,
-                message: message,
-                result: result
-                    ? enum_1.PolicyCheckResultType.Pass
-                    : enum_1.PolicyCheckResultType.Fail,
-                axleUnit: axleUnit,
-                actualWeight: actualWeight,
-                thresholdWeight: permittableWeight,
-            });
-        });
-        return policyCheckResults;
-    }
-    // Explicit multi-axle ownership path supplied by the consuming application.
-    // This is the new way, using { vehicleIndex: num }
-    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration);
-    axleConfiguration.forEach((ac, i) => {
-        const vehicleIndex = axleUnitVehicleIndexes[i];
-        const vehicleType = vehicleConfiguration[vehicleIndex];
-        const weight = vehicleIndex === 0
-            ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
-                axleConfiguration[1].numberOfAxles)
-            : policy.getDefaultTrailerWeight(vehicleType, ac.numberOfAxles);
-        const axleDimension = weight.length > 0
-            ? policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i) || {}
-            : {};
-        const actualWeight = ac.axleUnitWeight;
-        const permittableWeight = axleDimension.permittable || 0;
-        const result = actualWeight <= permittableWeight;
-        const axleUnit = i + 1;
-        const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
-        policyCheckResults.push({
+            else if (axleUnit.numberOfAxles === 3) {
+                const spreadQualifies = axleUnit.axleSpread !== undefined &&
+                    axleUnit.axleSpread >= QUALIFYING_TRIDEM_SPREAD_CM.MINIMUM &&
+                    axleUnit.axleSpread <= QUALIFYING_TRIDEM_SPREAD_CM.MAXIMUM;
+                const nextVehicleIndex = vehicleIndex + 1;
+                const hasImmediatelyFollowingBooster = vehicleConfiguration[nextVehicleIndex] ===
+                    enum_1.AccessoryVehicleType.Booster;
+                const boosterAxle = axleConfiguration.find((_, candidateIndex) => candidateIndex > axleIndex &&
+                    axleUnitVehicleIndexes[candidateIndex] === nextVehicleIndex);
+                const boosterQualifies = !hasImmediatelyFollowingBooster || (boosterAxle === null || boosterAxle === void 0 ? void 0 : boosterAxle.numberOfAxles) === 1;
+                permittableWeight =
+                    spreadQualifies && boosterQualifies
+                        ? PERMITTABLE_WEIGHT_MAXIMUM_KG.QUALIFYING_TRIDEM
+                        : PERMITTABLE_WEIGHT_MAXIMUM_KG.STANDARD_TRIDEM;
+            }
+        }
+        permittableWeight !== null && permittableWeight !== void 0 ? permittableWeight : (permittableWeight = getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, 'permittable'));
+        const result = axleUnit.axleUnitWeight <= permittableWeight;
+        const axleUnitNumber = axleIndex + 1;
+        return {
             id: policyId,
-            message: message,
+            message: `Weight for axle unit ${axleUnitNumber} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`,
             result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
-            axleUnit: axleUnit,
-            actualWeight: actualWeight,
+            axleUnit: axleUnitNumber,
+            actualWeight: axleUnit.axleUnitWeight,
             thresholdWeight: permittableWeight,
-        });
+        };
     });
-    return policyCheckResults;
 }
 /**
  * Validates minimum steer axle weight requirements for single steer, tridem drive power units.
@@ -1092,6 +1215,7 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * Currently includes:
  * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckLegalWeight: Validates axle units against legal weight limits
  * - CheckPermittableWeight: Validates total vehicle weight against permit limits
  * - MaxTireLoad: Validates tire load capacity for each axle unit
  * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles
@@ -1116,6 +1240,7 @@ exports.policyCheckMap = new Map([
         enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
         CheckAxleGroupMaximumLegalWeightThreshold,
     ],
+    [enum_1.PolicyCheckId.CheckLegalWeight, CheckLegalWeight],
     [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],

package/dist/helper/rules-engine.helper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRulesEngines = getRulesEngines;
 const json_rules_engine_1 = require("json-rules-engine");
 const custom_operators_1 = require("../rule-operator/custom-operators");
+const cost_1 = require("../constants/cost");
 /**
  * Gets a json-rules-engine with all onRouteBC custom operators added,
  * and all policy rules that apply to all permit types added.
@@ -51,7 +52,7 @@ function getRulesEngines(policy) {
                 event: {
                     type: 'cost',
                     params: {
-                        message: 'Calculated permit cost',
+                        message: c.params.description || cost_1.DEFAULT_COST_DESCRIPTION,
                         code: 'cost-value',
                         cost: c,
                     },

package/dist/policy-engine.js

@@ -21,6 +21,7 @@ const dimensions_helper_1 = require("./helper/dimensions.helper");
 const dimensions_helper_2 = require("./helper/dimensions.helper");
 const display_code_helper_1 = require("./helper/display-code-helper");
 const policy_check_helper_1 = require("./helper/policy-check.helper");
+const cost_1 = require("./constants/cost");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -92,11 +93,22 @@ class Policy {
             // has a no fee flag set.
             if ((_d = this.specialAuthorizations) === null || _d === void 0 ? void 0 : _d.noFeeType) {
                 const originalPermitCost = validationResults === null || validationResults === void 0 ? void 0 : validationResults.cost.reduce((accumulator, { cost }) => accumulator + (cost !== null && cost !== void 0 ? cost : 0), 0);
-                // Clear the cost array and replace with zero cost
-                validationResults.cost.length = 0;
-                const newPermitCostResult = new validation_result_1.ValidationResult(enum_1.ValidationResultType.Cost, enum_1.ValidationResultCode.CostValue, 'Calculated permit cost');
-                newPermitCostResult.cost = 0;
-                validationResults.cost.push(newPermitCostResult);
+                if (permit.permitType !== "STWSE") {
+                    // Clear the cost array and replace with zero cost
+                    validationResults.cost.length = 0;
+                    const newPermitCostResult = new validation_result_1.ValidationResult(enum_1.ValidationResultType.Cost, enum_1.ValidationResultCode.CostValue, cost_1.DEFAULT_COST_DESCRIPTION);
+                    newPermitCostResult.cost = 0;
+                    validationResults.cost.push(newPermitCostResult);
+                }
+                else {
+                    // If permit type is STWSE, keep each of the cost objects, but set their costs to zero
+                    const newPermitCosts = validationResults.cost.map(cost => {
+                        const newPermitCostResult = new validation_result_1.ValidationResult(enum_1.ValidationResultType.Cost, enum_1.ValidationResultCode.CostValue, cost.message);
+                        newPermitCostResult.cost = 0;
+                        return newPermitCostResult;
+                    });
+                    validationResults.cost = newPermitCosts;
+                }
                 // Add an informational message to the results
                 validationResults.information.push(new validation_result_1.ValidationResult(enum_1.ValidationResultType.Information, enum_1.ValidationResultCode.NoFeeClient, `Client '${this.specialAuthorizations.companyId}' has no fee flag, original permit cost would otherwise be '${originalPermitCost}'`));
             }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.22.1";
+export declare const version = "v2.24.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.22.1';
+exports.version = 'v2.24.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.22.1"
+  "version": "v2.24.0"
 }