@adtrackify/at-service-common 5.1.2 → 5.1.4

package/dist/cjs/__tests__/services/cost/cost-calculator-service.spec.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const at_tracking_event_types_1 = require("@adtrackify/at-tracking-event-types");
 const cost_calculator_service_1 = require("../../../services/cost/cost-calculator-service");
-vitest_1.vi.mock('../../../helpers/logging-helper', () => ({
-    Logger: { debug: vitest_1.vi.fn(), info: vitest_1.vi.fn(), warn: vitest_1.vi.fn(), error: vitest_1.vi.fn() },
+jest.mock('../../../helpers/logging-helper', () => ({
+    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
 }));
 const emptyRatesMap = {};
 const createLineItem = (overrides = {}) => ({
@@ -56,82 +55,82 @@ const createConfigs = (overrides = {}) => ({
     shipping: null,
     ...overrides,
 });
-(0, vitest_1.describe)('CostCalculatorService', () => {
-    (0, vitest_1.describe)('isDateInRange', () => {
-        (0, vitest_1.it)('should return true when no date bounds', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z')).toBe(true);
+describe('CostCalculatorService', () => {
+    describe('isDateInRange', () => {
+        it('should return true when no date bounds', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z')).toBe(true);
         });
-        (0, vitest_1.it)('should return true when order date is within range', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z', '2024-01-01T00:00:00Z', '2024-12-31T23:59:59Z')).toBe(true);
+        it('should return true when order date is within range', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z', '2024-01-01T00:00:00Z', '2024-12-31T23:59:59Z')).toBe(true);
         });
-        (0, vitest_1.it)('should return false when order date is before effectiveFrom', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.isDateInRange('2023-06-15T10:00:00Z', '2024-01-01T00:00:00Z')).toBe(false);
+        it('should return false when order date is before effectiveFrom', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.isDateInRange('2023-06-15T10:00:00Z', '2024-01-01T00:00:00Z')).toBe(false);
         });
-        (0, vitest_1.it)('should return false when order date is after effectiveTo', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.isDateInRange('2025-06-15T10:00:00Z', undefined, '2024-12-31T23:59:59Z')).toBe(false);
+        it('should return false when order date is after effectiveTo', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.isDateInRange('2025-06-15T10:00:00Z', undefined, '2024-12-31T23:59:59Z')).toBe(false);
         });
-        (0, vitest_1.it)('should return true for invalid order date', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.isDateInRange('invalid-date', '2024-01-01T00:00:00Z')).toBe(true);
+        it('should return true for invalid order date', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.isDateInRange('invalid-date', '2024-01-01T00:00:00Z')).toBe(true);
         });
     });
-    (0, vitest_1.describe)('findMatchingWeightTierAmount', () => {
-        (0, vitest_1.it)('should return 0 for empty tiers', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount([], 500, undefined)).toBe(0);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(undefined, 500, undefined)).toBe(0);
+    describe('findMatchingWeightTierAmount', () => {
+        it('should return 0 for empty tiers', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount([], 500, undefined)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(undefined, 500, undefined)).toBe(0);
         });
-        (0, vitest_1.it)('should find correct tier', () => {
+        it('should find correct tier', () => {
             const tiers = [
                 { weightMin: 0, weightMax: 500, flatAmount: 5 },
                 { weightMin: 501, weightMax: 1000, flatAmount: 10 },
                 { weightMin: 1001, weightMax: null, flatAmount: 15 },
             ];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 250, undefined)).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 750, undefined)).toBe(10);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 2000, undefined)).toBe(15);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 250, undefined)).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 750, undefined)).toBe(10);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 2000, undefined)).toBe(15);
         });
-        (0, vitest_1.it)('should return 0 when no tier matches', () => {
+        it('should return 0 when no tier matches', () => {
             const tiers = [{ weightMin: 100, weightMax: 200, flatAmount: 5 }];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 50, undefined)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 50, undefined)).toBe(0);
         });
-        (0, vitest_1.it)('should convert weight from grams to OUNCES before matching', () => {
+        it('should convert weight from grams to OUNCES before matching', () => {
             const tiers = [
                 { weightMin: 0, weightMax: 5, flatAmount: 2 },
                 { weightMin: 5.01, weightMax: null, flatAmount: 8 },
             ];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 100, at_tracking_event_types_1.WEIGHT_UNIT.OUNCES)).toBe(2);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, at_tracking_event_types_1.WEIGHT_UNIT.OUNCES)).toBe(8);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 100, at_tracking_event_types_1.WEIGHT_UNIT.OUNCES)).toBe(2);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, at_tracking_event_types_1.WEIGHT_UNIT.OUNCES)).toBe(8);
         });
-        (0, vitest_1.it)('should return 0 when tier has null flatAmount', () => {
+        it('should return 0 when tier has null flatAmount', () => {
             const tiers = [{ weightMin: 0, weightMax: 1000, flatAmount: null }];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, undefined)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, undefined)).toBe(0);
         });
     });
-    (0, vitest_1.describe)('findQuantityTierAmount', () => {
-        (0, vitest_1.it)('should return 0 for empty tiers', () => {
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount([], 5)).toBe(0);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(undefined, 5)).toBe(0);
+    describe('findQuantityTierAmount', () => {
+        it('should return 0 for empty tiers', () => {
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount([], 5)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(undefined, 5)).toBe(0);
         });
-        (0, vitest_1.it)('should find correct tier', () => {
+        it('should find correct tier', () => {
             const tiers = [
                 { quantityMin: 1, quantityMax: 10, flatAmount: 2 },
                 { quantityMin: 11, quantityMax: null, flatAmount: 1 },
             ];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(2);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 20)).toBe(1);
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(2);
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 20)).toBe(1);
         });
-        (0, vitest_1.it)('should return 0 when quantity is below all tiers', () => {
+        it('should return 0 when quantity is below all tiers', () => {
             const tiers = [
                 { quantityMin: 5, quantityMax: 10, flatAmount: 2 },
                 { quantityMin: 11, quantityMax: null, flatAmount: 1 },
             ];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 2)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 2)).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 when tier has null flatAmount', () => {
+        it('should return 0 when tier has null flatAmount', () => {
             const tiers = [{ quantityMin: 1, quantityMax: 10, flatAmount: null }];
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(0);
         });
     });
-    (0, vitest_1.describe)('calculateHandlingCost', () => {
+    describe('calculateHandlingCost', () => {
         const initLineItemCosts = (lineItemIds = ['1']) => {
             const result = {};
             for (const id of lineItemIds) {
@@ -139,23 +138,23 @@ const createConfigs = (overrides = {}) => ({
             }
             return result;
         };
-        (0, vitest_1.it)('should return 0 when no globalProductOverride', () => {
+        it('should return 0 when no globalProductOverride', () => {
             const configs = createConfigs();
             const lineItems = [createLineItem({ quantity: 1 })];
             const liCosts = initLineItemCosts();
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should apply the fee per unit, multiplied by quantity', () => {
+        it('should apply the fee per unit, multiplied by quantity', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
             const lineItems = [createLineItem({ lineItemId: '1', quantity: 3 })];
             const liCosts = initLineItemCosts();
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBe(6);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemHandlingCost).toBe(6);
+            expect(result).toBe(6);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(6);
         });
-        (0, vitest_1.it)('should sum across multiple line items using each quantity', () => {
+        it('should sum across multiple line items using each quantity', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
@@ -165,11 +164,11 @@ const createConfigs = (overrides = {}) => ({
             ];
             const liCosts = initLineItemCosts(['1', '2']);
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBe(10);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemHandlingCost).toBe(4);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemHandlingCost).toBe(6);
+            expect(result).toBe(10);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(4);
+            expect(liCosts['2'].totalLineItemHandlingCost).toBe(6);
         });
-        (0, vitest_1.it)('should match the variant-level fee when both are the same amount', () => {
+        it('should match the variant-level fee when both are the same amount', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
@@ -179,9 +178,9 @@ const createConfigs = (overrides = {}) => ({
             const variantTotal = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([
                 createLineItem({ lineItemId: '1', quantity, variantHandlingFee: 2 }),
             ]);
-            (0, vitest_1.expect)(globalTotal).toBe(variantTotal['1']);
+            expect(globalTotal).toBe(variantTotal['1']);
         });
-        (0, vitest_1.it)('should convert currency when config currency differs from order currency', () => {
+        it('should convert currency when config currency differs from order currency', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 10, currency: 'EUR' },
             });
@@ -189,17 +188,17 @@ const createConfigs = (overrides = {}) => ({
             const lineItems = [createLineItem({ quantity: 1 })];
             const liCosts = initLineItemCosts();
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', rates);
-            (0, vitest_1.expect)(result).toBeCloseTo(11);
+            expect(result).toBeCloseTo(11);
         });
-        (0, vitest_1.it)('should return fee without conversion when config has no currency', () => {
+        it('should return fee without conversion when config has no currency', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 5 },
             });
             const lineItems = [createLineItem({ quantity: 1 })];
             const liCosts = initLineItemCosts();
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(5);
         });
-        (0, vitest_1.it)('should skip line items that have a per-variant handling fee override', () => {
+        it('should skip line items that have a per-variant handling fee override', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
@@ -207,20 +206,20 @@ const createConfigs = (overrides = {}) => ({
             const liCosts = initLineItemCosts();
             liCosts['1'].totalLineItemHandlingCost = 4.5;
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBe(0);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemHandlingCost).toBe(4.5);
+            expect(result).toBe(0);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(4.5);
         });
-        (0, vitest_1.it)('should treat an explicit 0 override as an override and suppress the global fee', () => {
+        it('should treat an explicit 0 override as an override and suppress the global fee', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
             const lineItems = [createLineItem({ lineItemId: '1', quantity: 3, variantHandlingFee: 0 })];
             const liCosts = initLineItemCosts();
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBe(0);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemHandlingCost).toBe(0);
+            expect(result).toBe(0);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(0);
         });
-        (0, vitest_1.it)('should apply the global fee only to line items without an override', () => {
+        it('should apply the global fee only to line items without an override', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
             });
@@ -230,363 +229,273 @@ const createConfigs = (overrides = {}) => ({
             ];
             const liCosts = initLineItemCosts(['1', '2']);
             const result = cost_calculator_service_1.CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBe(2);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemHandlingCost).toBe(0);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemHandlingCost).toBe(2);
+            expect(result).toBe(2);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(0);
+            expect(liCosts['2'].totalLineItemHandlingCost).toBe(2);
         });
     });
-    (0, vitest_1.describe)('calculateGatewayCost', () => {
-        (0, vitest_1.it)('should return 0 when no gateway config', () => {
+    describe('calculateGatewayCost', () => {
+        it('should return 0 when no gateway config', () => {
             const configs = createConfigs();
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 when no matching gateway', () => {
+        it('should return 0 when no matching gateway', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'paypal', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should calculate flat + percent for matching gateway', () => {
+        it('should calculate flat + percent for matching gateway', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBeCloseTo(3.2);
+            expect(result).toBeCloseTo(3.20);
         });
-        (0, vitest_1.it)('should be case-insensitive for gateway name', () => {
+        it('should be case-insensitive for gateway name', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'Stripe', flatAmount: 1, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'Stripe', flatAmount: 1, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(1);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(1);
         });
-        (0, vitest_1.it)('should respect date range', () => {
+        it('should respect date range', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        {
-                            gatewayName: 'stripe',
-                            flatAmount: 1,
-                            percentRate: 0,
-                            currency: 'USD',
-                            effectiveFrom: '2025-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    entries: [{
+                            gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'USD',
+                            effectiveFrom: '2025-01-01T00:00:00Z', createdAt: '', updatedAt: '',
+                        }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should convert flat amount from entry currency', () => {
+        it('should convert flat amount from entry currency', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'EUR', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'EUR', createdAt: '', updatedAt: '' }],
                 },
             });
             const rates = { EUR: { USD: 1.1 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', rates);
-            (0, vitest_1.expect)(result).toBeCloseTo(1.1);
+            expect(result).toBeCloseTo(1.1);
         });
-        (0, vitest_1.it)('should pick first matching gateway when multiple entries exist', () => {
+        it('should pick first matching gateway when multiple entries exist', () => {
             const configs = createConfigs({
                 gateway: {
                     entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                        { gatewayName: 'stripe', flatAmount: 0.5, percentRate: 3.5, currency: 'USD', createdAt: '', updatedAt: '' },
+                        { gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
+                        { gatewayName: 'stripe', flatAmount: 0.50, percentRate: 3.5, currency: 'USD', createdAt: '', updatedAt: '' },
                     ],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBeCloseTo(3.2);
+            expect(result).toBeCloseTo(3.20);
         });
-        (0, vitest_1.it)('should respect effectiveTo date on gateway entry', () => {
+        it('should respect effectiveTo date on gateway entry', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        {
-                            gatewayName: 'stripe',
-                            flatAmount: 1,
-                            percentRate: 0,
-                            currency: 'USD',
-                            effectiveTo: '2024-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    entries: [{
+                            gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'USD',
+                            effectiveTo: '2024-01-01T00:00:00Z', createdAt: '', updatedAt: '',
+                        }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should match gateway when order has multiple gateways', () => {
+        it('should match gateway when order has multiple gateways', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'paypal', flatAmount: 0.5, percentRate: 3.0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.50, percentRate: 3.0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateGatewayCost(configs, ['stripe', 'paypal'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result).toBeCloseTo(3.5);
+            expect(result).toBeCloseTo(3.50);
         });
     });
-    (0, vitest_1.describe)('calculateShippingCost', () => {
-        (0, vitest_1.it)('should return 0 when no shipping config', () => {
+    describe('calculateShippingCost', () => {
+        it('should return 0 when no shipping config', () => {
             const configs = createConfigs();
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should return shopify amount for SHOPIFY_CHARGES method', () => {
+        it('should return shopify amount for SHOPIFY_CHARGES method', () => {
             const configs = createConfigs({
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 15.5, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15.5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 15.50, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15.50);
         });
-        (0, vitest_1.it)('should return fixed rate for FIXED_RATE method', () => {
+        it('should return fixed rate for FIXED_RATE method', () => {
             const configs = createConfigs({
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 8.99, currency: 'USD' },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(8.99);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(8.99);
         });
-        (0, vitest_1.it)('should convert fixed rate from shipping currency', () => {
+        it('should convert fixed rate from shipping currency', () => {
             const configs = createConfigs({
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 10, currency: 'GBP' },
             });
             const rates = { GBP: { USD: 1.27 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', rates);
-            (0, vitest_1.expect)(result).toBeCloseTo(12.7);
+            expect(result).toBeCloseTo(12.7);
         });
-        (0, vitest_1.it)('should match shipping profile by country', () => {
+        it('should match shipping profile by country', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Profile',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 15,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
         });
-        (0, vitest_1.it)('should fall back to default profile', () => {
+        it('should fall back to default profile', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Profile',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 15,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15);
         });
-        (0, vitest_1.it)('should handle weight-tiered profile', () => {
+        it('should handle weight-tiered profile', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'Weight',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.WEIGHT_TIERED,
-                            currency: 'USD',
+                    profiles: [{
+                            id: 'p1', name: 'Weight', countries: ['US'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'USD',
                             weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.GRAMS,
                             weightTiers: [
                                 { weightMin: 0, weightMax: 500, flatAmount: 5 },
                                 { weightMin: 501, weightMax: null, flatAmount: 10 },
                             ],
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 300, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 700, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(10);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 300, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 700, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(10);
         });
-        (0, vitest_1.it)('should return 0 when no shipping profile matches (no country match, no default)', () => {
+        it('should return 0 when no shipping profile matches (no country match, no default)', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'US Only',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    profiles: [{
+                            id: 'p1', name: 'US Only', countries: ['US'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
         });
-        (0, vitest_1.it)('should skip expired shipping profile and fall back to default', () => {
+        it('should skip expired shipping profile and fall back to default', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
                     profiles: [
                         {
-                            id: 'p1',
-                            name: 'US Expired',
-                            countries: ['US'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 5,
-                            currency: 'USD',
+                            id: 'p1', name: 'US Expired', countries: ['US'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
                             effectiveTo: '2024-01-01T00:00:00Z',
-                            createdAt: '',
-                            updatedAt: '',
+                            createdAt: '', updatedAt: '',
                         },
                         {
-                            id: 'p2',
-                            name: 'Default',
-                            countries: [],
-                            isDefault: true,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 12,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 12, currency: 'USD',
+                            createdAt: '', updatedAt: '',
                         },
                     ],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(12);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(12);
         });
-        (0, vitest_1.it)('should convert weight-tiered shipping profile amount from profile currency', () => {
+        it('should convert weight-tiered shipping profile amount from profile currency', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'EUR',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'EU Weight',
-                            countries: ['DE'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.WEIGHT_TIERED,
-                            currency: 'EUR',
+                    profiles: [{
+                            id: 'p1', name: 'EU Weight', countries: ['DE'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'EUR',
                             weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.GRAMS,
                             weightTiers: [
                                 { weightMin: 0, weightMax: 500, flatAmount: 5 },
                                 { weightMin: 501, weightMax: null, flatAmount: 10 },
                             ],
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
             const rates = { EUR: { USD: 1.1 } };
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'DE', 300, '2024-06-15T10:00:00Z', 'USD', rates)).toBeCloseTo(5.5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'DE', 300, '2024-06-15T10:00:00Z', 'USD', rates)).toBeCloseTo(5.5);
         });
-        (0, vitest_1.it)('should be case-insensitive for shipping profile country matching', () => {
+        it('should be case-insensitive for shipping profile country matching', () => {
             const configs = createConfigs({
                 shipping: {
                     method: at_tracking_event_types_1.SHIPPING_METHOD.SHIPPING_PROFILES,
                     currency: 'USD',
-                    profiles: [
-                        {
-                            id: 'p1',
-                            name: 'US',
-                            countries: ['us'],
-                            isDefault: false,
-                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                            flatAmount: 7,
-                            currency: 'USD',
-                            createdAt: '',
-                            updatedAt: '',
-                        },
-                    ],
+                    profiles: [{
+                            id: 'p1', name: 'US', countries: ['us'], isDefault: false,
+                            rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT, flatAmount: 7, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
                 },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(7);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(7);
         });
     });
-    (0, vitest_1.describe)('calculateOtherCostEntry', () => {
+    describe('calculateOtherCostEntry', () => {
         const initLineItemCosts = () => ({
             '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
         });
-        (0, vitest_1.it)('should calculate PER_ORDER flat amount as order-level cost', () => {
+        it('should calculate PER_ORDER flat amount as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 3 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(3);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(3);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate PER_LINE_ITEM with quantity as line-item-level cost', () => {
+        it('should calculate PER_LINE_ITEM with quantity as line-item-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
             const liCosts = initLineItemCosts();
             const context = createContext({ lineItems: [createLineItem({ quantity: 3 })] });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(6);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
         });
-        (0, vitest_1.it)('should accumulate PER_LINE_ITEM costs across multiple line items as line-item-level', () => {
+        it('should accumulate PER_LINE_ITEM costs across multiple line items as line-item-level', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
@@ -601,19 +510,19 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(18);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(2);
-            (0, vitest_1.expect)(liCosts['3'].totalLineItemOtherCost).toBe(10);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(18);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(2);
+            expect(liCosts['3'].totalLineItemOtherCost).toBe(10);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with flat amount as order-level cost', () => {
+        it('should calculate BY_ORDER_WEIGHT with flat amount as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, { flatAmount: 0.01 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(5);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with weight tiers in KILOGRAMS (totalWeight is grams from Shopify)', () => {
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in KILOGRAMS (totalWeight is grams from Shopify)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.KILOGRAMS,
                 weightIntervals: [
@@ -622,11 +531,11 @@ const createConfigs = (overrides = {}) => ({
                     { weightMin: 20.01, weightMax: null, flatAmount: 15 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(8);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 25000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(15);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(8);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 25000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(15);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with weight tiers in POUNDS', () => {
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in POUNDS', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.POUNDS,
                 weightIntervals: [
@@ -634,10 +543,10 @@ const createConfigs = (overrides = {}) => ({
                     { weightMin: 10.01, weightMax: null, flatAmount: 12 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(12);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(12);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with weight tiers in GRAMS (no conversion needed)', () => {
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in GRAMS (no conversion needed)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.GRAMS,
                 weightIntervals: [
@@ -645,10 +554,10 @@ const createConfigs = (overrides = {}) => ({
                     { weightMin: 1001, weightMax: null, flatAmount: 7 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 1500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(7);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 1500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(7);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with weight tiers and no weightUnit (treats as grams)', () => {
+        it('should calculate BY_ORDER_WEIGHT with weight tiers and no weightUnit (treats as grams)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 weightUnit: undefined,
                 weightIntervals: [
@@ -656,35 +565,35 @@ const createConfigs = (overrides = {}) => ({
                     { weightMin: 1001, weightMax: null, flatAmount: 9 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(4);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(4);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with flat amount and KILOGRAMS unit (converts weight before multiplying)', () => {
+        it('should calculate BY_ORDER_WEIGHT with flat amount and KILOGRAMS unit (converts weight before multiplying)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
-                flatAmount: 0.5,
+                flatAmount: 0.50,
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.KILOGRAMS,
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(1);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(1);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_WEIGHT with flat amount and POUNDS unit (converts weight before multiplying)', () => {
+        it('should calculate BY_ORDER_WEIGHT with flat amount and POUNDS unit (converts weight before multiplying)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
-                flatAmount: 2.0,
+                flatAmount: 2.00,
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.POUNDS,
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 453.592 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(2);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBeCloseTo(2);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_LINE_ITEM_QUANTITY with flat amount as line-item-level cost', () => {
-            const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 0.5 });
+        it('should calculate BY_LINE_ITEM_QUANTITY with flat amount as line-item-level cost', () => {
+            const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 0.50 });
             const liCosts = initLineItemCosts();
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(5);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(5);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(5);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(5);
         });
-        (0, vitest_1.it)('should calculate BY_LINE_ITEM_QUANTITY with tiers per line item quantity', () => {
+        it('should calculate BY_LINE_ITEM_QUANTITY with tiers per line item quantity', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 quantityIntervals: [
                     { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
@@ -693,14 +602,14 @@ const createConfigs = (overrides = {}) => ({
             });
             const liCosts1 = initLineItemCosts();
             const result1 = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 3 })] }), liCosts1, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result1.lineItemLevel).toBe(3);
-            (0, vitest_1.expect)(result1.orderLevel).toBe(0);
+            expect(result1.lineItemLevel).toBe(3);
+            expect(result1.orderLevel).toBe(0);
             const liCosts2 = initLineItemCosts();
             const result2 = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts2, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result2.lineItemLevel).toBe(2);
-            (0, vitest_1.expect)(result2.orderLevel).toBe(0);
+            expect(result2.lineItemLevel).toBe(2);
+            expect(result2.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_LINE_ITEM_QUANTITY with multiple line items at different tiers', () => {
+        it('should calculate BY_LINE_ITEM_QUANTITY with multiple line items at different tiers', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 quantityIntervals: [
                     { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
@@ -718,28 +627,28 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(5);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(3);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(2);
+            expect(result.lineItemLevel).toBe(5);
+            expect(result.orderLevel).toBe(0);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(3);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(2);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_QUANTITY with flat amount as order-level cost', () => {
-            const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 0.5 });
+        it('should calculate BY_ORDER_QUANTITY with flat amount as order-level cost', () => {
+            const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 0.50 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(5);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_QUANTITY with tiers as order-level cost', () => {
+        it('should calculate BY_ORDER_QUANTITY with tiers as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
                 quantityIntervals: [
                     { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
                     { quantityMin: 6, quantityMax: null, flatAmount: 2 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 3 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 3 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_QUANTITY with multiple tiers correctly', () => {
+        it('should calculate BY_ORDER_QUANTITY with multiple tiers correctly', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
                 quantityIntervals: [
                     { quantityMin: 1, quantityMax: 10, flatAmount: 5 },
@@ -747,31 +656,33 @@ const createConfigs = (overrides = {}) => ({
                     { quantityMin: 51, quantityMax: null, flatAmount: 1 },
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 1 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 25 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 100 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(1);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 1 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 25 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 100 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(1);
         });
-        (0, vitest_1.it)('should return 0 for BY_ORDER_QUANTITY when quantity does not match any tier', () => {
+        it('should return 0 for BY_ORDER_QUANTITY when quantity does not match any tier', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
-                quantityIntervals: [{ quantityMin: 5, quantityMax: 10, flatAmount: 3 }],
+                quantityIntervals: [
+                    { quantityMin: 5, quantityMax: 10, flatAmount: 3 },
+                ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 2 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 2 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate BY_ORDER_QUANTITY with empty quantityIntervals using flat amount', () => {
+        it('should calculate BY_ORDER_QUANTITY with empty quantityIntervals using flat amount', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 2, quantityIntervals: [] });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 7 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(14);
+            expect(result.orderLevel).toBe(14);
         });
-        (0, vitest_1.it)('should return 0 for BY_LINE_ITEM_QUANTITY when line item quantity is below all tiers', () => {
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when line item quantity is below all tiers', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 quantityIntervals: [{ quantityMin: 5, quantityMax: 10, flatAmount: 3 }],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 2 })] }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply BY_LINE_ITEM_QUANTITY filters per line item, skipping non-matching ones', () => {
+        it('should apply BY_LINE_ITEM_QUANTITY filters per line item, skipping non-matching ones', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 flatAmount: 1,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
@@ -782,40 +693,32 @@ const createConfigs = (overrides = {}) => ({
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 4,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 6,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 4, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 6, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(4);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(4);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(4);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should convert flat amount for BY_ORDER_QUANTITY', () => {
+        it('should convert flat amount for BY_ORDER_QUANTITY', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 5, currency: 'GBP' });
             const rates = { GBP: { USD: 1.27 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', rates);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(63.5);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBeCloseTo(63.5);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should convert tier amount currency for BY_ORDER_QUANTITY', () => {
+        it('should convert tier amount currency for BY_ORDER_QUANTITY', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
                 currency: 'EUR',
                 quantityIntervals: [{ quantityMin: 1, quantityMax: null, flatAmount: 10 }],
             });
             const rates = { EUR: { USD: 1.1 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 5 }), initLineItemCosts(), 'USD', rates);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(11);
+            expect(result.orderLevel).toBeCloseTo(11);
         });
-        (0, vitest_1.it)('should return 0 for BY_ORDER_QUANTITY when order filters do not match', () => {
+        it('should return 0 for BY_ORDER_QUANTITY when order filters do not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
                 flatAmount: 5,
                 filters: { orderTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['wholesale'] } },
@@ -824,15 +727,14 @@ const createConfigs = (overrides = {}) => ({
                 totalQuantity: 10,
                 orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate PER_REFUND_ORDER when hasRefund as order-level cost', () => {
+        it('should calculate PER_REFUND_ORDER when hasRefund as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { flatAmount: 5 });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: true }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: false }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: true }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: false }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should calculate PER_REFUND_LINE_ITEM as line-item-level cost', () => {
+        it('should calculate PER_REFUND_LINE_ITEM as line-item-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 2 });
             const liCosts = initLineItemCosts();
             const context = createContext({
@@ -840,17 +742,17 @@ const createConfigs = (overrides = {}) => ({
                 lineItems: [createLineItem({ refundedQuantity: 2 })],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(4);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(4);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(4);
         });
-        (0, vitest_1.it)('should skip PER_REFUND_LINE_ITEM when refundedQuantity is 0', () => {
+        it('should skip PER_REFUND_LINE_ITEM when refundedQuantity is 0', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 2 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should only count refunded line items for PER_REFUND_LINE_ITEM with mixed refund/non-refund', () => {
+        it('should only count refunded line items for PER_REFUND_LINE_ITEM with mixed refund/non-refund', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 3 });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
@@ -866,70 +768,70 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(9);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
-            (0, vitest_1.expect)(liCosts['3'].totalLineItemOtherCost).toBe(3);
+            expect(result.lineItemLevel).toBe(9);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['3'].totalLineItemOtherCost).toBe(3);
         });
-        (0, vitest_1.it)('should calculate PCT_COGS as order-level cost', () => {
+        it('should calculate PCT_COGS as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalProductCost: 50 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(5);
+            expect(result.orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should calculate PCT_SHIPPING as order-level cost', () => {
+        it('should calculate PCT_SHIPPING as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { percentRate: 5 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalShipping: 20 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(1);
+            expect(result.orderLevel).toBe(1);
         });
-        (0, vitest_1.it)('should calculate PCT_TOTAL_SALES as order-level cost', () => {
+        it('should calculate PCT_TOTAL_SALES as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 2 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalPrice: 200 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(4);
+            expect(result.orderLevel).toBe(4);
         });
-        (0, vitest_1.it)('should calculate PCT_GROSS_SALES as order-level cost', () => {
+        it('should calculate PCT_GROSS_SALES as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { percentRate: 3 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ grossSalePrice: 150 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(4.5);
+            expect(result.orderLevel).toBeCloseTo(4.5);
         });
-        (0, vitest_1.it)('should calculate PCT_NET_SALES as order-level cost', () => {
+        it('should calculate PCT_NET_SALES as order-level cost', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: 4 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ netSalePrice: 80 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(3.2);
+            expect(result.orderLevel).toBe(3.2);
         });
-        (0, vitest_1.it)('should return 0 for PCT_COGS when totalProductCost is 0', () => {
+        it('should return 0 for PCT_COGS when totalProductCost is 0', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalProductCost: 0 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_SHIPPING when totalShipping is 0', () => {
+        it('should return 0 for PCT_SHIPPING when totalShipping is 0', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { percentRate: 5 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalShipping: 0 }), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when flatAmount is 0', () => {
+        it('should return 0 for PER_ORDER when flatAmount is 0', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 0 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PER_LINE_ITEM when quantity is 0', () => {
+        it('should return 0 for PER_LINE_ITEM when quantity is 0', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
             const context = createContext({ lineItems: [createLineItem({ quantity: 0 })] });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for unknown entry type', () => {
+        it('should return 0 for unknown entry type', () => {
             const entry = createEntry('UNKNOWN_TYPE', { flatAmount: 5 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should convert flat amount for BY_ORDER_WEIGHT (flat * weight mode)', () => {
+        it('should convert flat amount for BY_ORDER_WEIGHT (flat * weight mode)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, { flatAmount: 2, currency: 'EUR' });
             const rates = { EUR: { USD: 1.1 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', rates);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(1100);
+            expect(result.orderLevel).toBeCloseTo(1100);
         });
-        (0, vitest_1.it)('should convert tier amount for BY_ORDER_WEIGHT with tiers + currency', () => {
+        it('should convert tier amount for BY_ORDER_WEIGHT with tiers + currency', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 currency: 'EUR',
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.GRAMS,
@@ -939,34 +841,32 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const rates = { EUR: { USD: 1.1 } };
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 300 }), initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(5.5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 300 }), initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(5.5);
         });
-        (0, vitest_1.it)('should convert flat amount for BY_LINE_ITEM_QUANTITY', () => {
+        it('should convert flat amount for BY_LINE_ITEM_QUANTITY', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 5, currency: 'GBP' });
             const rates = { GBP: { USD: 1.27 } };
             const liCosts = initLineItemCosts();
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts, 'USD', rates);
-            (0, vitest_1.expect)(result.lineItemLevel).toBeCloseTo(63.5);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBeCloseTo(63.5);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 when order-level filters do not match', () => {
+        it('should return 0 when order-level filters do not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { countries: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['US'] } },
             });
-            const context = createContext({
-                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
-            });
+            const context = createContext({ orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' } });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should convert flat amount from entry currency', () => {
+        it('should convert flat amount from entry currency', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: 'EUR' });
             const rates = { EUR: { USD: 1.1 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', rates);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(11);
+            expect(result.orderLevel).toBeCloseTo(11);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when product filter does not match any line item', () => {
+        it('should return 0 for PER_ORDER when product filter does not match any line item', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
@@ -974,10 +874,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when product filter matches a line item', () => {
+        it('should apply PER_ORDER when product filter matches a line item', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P100'] } },
@@ -985,33 +884,26 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when at least one of multiple line items matches product filter', () => {
+        it('should apply PER_ORDER when at least one of multiple line items matches product filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike' } }),
                 ],
             });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
                 '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
             };
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for BY_ORDER_WEIGHT when productTags filter does not match any line item', () => {
+        it('should return 0 for BY_ORDER_WEIGHT when productTags filter does not match any line item', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 flatAmount: 0.01,
                 filters: { productTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['fragile'] } },
@@ -1020,10 +912,9 @@ const createConfigs = (overrides = {}) => ({
                 totalWeight: 500,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['lightweight'] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply BY_ORDER_WEIGHT when productTags filter matches a line item', () => {
+        it('should apply BY_ORDER_WEIGHT when productTags filter matches a line item', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 flatAmount: 0.01,
                 filters: { productTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['fragile'] } },
@@ -1032,84 +923,62 @@ const createConfigs = (overrides = {}) => ({
                 totalWeight: 500,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['fragile'] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for BY_LINE_ITEM_QUANTITY when productVendors filter does not match', () => {
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when productVendors filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 flatAmount: 0.5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({
-                        quantity: 10,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
-                ],
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply BY_LINE_ITEM_QUANTITY when productVendors filter matches', () => {
+        it('should apply BY_LINE_ITEM_QUANTITY when productVendors filter matches', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 flatAmount: 0.5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({
-                        quantity: 10,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                ],
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for PCT_GROSS_SALES when productTypes filter does not match', () => {
+        it('should return 0 for PCT_GROSS_SALES when productTypes filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
                 percentRate: 3,
                 filters: { productTypes: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Electronics'] } },
             });
             const context = createContext({
                 grossSalePrice: 150,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Clothing' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Clothing' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PCT_GROSS_SALES when productTypes filter matches', () => {
+        it('should apply PCT_GROSS_SALES when productTypes filter matches', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
                 percentRate: 3,
                 filters: { productTypes: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Electronics'] } },
             });
             const context = createContext({
                 grossSalePrice: 150,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Electronics' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Electronics' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBeCloseTo(4.5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
         });
-        (0, vitest_1.it)('should return 0 for PCT_NET_SALES when productCategories filter does not match', () => {
+        it('should return 0 for PCT_NET_SALES when productCategories filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, {
                 percentRate: 5,
                 filters: { productCategories: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Home > Kitchen'] } },
             });
             const context = createContext({
                 netSalePrice: 80,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Sports' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Sports' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_TOTAL_SALES when products filter does not match', () => {
+        it('should return 0 for PCT_TOTAL_SALES when products filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, {
                 percentRate: 2,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
@@ -1118,24 +987,20 @@ const createConfigs = (overrides = {}) => ({
                 totalPrice: 200,
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_COGS when product filter does not match', () => {
+        it('should return 0 for PCT_COGS when product filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, {
                 percentRate: 10,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Apple'] } },
             });
             const context = createContext({
                 totalProductCost: 50,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Samsung' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Samsung' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_SHIPPING when product filter does not match', () => {
+        it('should return 0 for PCT_SHIPPING when product filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, {
                 percentRate: 5,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P500'] } },
@@ -1144,24 +1009,20 @@ const createConfigs = (overrides = {}) => ({
                 totalShipping: 20,
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PER_REFUND_ORDER when product filter does not match', () => {
+        it('should return 0 for PER_REFUND_ORDER when product filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
                 hasRefund: true,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_REFUND_ORDER when product filter matches and hasRefund', () => {
+        it('should apply PER_REFUND_ORDER when product filter matches and hasRefund', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
@@ -1170,10 +1031,9 @@ const createConfigs = (overrides = {}) => ({
                 hasRefund: true,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should only apply PER_LINE_ITEM cost to line items matching product filter', () => {
+        it('should only apply PER_LINE_ITEM cost to line items matching product filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 2,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
@@ -1184,41 +1044,28 @@ const createConfigs = (overrides = {}) => ({
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(6);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PER_LINE_ITEM when no line items match product filter', () => {
+        it('should return 0 for PER_LINE_ITEM when no line items match product filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 2,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should only apply PER_REFUND_LINE_ITEM cost to refunded line items matching product filter', () => {
+        it('should only apply PER_REFUND_LINE_ITEM cost to refunded line items matching product filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
                 flatAmount: 3,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P1'] } },
@@ -1230,24 +1077,16 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 hasRefund: true,
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        refundedQuantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [] },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        refundedQuantity: 1,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [] },
-                    }),
+                    createLineItem({ lineItemId: '1', refundedQuantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [] } }),
+                    createLineItem({ lineItemId: '2', refundedQuantity: 1, filterContext: { productId: 'P2', variantId: 'V2', tags: [] } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(6);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should check both order and product filters for PER_ORDER (both must pass)', () => {
+        it('should check both order and product filters for PER_ORDER (both must pass)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: {
@@ -1259,22 +1098,19 @@ const createConfigs = (overrides = {}) => ({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextPass, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextPass, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
             const contextProductFail = createContext({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextProductFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextProductFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
             const contextOrderFail = createContext({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextOrderFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, contextOrderFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for BY_ORDER_WEIGHT when order-level country filter does not match', () => {
+        it('should return 0 for BY_ORDER_WEIGHT when order-level country filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 flatAmount: 0.01,
                 filters: { countries: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['US'] } },
@@ -1283,10 +1119,9 @@ const createConfigs = (overrides = {}) => ({
                 totalWeight: 500,
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for BY_LINE_ITEM_QUANTITY when orderTags filter does not match', () => {
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when orderTags filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 flatAmount: 0.5,
                 filters: { orderTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['wholesale'] } },
@@ -1295,10 +1130,9 @@ const createConfigs = (overrides = {}) => ({
                 lineItems: [createLineItem({ quantity: 10 })],
                 orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_GROSS_SALES when orderPaymentGateways filter does not match', () => {
+        it('should return 0 for PCT_GROSS_SALES when orderPaymentGateways filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
                 percentRate: 3,
                 filters: { orderPaymentGateways: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['stripe'] } },
@@ -1307,10 +1141,9 @@ const createConfigs = (overrides = {}) => ({
                 grossSalePrice: 150,
                 orderFilterContext: { tags: [], paymentGateways: ['paypal'], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PCT_GROSS_SALES when orderPaymentGateways filter matches', () => {
+        it('should apply PCT_GROSS_SALES when orderPaymentGateways filter matches', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
                 percentRate: 3,
                 filters: { orderPaymentGateways: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['stripe'] } },
@@ -1319,10 +1152,9 @@ const createConfigs = (overrides = {}) => ({
                 grossSalePrice: 150,
                 orderFilterContext: { tags: [], paymentGateways: ['stripe'], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBeCloseTo(4.5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
         });
-        (0, vitest_1.it)('should return 0 for PER_LINE_ITEM when orderShippingTitles filter does not match', () => {
+        it('should return 0 for PER_LINE_ITEM when orderShippingTitles filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 2,
                 filters: { orderShippingTitles: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Express'] } },
@@ -1331,10 +1163,9 @@ const createConfigs = (overrides = {}) => ({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: ['Standard'] },
                 lineItems: [createLineItem({ quantity: 3 })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PCT_COGS when orderSourceNames filter does not match', () => {
+        it('should return 0 for PCT_COGS when orderSourceNames filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, {
                 percentRate: 10,
                 filters: { orderSourceNames: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['web'] } },
@@ -1343,52 +1174,41 @@ const createConfigs = (overrides = {}) => ({
                 totalProductCost: 50,
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], sourceName: 'pos' },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when EXCLUDE product filter does not match any line item vendor', () => {
+        it('should apply PER_ORDER when EXCLUDE product filter does not match any line item vendor', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when EXCLUDE product filter matches all line items', () => {
+        it('should return 0 for PER_ORDER when EXCLUDE product filter matches all line items', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
                 ],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when product filter mode is ALL', () => {
+        it('should apply PER_ORDER when product filter mode is ALL', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.ALL, values: [] } },
             });
             const context = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'anything' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'anything' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when multiple product filters set and no single line item satisfies all', () => {
+        it('should return 0 for PER_ORDER when multiple product filters set and no single line item satisfies all', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: {
@@ -1398,23 +1218,17 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas', productType: 'Shoes' } }),
                 ],
             });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
                 '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
             };
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when one line item satisfies all product filters', () => {
+        it('should apply PER_ORDER when one line item satisfies all product filters', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: {
@@ -1424,23 +1238,17 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '2', filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Shoes' } }),
                 ],
             });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
                 '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
             };
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should match PER_ORDER with productId_variantId composite filter', () => {
+        it('should match PER_ORDER with productId_variantId composite filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P100_V200'] } },
@@ -1448,15 +1256,13 @@ const createConfigs = (overrides = {}) => ({
             const matchContext = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V200', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
             const noMatchContext = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V999', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should convert currency AND evaluate product filters for PER_ORDER', () => {
+        it('should convert currency AND evaluate product filters for PER_ORDER', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 10,
                 currency: 'EUR',
@@ -1466,16 +1272,13 @@ const createConfigs = (overrides = {}) => ({
             const matchContext = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(11);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(11);
             const noMatchContext = createContext({
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', rates)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should evaluate weight tiers AND product filters for BY_ORDER_WEIGHT', () => {
+        it('should evaluate weight tiers AND product filters for BY_ORDER_WEIGHT', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
                 weightUnit: at_tracking_event_types_1.WEIGHT_UNIT.KILOGRAMS,
                 weightIntervals: [
@@ -1486,22 +1289,16 @@ const createConfigs = (overrides = {}) => ({
             });
             const matchContext = createContext({
                 totalWeight: 2000,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Heavy Items' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Heavy Items' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(3);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
             const noMatchContext = createContext({
                 totalWeight: 2000,
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Light Items' } }),
-                ],
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Light Items' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should evaluate quantity tiers AND product filters for BY_LINE_ITEM_QUANTITY', () => {
+        it('should evaluate quantity tiers AND product filters for BY_LINE_ITEM_QUANTITY', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
                 quantityIntervals: [
                     { quantityMin: 1, quantityMax: 10, flatAmount: 2 },
@@ -1510,21 +1307,15 @@ const createConfigs = (overrides = {}) => ({
                 filters: { productTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['bulk'] } },
             });
             const matchContext = createContext({
-                lineItems: [
-                    createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['bulk'] } }),
-                ],
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['bulk'] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(2);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(2);
             const noMatchContext = createContext({
-                lineItems: [
-                    createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['single'] } }),
-                ],
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['single'] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap)
-                .lineItemLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_LINE_ITEM to line items NOT matching EXCLUDE product filter', () => {
+        it('should apply PER_LINE_ITEM to line items NOT matching EXCLUDE product filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 2,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
@@ -1535,24 +1326,16 @@ const createConfigs = (overrides = {}) => ({
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(4);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(0);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(4);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(4);
         });
-        (0, vitest_1.it)('should apply PER_LINE_ITEM selectively when multiple product filters used', () => {
+        it('should apply PER_LINE_ITEM selectively when multiple product filters used', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 1,
                 filters: {
@@ -1567,30 +1350,18 @@ const createConfigs = (overrides = {}) => ({
             };
             const context = createContext({
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Shoes' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 3,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Hats' },
-                    }),
-                    createLineItem({
-                        lineItemId: '3',
-                        quantity: 1,
-                        filterContext: { productId: 'P3', variantId: 'V3', tags: [], vendor: 'Adidas', productType: 'Shoes' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike', productType: 'Shoes' } }),
+                    createLineItem({ lineItemId: '2', quantity: 3, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Nike', productType: 'Hats' } }),
+                    createLineItem({ lineItemId: '3', quantity: 1, filterContext: { productId: 'P3', variantId: 'V3', tags: [], vendor: 'Adidas', productType: 'Shoes' } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(2);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(2);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
-            (0, vitest_1.expect)(liCosts['3'].totalLineItemOtherCost).toBe(0);
+            expect(result.lineItemLevel).toBe(2);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(2);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['3'].totalLineItemOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should return 0 for PER_REFUND_ORDER when product filter matches but hasRefund is false', () => {
+        it('should return 0 for PER_REFUND_ORDER when product filter matches but hasRefund is false', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
@@ -1599,10 +1370,9 @@ const createConfigs = (overrides = {}) => ({
                 hasRefund: false,
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_REFUND_LINE_ITEM only to refunded line items NOT matching EXCLUDE filter', () => {
+        it('should apply PER_REFUND_LINE_ITEM only to refunded line items NOT matching EXCLUDE filter', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
                 flatAmount: 3,
                 filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['P1'] } },
@@ -1614,24 +1384,16 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 hasRefund: true,
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        refundedQuantity: 2,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [] },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        refundedQuantity: 1,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [] },
-                    }),
+                    createLineItem({ lineItemId: '1', refundedQuantity: 2, filterContext: { productId: 'P1', variantId: 'V1', tags: [] } }),
+                    createLineItem({ lineItemId: '2', refundedQuantity: 1, filterContext: { productId: 'P2', variantId: 'V2', tags: [] } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(3);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(0);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(3);
+            expect(result.lineItemLevel).toBe(3);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(3);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when EXCLUDE order filter does not match', () => {
+        it('should apply PER_ORDER when EXCLUDE order filter does not match', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { orderTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['test'] } },
@@ -1639,10 +1401,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 orderFilterContext: { tags: ['vip'], paymentGateways: [], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when EXCLUDE order filter matches', () => {
+        it('should return 0 for PER_ORDER when EXCLUDE order filter matches', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { orderTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['test'] } },
@@ -1650,10 +1411,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 orderFilterContext: { tags: ['test'], paymentGateways: [], shippingTitles: [] },
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should handle undefined filter context fields (missing vendor, productType, category)', () => {
+        it('should handle undefined filter context fields (missing vendor, productType, category)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
@@ -1661,10 +1421,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should handle EXCLUDE filter with undefined filter context field (undefined treated as not matching)', () => {
+        it('should handle EXCLUDE filter with undefined filter context field (undefined treated as not matching)', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
@@ -1672,10 +1431,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should return 0 for PER_ORDER when INCLUDE productTags filter and line item has empty tags', () => {
+        it('should return 0 for PER_ORDER when INCLUDE productTags filter and line item has empty tags', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['sale'] } },
@@ -1683,10 +1441,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(0);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
         });
-        (0, vitest_1.it)('should apply PER_ORDER when EXCLUDE productTags filter and line item has empty tags', () => {
+        it('should apply PER_ORDER when EXCLUDE productTags filter and line item has empty tags', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                 flatAmount: 5,
                 filters: { productTags: { mode: at_tracking_event_types_1.COST_FILTER_MODE.EXCLUDE, values: ['sale'] } },
@@ -1694,10 +1451,9 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
             });
-            (0, vitest_1.expect)(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap)
-                .orderLevel).toBe(5);
+            expect(cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
         });
-        (0, vitest_1.it)('should apply PER_LINE_ITEM only to line items matching product filter when order filter also passes', () => {
+        it('should apply PER_LINE_ITEM only to line items matching product filter when order filter also passes', () => {
             const entry = createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
                 flatAmount: 2,
                 filters: {
@@ -1712,33 +1468,25 @@ const createConfigs = (overrides = {}) => ({
             const context = createContext({
                 orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
                 lineItems: [
-                    createLineItem({
-                        lineItemId: '1',
-                        quantity: 3,
-                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
-                    }),
-                    createLineItem({
-                        lineItemId: '2',
-                        quantity: 2,
-                        filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' },
-                    }),
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                    createLineItem({ lineItemId: '2', quantity: 2, filterContext: { productId: 'P2', variantId: 'V2', tags: [], vendor: 'Adidas' } }),
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(6);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
         });
     });
-    (0, vitest_1.describe)('calculateOtherCost', () => {
-        (0, vitest_1.it)('should return 0 when no order config', () => {
+    describe('calculateOtherCost', () => {
+        it('should return 0 when no order config', () => {
             const configs = createConfigs();
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, createContext(), {}, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBe(0);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.total).toBe(0);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should sum multiple entries and separate order-level costs', () => {
+        it('should sum multiple entries and separate order-level costs', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -1747,15 +1495,13 @@ const createConfigs = (overrides = {}) => ({
                     ],
                 },
             });
-            const liCosts = {
-                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
-            };
+            const liCosts = { '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, createContext(), liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBe(5);
-            (0, vitest_1.expect)(result.orderLevel).toBe(5);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(0);
+            expect(result.total).toBe(5);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
         });
-        (0, vitest_1.it)('should accumulate lineItemCosts from multiple PER_LINE_ITEM entries', () => {
+        it('should accumulate lineItemCosts from multiple PER_LINE_ITEM entries', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -1771,12 +1517,12 @@ const createConfigs = (overrides = {}) => ({
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
             };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBe(10);
-            (0, vitest_1.expect)(result.orderLevel).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(10);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(10);
+            expect(result.total).toBe(10);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(10);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(10);
         });
-        (0, vitest_1.it)('should skip entries outside date range', () => {
+        it('should skip entries outside date range', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -1786,29 +1532,25 @@ const createConfigs = (overrides = {}) => ({
             });
             const liCosts = {};
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, createContext(), liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBe(0);
+            expect(result.total).toBe(0);
         });
-        (0, vitest_1.it)('should only sum entries whose filters pass (mixed filter results)', () => {
+        it('should only sum entries whose filters pass (mixed filter results)', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e1',
-                            flatAmount: 3,
+                            id: 'e1', flatAmount: 3,
                             filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
                         }),
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e2',
-                            flatAmount: 7,
+                            id: 'e2', flatAmount: 7,
                             filters: { products: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
                         }),
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
-                            id: 'e3',
-                            percentRate: 2,
+                            id: 'e3', percentRate: 2,
                         }),
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e4',
-                            flatAmount: 10,
+                            id: 'e4', flatAmount: 10,
                             filters: { countries: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['CA'] } },
                         }),
                     ],
@@ -1816,24 +1558,15 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({
                 grossSalePrice: 120,
-                orderFilterContext: {
-                    tags: [],
-                    paymentGateways: ['stripe'],
-                    shippingTitles: ['Standard'],
-                    shipCountryCode: 'US',
-                },
-                lineItems: [
-                    createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [], vendor: 'Nike' } }),
-                ],
+                orderFilterContext: { tags: [], paymentGateways: ['stripe'], shippingTitles: ['Standard'], shipCountryCode: 'US' },
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [], vendor: 'Nike' } })],
             });
-            const liCosts = {
-                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
-            };
+            const liCosts = { '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 } };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBeCloseTo(5.4);
-            (0, vitest_1.expect)(result.orderLevel).toBeCloseTo(5.4);
+            expect(result.total).toBeCloseTo(5.4);
+            expect(result.orderLevel).toBeCloseTo(5.4);
         });
-        (0, vitest_1.it)('should sum PER_ORDER and PER_LINE_ITEM entries together and separate by level', () => {
+        it('should sum PER_ORDER and PER_LINE_ITEM entries together and separate by level', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -1843,66 +1576,65 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const liCosts = {
                 '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
                 '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
             };
             const result = cost_calculator_service_1.CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.total).toBe(15);
-            (0, vitest_1.expect)(result.orderLevel).toBe(5);
-            (0, vitest_1.expect)(result.lineItemLevel).toBe(10);
-            (0, vitest_1.expect)(liCosts['1'].totalLineItemOtherCost).toBe(6);
-            (0, vitest_1.expect)(liCosts['2'].totalLineItemOtherCost).toBe(4);
+            expect(result.total).toBe(15);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(10);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(4);
         });
     });
-    (0, vitest_1.describe)('calculateLineItemHandlingCosts', () => {
-        (0, vitest_1.it)('should omit line items with no handling fee override', () => {
+    describe('calculateLineItemHandlingCosts', () => {
+        it('should omit line items with no handling fee override', () => {
             const result = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([createLineItem()]);
-            (0, vitest_1.expect)(result['1']).toBeUndefined();
-            (0, vitest_1.expect)(Object.keys(result)).toHaveLength(0);
+            expect(result['1']).toBeUndefined();
+            expect(Object.keys(result)).toHaveLength(0);
         });
-        (0, vitest_1.it)('should include an explicit 0 override as 0, distinct from having no override', () => {
-            const result = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([
-                createLineItem({ variantHandlingFee: 0, quantity: 3 }),
-            ]);
-            (0, vitest_1.expect)(result['1']).toBe(0);
+        it('should include an explicit 0 override as 0, distinct from having no override', () => {
+            const result = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([createLineItem({ variantHandlingFee: 0, quantity: 3 })]);
+            expect(result['1']).toBe(0);
         });
-        (0, vitest_1.it)('should multiply handling fee by quantity', () => {
+        it('should multiply handling fee by quantity', () => {
             const result = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([
                 createLineItem({ lineItemId: '1', quantity: 3, variantHandlingFee: 1.5 }),
             ]);
-            (0, vitest_1.expect)(result['1']).toBe(4.5);
+            expect(result['1']).toBe(4.5);
         });
-        (0, vitest_1.it)('should handle multiple line items', () => {
+        it('should handle multiple line items', () => {
             const result = cost_calculator_service_1.CostCalculatorService.calculateLineItemHandlingCosts([
                 createLineItem({ lineItemId: '1', quantity: 2, variantHandlingFee: 1 }),
                 createLineItem({ lineItemId: '2', quantity: 1, variantHandlingFee: 3 }),
             ]);
-            (0, vitest_1.expect)(result['1']).toBe(2);
-            (0, vitest_1.expect)(result['2']).toBe(3);
+            expect(result['1']).toBe(2);
+            expect(result['2']).toBe(3);
         });
     });
-    (0, vitest_1.describe)('calculateOrderCosts', () => {
-        (0, vitest_1.it)('should return default result when configs is null', () => {
+    describe('calculateOrderCosts', () => {
+        it('should return default result when configs is null', () => {
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.totalHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(0);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevelOtherCost).toBe(0);
-            (0, vitest_1.expect)(result.totalGatewayCost).toBe(0);
-            (0, vitest_1.expect)(result.totalShippingCost).toBe(0);
-        });
-        (0, vitest_1.it)('should calculate all cost types together', () => {
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(0);
+            expect(result.totalHandlingCost).toBe(0);
+            expect(result.totalOtherCost).toBe(0);
+            expect(result.orderLevelOtherCost).toBe(0);
+            expect(result.lineItemLevelOtherCost).toBe(0);
+            expect(result.totalGatewayCost).toBe(0);
+            expect(result.totalShippingCost).toBe(0);
+        });
+        it('should calculate all cost types together', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 2 },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
                 order: {
@@ -1914,44 +1646,40 @@ const createConfigs = (overrides = {}) => ({
                 lineItems: [createLineItem({ variantHandlingFee: 0.5, quantity: 2 })],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(1);
-            (0, vitest_1.expect)(result.totalHandlingCost).toBe(1);
-            (0, vitest_1.expect)(result.totalGatewayCost).toBeCloseTo(3.2);
-            (0, vitest_1.expect)(result.totalShippingCost).toBe(10);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(1);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(1);
-            (0, vitest_1.expect)(result.lineItemLevelOtherCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemCosts['1'].totalLineItemHandlingCost).toBe(1);
-        });
-        (0, vitest_1.it)('should handle partial configs', () => {
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(1);
+            expect(result.totalHandlingCost).toBe(1);
+            expect(result.totalGatewayCost).toBeCloseTo(3.20);
+            expect(result.totalShippingCost).toBe(10);
+            expect(result.totalOtherCost).toBe(1);
+            expect(result.orderLevelOtherCost).toBe(1);
+            expect(result.lineItemLevelOtherCost).toBe(0);
+            expect(result.lineItemCosts['1'].totalLineItemHandlingCost).toBe(1);
+        });
+        it('should handle partial configs', () => {
             const configs = createConfigs({
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.totalHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.totalGatewayCost).toBe(0.3);
-            (0, vitest_1.expect)(result.totalShippingCost).toBe(0);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(0);
-        });
-        (0, vitest_1.it)('should respect product filters in calculateOrderCosts integration', () => {
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(0);
+            expect(result.totalHandlingCost).toBe(0);
+            expect(result.totalGatewayCost).toBe(0.30);
+            expect(result.totalShippingCost).toBe(0);
+            expect(result.totalOtherCost).toBe(0);
+        });
+        it('should respect product filters in calculateOrderCosts integration', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e1',
-                            flatAmount: 5,
+                            id: 'e1', flatAmount: 5,
                             filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
                         }),
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'e2',
-                            flatAmount: 10,
+                            id: 'e2', flatAmount: 10,
                             filters: { productVendors: { mode: at_tracking_event_types_1.COST_FILTER_MODE.INCLUDE, values: ['Puma'] } },
                         }),
                     ],
@@ -1967,16 +1695,14 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(5);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(5);
+            expect(result.totalOtherCost).toBe(5);
+            expect(result.orderLevelOtherCost).toBe(5);
         });
-        (0, vitest_1.it)('should accumulate all cost types with multiple line items and separate by level', () => {
+        it('should accumulate all cost types with multiple line items and separate by level', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 1, currency: 'USD' },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 5, currency: 'USD' },
                 order: {
@@ -1995,32 +1721,34 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevelHandlingCost).toBe(0);
-            (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(3.5);
-            (0, vitest_1.expect)(result.totalHandlingCost).toBe(3.5);
-            (0, vitest_1.expect)(result.totalGatewayCost).toBeCloseTo(6.1);
-            (0, vitest_1.expect)(result.totalShippingCost).toBe(5);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(12);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(7);
-            (0, vitest_1.expect)(result.lineItemLevelOtherCost).toBe(5);
-            (0, vitest_1.expect)(result.lineItemCosts['1'].totalLineItemOtherCost).toBe(3);
-            (0, vitest_1.expect)(result.lineItemCosts['2'].totalLineItemOtherCost).toBe(2);
-            (0, vitest_1.expect)(result.lineItemCosts['1'].totalLineItemHandlingCost).toBe(1.5);
-            (0, vitest_1.expect)(result.lineItemCosts['2'].totalLineItemHandlingCost).toBe(2);
-        });
-        (0, vitest_1.it)('should maintain decimal precision with Big.js', () => {
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(3.5);
+            expect(result.totalHandlingCost).toBe(3.5);
+            expect(result.totalGatewayCost).toBeCloseTo(6.10);
+            expect(result.totalShippingCost).toBe(5);
+            expect(result.totalOtherCost).toBe(12);
+            expect(result.orderLevelOtherCost).toBe(7);
+            expect(result.lineItemLevelOtherCost).toBe(5);
+            expect(result.lineItemCosts['1'].totalLineItemOtherCost).toBe(3);
+            expect(result.lineItemCosts['2'].totalLineItemOtherCost).toBe(2);
+            expect(result.lineItemCosts['1'].totalLineItemHandlingCost).toBe(1.5);
+            expect(result.lineItemCosts['2'].totalLineItemHandlingCost).toBe(2);
+        });
+        it('should maintain decimal precision with Big.js', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 33.33 })],
+                    entries: [
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 33.33 }),
+                    ],
                 },
             });
             const context = createContext({ totalPrice: 99.99 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.totalOtherCost).toBeCloseTo(33.326667, 4);
+            expect(result.totalOtherCost).toBeCloseTo(33.326667, 4);
         });
     });
-    (0, vitest_1.describe)('calculateOtherCost - category routing', () => {
-        (0, vitest_1.it)('should route COGS category costs to totalOtherCogs', () => {
+    describe('calculateOtherCost - category routing', () => {
+        it('should route COGS category costs to totalOtherCogs', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2030,15 +1758,15 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(15);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(0);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(0);
-            (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(0);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(0);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(0);
-        });
-        (0, vitest_1.it)('should route FULFILLMENT category costs to otherFulfillmentCost', () => {
+            expect(result.categoryCosts.totalOtherCogs).toBe(15);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+            expect(result.categoryCosts.otherTransactionCost).toBe(0);
+            expect(result.categoryCosts.marketingCost).toBe(0);
+            expect(result.categoryCosts.agencyFeesCost).toBe(0);
+            expect(result.categoryCosts.opexCost).toBe(0);
+            expect(result.categoryCosts.totalOtherCost).toBe(0);
+        });
+        it('should route FULFILLMENT category costs to otherFulfillmentCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2047,10 +1775,10 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(8);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(0);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(8);
+            expect(result.categoryCosts.totalOtherCogs).toBe(0);
         });
-        (0, vitest_1.it)('should route TRANSACTION category costs to otherTransactionCost', () => {
+        it('should route TRANSACTION category costs to otherTransactionCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2060,9 +1788,9 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ totalPrice: 100 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(3);
+            expect(result.categoryCosts.otherTransactionCost).toBe(3);
         });
-        (0, vitest_1.it)('should route MARKETING category costs to marketingCost', () => {
+        it('should route MARKETING category costs to marketingCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2071,43 +1799,43 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(25);
+            expect(result.categoryCosts.marketingCost).toBe(25);
         });
-        (0, vitest_1.it)('should route AGENCY_FEES category costs to agencyFeesCost', () => {
+        it('should route AGENCY_FEES category costs to agencyFeesCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
-                            id: 'agency1',
-                            percentRate: 15,
-                            category: 'agency_fees',
-                        }),
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { id: 'agency1', percentRate: 15, category: 'agency_fees' }),
                     ],
                 },
             });
             const context = createContext({ grossSalePrice: 200 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(30);
+            expect(result.categoryCosts.agencyFeesCost).toBe(30);
         });
-        (0, vitest_1.it)('should route OPEX category costs to opexCost', () => {
+        it('should route OPEX category costs to opexCost', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 12, category: 'opex' })],
+                    entries: [
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 12, category: 'opex' }),
+                    ],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(12);
+            expect(result.categoryCosts.opexCost).toBe(12);
         });
-        (0, vitest_1.it)('should route OTHER category costs to totalOtherCost', () => {
+        it('should route OTHER category costs to totalOtherCost', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 7, category: 'other' })],
+                    entries: [
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 7, category: 'other' }),
+                    ],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(7);
+            expect(result.categoryCosts.totalOtherCost).toBe(7);
         });
-        (0, vitest_1.it)('should route legacy payment_fees to TRANSACTION (otherTransactionCost)', () => {
+        it('should route legacy payment_fees to TRANSACTION (otherTransactionCost)', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2116,10 +1844,10 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(2.5);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(0);
+            expect(result.categoryCosts.otherTransactionCost).toBe(2.5);
+            expect(result.categoryCosts.totalOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should route legacy packaging to FULFILLMENT (otherFulfillmentCost)', () => {
+        it('should route legacy packaging to FULFILLMENT (otherFulfillmentCost)', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2128,25 +1856,21 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(1.75);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(0);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(1.75);
+            expect(result.categoryCosts.totalOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should route unknown category to totalOtherCost', () => {
+        it('should route unknown category to totalOtherCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                            id: 'unknown1',
-                            flatAmount: 3,
-                            category: 'unknown_category_xyz',
-                        }),
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'unknown1', flatAmount: 3, category: 'unknown_category_xyz' }),
                     ],
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(3);
+            expect(result.categoryCosts.totalOtherCost).toBe(3);
         });
-        (0, vitest_1.it)('should route undefined/null category to totalOtherCost', () => {
+        it('should route undefined/null category to totalOtherCost', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2156,9 +1880,9 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(10);
+            expect(result.categoryCosts.totalOtherCost).toBe(10);
         });
-        (0, vitest_1.it)('should accumulate costs across multiple entries of the same category', () => {
+        it('should accumulate costs across multiple entries of the same category', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2169,12 +1893,15 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 2 }), createLineItem({ lineItemId: '2', quantity: 3 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 2 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(18);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(18);
         });
-        (0, vitest_1.it)('should route costs to multiple categories correctly', () => {
+        it('should route costs to multiple categories correctly', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2190,62 +1917,59 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ totalPrice: 100 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(5);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(2);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(15);
-            (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(8);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(20);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(3);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(3);
-        });
-        (0, vitest_1.it)('should handle line-item level costs in category routing', () => {
+            expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
+            expect(result.categoryCosts.otherTransactionCost).toBe(2);
+            expect(result.categoryCosts.marketingCost).toBe(15);
+            expect(result.categoryCosts.agencyFeesCost).toBe(8);
+            expect(result.categoryCosts.opexCost).toBe(20);
+            expect(result.categoryCosts.totalOtherCost).toBe(3);
+            expect(result.totalOtherCost).toBe(3);
+        });
+        it('should handle line-item level costs in category routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
                         createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'cogs_li', flatAmount: 2, category: 'cogs' }),
-                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
-                            id: 'ful_li',
-                            flatAmount: 1.5,
-                            category: 'fulfillment',
-                        }),
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'ful_li', flatAmount: 1.5, category: 'fulfillment' }),
                     ],
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(7.5);
+            expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(7.5);
         });
-        (0, vitest_1.it)('should handle PCT_COGS entry type with category routing', () => {
+        it('should handle PCT_COGS entry type with category routing', () => {
             const configs = createConfigs({
                 order: {
-                    entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { id: 'pct_cogs', percentRate: 10, category: 'cogs' })],
+                    entries: [
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { id: 'pct_cogs', percentRate: 10, category: 'cogs' }),
+                    ],
                 },
             });
             const context = createContext({ totalProductCost: 50 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(5);
+            expect(result.categoryCosts.totalOtherCogs).toBe(5);
         });
-        (0, vitest_1.it)('should handle PCT_SHIPPING entry type routed to fulfillment', () => {
+        it('should handle PCT_SHIPPING entry type routed to fulfillment', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
-                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, {
-                            id: 'pct_ship',
-                            percentRate: 20,
-                            category: 'fulfillment',
-                        }),
+                        createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { id: 'pct_ship', percentRate: 20, category: 'fulfillment' }),
                     ],
                 },
             });
             const context = createContext({ totalShipping: 25 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(5);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
         });
-        (0, vitest_1.it)('should handle refund costs with category routing', () => {
+        it('should handle refund costs with category routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2255,9 +1979,9 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ hasRefund: true });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(15);
+            expect(result.categoryCosts.opexCost).toBe(15);
         });
-        (0, vitest_1.it)('should not apply refund costs when hasRefund is false', () => {
+        it('should not apply refund costs when hasRefund is false', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2267,9 +1991,9 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ hasRefund: false });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(0);
+            expect(result.categoryCosts.opexCost).toBe(0);
         });
-        (0, vitest_1.it)('should respect date ranges in category cost routing', () => {
+        it('should respect date ranges in category cost routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2292,11 +2016,11 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(10);
+            expect(result.categoryCosts.marketingCost).toBe(10);
         });
-        (0, vitest_1.it)('should return default categoryCosts when configs is null', () => {
+        it('should return default categoryCosts when configs is null', () => {
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts).toEqual({
+            expect(result.categoryCosts).toEqual({
                 totalOtherCogs: 0,
                 otherFulfillmentCost: 0,
                 otherTransactionCost: 0,
@@ -2306,10 +2030,10 @@ const createConfigs = (overrides = {}) => ({
                 totalOtherCost: 0,
             });
         });
-        (0, vitest_1.it)('should return default categoryCosts when order config is null', () => {
+        it('should return default categoryCosts when order config is null', () => {
             const configs = createConfigs({ order: null });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts).toEqual({
+            expect(result.categoryCosts).toEqual({
                 totalOtherCogs: 0,
                 otherFulfillmentCost: 0,
                 otherTransactionCost: 0,
@@ -2319,7 +2043,7 @@ const createConfigs = (overrides = {}) => ({
                 totalOtherCost: 0,
             });
         });
-        (0, vitest_1.it)('should handle mixed legacy and new categories', () => {
+        it('should handle mixed legacy and new categories', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2331,10 +2055,10 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(8);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(6);
+            expect(result.categoryCosts.otherTransactionCost).toBe(8);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(6);
         });
-        (0, vitest_1.it)('should handle weight-based costs with category routing', () => {
+        it('should handle weight-based costs with category routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2349,9 +2073,9 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ totalWeight: 1000 });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(10);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(10);
         });
-        (0, vitest_1.it)('should handle quantity-based costs with category routing', () => {
+        it('should handle quantity-based costs with category routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2365,9 +2089,9 @@ const createConfigs = (overrides = {}) => ({
             });
             const context = createContext({ lineItems: [createLineItem({ quantity: 10 })] });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(5);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
         });
-        (0, vitest_1.it)('should handle BY_ORDER_QUANTITY costs with category routing', () => {
+        it('should handle BY_ORDER_QUANTITY costs with category routing', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2383,15 +2107,18 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 4 }), createLineItem({ lineItemId: '2', quantity: 3 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 4 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
                 totalQuantity: 7,
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(5);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(5);
-            (0, vitest_1.expect)(result.lineItemLevelOtherCost).toBe(0);
+            expect(result.categoryCosts.totalOtherCogs).toBe(5);
+            expect(result.orderLevelOtherCost).toBe(5);
+            expect(result.lineItemLevelOtherCost).toBe(0);
         });
-        (0, vitest_1.it)('should continue processing other entries when one entry fails', () => {
+        it('should continue processing other entries when one entry fails', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2407,18 +2134,16 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(5);
+            expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            expect(result.categoryCosts.marketingCost).toBe(5);
         });
     });
-    (0, vitest_1.describe)('calculateOrderCosts - category costs integration', () => {
-        (0, vitest_1.it)('should calculate all cost types with category routing in full integration', () => {
+    describe('calculateOrderCosts - category costs integration', () => {
+        it('should calculate all cost types with category routing in full integration', () => {
             const configs = createConfigs({
                 globalProductOverride: { globalHandlingFee: 1.5, currency: 'USD' },
                 gateway: {
-                    entries: [
-                        { gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' },
-                    ],
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
                 },
                 shipping: { method: at_tracking_event_types_1.SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 7, currency: 'USD' },
                 order: {
@@ -2441,20 +2166,20 @@ const createConfigs = (overrides = {}) => ({
                 ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(3.25);
-            (0, vitest_1.expect)(result.totalHandlingCost).toBe(3.25);
-            (0, vitest_1.expect)(result.totalGatewayCost).toBeCloseTo(6.1);
-            (0, vitest_1.expect)(result.totalShippingCost).toBe(7);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(5);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(3);
-            (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(2);
-            (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(10);
-            (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(10);
-            (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(8);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(4);
-            (0, vitest_1.expect)(result.totalOtherCost).toBe(4);
-        });
-        (0, vitest_1.it)('should properly separate order-level and line-item-level costs with categories', () => {
+            expect(result.lineItemLevelHandlingCost).toBe(3.25);
+            expect(result.totalHandlingCost).toBe(3.25);
+            expect(result.totalGatewayCost).toBeCloseTo(6.10);
+            expect(result.totalShippingCost).toBe(7);
+            expect(result.categoryCosts.totalOtherCogs).toBe(5);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(3);
+            expect(result.categoryCosts.otherTransactionCost).toBe(2);
+            expect(result.categoryCosts.marketingCost).toBe(10);
+            expect(result.categoryCosts.agencyFeesCost).toBe(10);
+            expect(result.categoryCosts.opexCost).toBe(8);
+            expect(result.categoryCosts.totalOtherCost).toBe(4);
+            expect(result.totalOtherCost).toBe(4);
+        });
+        it('should properly separate order-level and line-item-level costs with categories', () => {
             const configs = createConfigs({
                 order: {
                     entries: [
@@ -2466,35 +2191,38 @@ const createConfigs = (overrides = {}) => ({
                 },
             });
             const context = createContext({
-                lineItems: [createLineItem({ lineItemId: '1', quantity: 3 }), createLineItem({ lineItemId: '2', quantity: 2 })],
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
             });
             const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-            (0, vitest_1.expect)(result.orderLevelOtherCost).toBe(15);
-            (0, vitest_1.expect)(result.lineItemLevelOtherCost).toBe(15);
-            (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(20);
-            (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(10);
-            (0, vitest_1.expect)(result.lineItemCosts['1'].totalLineItemOtherCost).toBe(9);
-            (0, vitest_1.expect)(result.lineItemCosts['2'].totalLineItemOtherCost).toBe(6);
+            expect(result.orderLevelOtherCost).toBe(15);
+            expect(result.lineItemLevelOtherCost).toBe(15);
+            expect(result.categoryCosts.totalOtherCogs).toBe(20);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(10);
+            expect(result.lineItemCosts['1'].totalLineItemOtherCost).toBe(9);
+            expect(result.lineItemCosts['2'].totalLineItemOtherCost).toBe(6);
         });
     });
-    (0, vitest_1.describe)('defensive coding - malformed input handling', () => {
-        (0, vitest_1.describe)('empty and missing entries', () => {
-            (0, vitest_1.it)('should handle empty entries array', () => {
+    describe('defensive coding - malformed input handling', () => {
+        describe('empty and missing entries', () => {
+            it('should handle empty entries array', () => {
                 const configs = createConfigs({
                     order: { entries: [] },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(0);
-                (0, vitest_1.expect)(result.totalOtherCost).toBe(0);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.totalOtherCost).toBe(0);
+                expect(result.totalOtherCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle undefined entries', () => {
+            it('should handle undefined entries', () => {
                 const configs = createConfigs({
                     order: { entries: undefined },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts).toEqual({
+                expect(result.categoryCosts).toEqual({
                     totalOtherCogs: 0,
                     otherFulfillmentCost: 0,
                     otherTransactionCost: 0,
@@ -2504,12 +2232,12 @@ const createConfigs = (overrides = {}) => ({
                     totalOtherCost: 0,
                 });
             });
-            (0, vitest_1.it)('should handle null entries', () => {
+            it('should handle null entries', () => {
                 const configs = createConfigs({
                     order: { entries: null },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts).toEqual({
+                expect(result.categoryCosts).toEqual({
                     totalOtherCogs: 0,
                     otherFulfillmentCost: 0,
                     otherTransactionCost: 0,
@@ -2520,64 +2248,76 @@ const createConfigs = (overrides = {}) => ({
                 });
             });
         });
-        (0, vitest_1.describe)('malformed entry data', () => {
-            (0, vitest_1.it)('should handle entry with undefined flatAmount', () => {
+        describe('malformed entry data', () => {
+            it('should handle entry with undefined flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: undefined, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: undefined, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(0);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
             });
-            (0, vitest_1.it)('should handle entry with null flatAmount', () => {
+            it('should handle entry with null flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: null, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: null, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(0);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
             });
-            (0, vitest_1.it)('should handle entry with NaN flatAmount', () => {
+            it('should handle entry with NaN flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: NaN, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: NaN, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
+                expect(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
             });
-            (0, vitest_1.it)('should handle entry with negative flatAmount', () => {
+            it('should handle entry with negative flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: -10, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: -10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(-10);
+                expect(result.categoryCosts.totalOtherCogs).toBe(-10);
             });
-            (0, vitest_1.it)('should handle entry with Infinity flatAmount', () => {
+            it('should handle entry with Infinity flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: Infinity, category: 'marketing' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: Infinity, category: 'marketing' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.marketingCost).toBe('number');
+                expect(typeof result.categoryCosts.marketingCost).toBe('number');
             });
-            (0, vitest_1.it)('should handle entry with string flatAmount', () => {
+            it('should handle entry with string flatAmount', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: '10.50', category: 'opex' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: '10.50', category: 'opex' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(10.5);
+                expect(result.categoryCosts.opexCost).toBe(10.5);
             });
         });
-        (0, vitest_1.describe)('malformed percent rates', () => {
-            (0, vitest_1.it)('should handle undefined percentRate', () => {
+        describe('malformed percent rates', () => {
+            it('should handle undefined percentRate', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2587,9 +2327,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ totalPrice: 100 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(0);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle null percentRate', () => {
+            it('should handle null percentRate', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2599,74 +2339,86 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ grossSalePrice: 200 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(0);
+                expect(result.categoryCosts.agencyFeesCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle negative percentRate', () => {
+            it('should handle negative percentRate', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: -5, category: 'marketing' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: -5, category: 'marketing' }),
+                        ],
                     },
                 });
                 const context = createContext({ netSalePrice: 100 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(-5);
+                expect(result.categoryCosts.marketingCost).toBe(-5);
             });
-            (0, vitest_1.it)('should handle percentRate over 100', () => {
+            it('should handle percentRate over 100', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 150, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 150, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalProductCost: 50 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(75);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(75);
             });
         });
-        (0, vitest_1.describe)('malformed context data', () => {
-            (0, vitest_1.it)('should handle zero totalPrice for percent calculations', () => {
+        describe('malformed context data', () => {
+            it('should handle zero totalPrice for percent calculations', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'transaction' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'transaction' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: 0 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(0);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle negative totalPrice', () => {
+            it('should handle negative totalPrice', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: -100 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(-10);
+                expect(result.categoryCosts.totalOtherCogs).toBe(-10);
             });
-            (0, vitest_1.it)('should handle empty lineItems array', () => {
+            it('should handle empty lineItems array', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ lineItems: [] });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-                (0, vitest_1.expect)(result.lineItemCosts).toEqual({});
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.lineItemCosts).toEqual({});
             });
-            (0, vitest_1.it)('should handle lineItems with zero quantity', () => {
+            it('should handle lineItems with zero quantity', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'marketing' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'marketing' }),
+                        ],
                     },
                 });
                 const context = createContext({
                     lineItems: [createLineItem({ quantity: 0 })],
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(0);
+                expect(result.categoryCosts.marketingCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle undefined orderCreatedAt', () => {
+            it('should handle undefined orderCreatedAt', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2681,9 +2433,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ orderCreatedAt: undefined });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.totalOtherCogs).toBe('number');
+                expect(typeof result.categoryCosts.totalOtherCogs).toBe('number');
             });
-            (0, vitest_1.it)('should handle invalid orderCreatedAt format', () => {
+            it('should handle invalid orderCreatedAt format', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2697,46 +2449,46 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ orderCreatedAt: 'not-a-date' });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(10);
+                expect(result.categoryCosts.opexCost).toBe(10);
             });
         });
-        (0, vitest_1.describe)('currency edge cases', () => {
-            (0, vitest_1.it)('should handle empty currency string', () => {
+        describe('currency edge cases', () => {
+            it('should handle empty currency string', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: '', category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: '', category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
             });
-            (0, vitest_1.it)('should handle null order currency', () => {
+            it('should handle null order currency', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), null, emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
+                expect(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
             });
-            (0, vitest_1.it)('should handle missing exchange rates', () => {
+            it('should handle missing exchange rates', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
-                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                                flatAmount: 10,
-                                currency: 'EUR',
-                                category: 'transaction',
-                            }),
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: 'EUR', category: 'transaction' }),
                         ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', {});
-                (0, vitest_1.expect)(typeof result.categoryCosts.otherTransactionCost).toBe('number');
+                expect(typeof result.categoryCosts.otherTransactionCost).toBe('number');
             });
         });
-        (0, vitest_1.describe)('weight and quantity tier edge cases', () => {
-            (0, vitest_1.it)('should fall back to flat mode when weightIntervals array is empty', () => {
+        describe('weight and quantity tier edge cases', () => {
+            it('should fall back to flat mode when weightIntervals array is empty', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2750,9 +2502,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ totalWeight: 1000 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(5000);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(5000);
             });
-            (0, vitest_1.it)('should fall back to flat mode when quantityIntervals array is empty', () => {
+            it('should fall back to flat mode when quantityIntervals array is empty', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2766,9 +2518,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ lineItems: [createLineItem({ quantity: 10 })] });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(50);
+                expect(result.categoryCosts.totalOtherCogs).toBe(50);
             });
-            (0, vitest_1.it)('should handle weight outside all tier ranges', () => {
+            it('should handle weight outside all tier ranges', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2785,9 +2537,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ totalWeight: 1000 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle zero totalWeight', () => {
+            it('should handle zero totalWeight', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2801,9 +2553,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ totalWeight: 0 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(0);
+                expect(result.categoryCosts.marketingCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle negative totalWeight', () => {
+            it('should handle negative totalWeight', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2817,21 +2569,23 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ totalWeight: -100 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.opexCost).toBe('number');
+                expect(typeof result.categoryCosts.opexCost).toBe('number');
             });
         });
-        (0, vitest_1.describe)('filter context edge cases', () => {
-            (0, vitest_1.it)('should handle undefined orderFilterContext', () => {
+        describe('filter context edge cases', () => {
+            it('should handle undefined orderFilterContext', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ orderFilterContext: undefined });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(typeof result.categoryCosts.totalOtherCogs).toBe('number');
+                expect(typeof result.categoryCosts.totalOtherCogs).toBe('number');
             });
-            (0, vitest_1.it)('should handle empty tags array in filter context', () => {
+            it('should handle empty tags array in filter context', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2849,11 +2603,11 @@ const createConfigs = (overrides = {}) => ({
                     orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [] },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
             });
         });
-        (0, vitest_1.describe)('date range edge cases', () => {
-            (0, vitest_1.it)('should handle entry with effectiveFrom after effectiveTo', () => {
+        describe('date range edge cases', () => {
+            it('should handle entry with effectiveFrom after effectiveTo', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2868,9 +2622,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(0);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
             });
-            (0, vitest_1.it)('should handle entry with same effectiveFrom and effectiveTo', () => {
+            it('should handle entry with same effectiveFrom and effectiveTo', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2885,9 +2639,9 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(10);
+                expect(result.categoryCosts.agencyFeesCost).toBe(10);
             });
-            (0, vitest_1.it)('should handle invalid effectiveFrom format', () => {
+            it('should handle invalid effectiveFrom format', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2901,11 +2655,11 @@ const createConfigs = (overrides = {}) => ({
                 });
                 const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(10);
+                expect(result.categoryCosts.opexCost).toBe(10);
             });
         });
-        (0, vitest_1.describe)('concurrent category accumulation', () => {
-            (0, vitest_1.it)('should correctly accumulate when multiple entries have same ID but different categories', () => {
+        describe('concurrent category accumulation', () => {
+            it('should correctly accumulate when multiple entries have same ID but different categories', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -2915,10 +2669,10 @@ const createConfigs = (overrides = {}) => ({
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(5);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
             });
-            (0, vitest_1.it)('should handle maximum number of entries without performance degradation', () => {
+            it('should handle maximum number of entries without performance degradation', () => {
                 const entries = Array.from({ length: 100 }, (_, i) => createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                     id: `entry-${i}`,
                     flatAmount: 1,
@@ -2935,12 +2689,12 @@ const createConfigs = (overrides = {}) => ({
                     result.categoryCosts.agencyFeesCost +
                     result.categoryCosts.opexCost +
                     result.categoryCosts.totalOtherCost;
-                (0, vitest_1.expect)(totalCost).toBe(100);
+                expect(totalCost).toBe(100);
             });
         });
     });
-    (0, vitest_1.describe)('Accounting Identity Tests', () => {
-        (0, vitest_1.describe)('sum of category costs equals order + line-item level costs', () => {
+    describe('Accounting Identity Tests', () => {
+        describe('sum of category costs equals order + line-item level costs', () => {
             const sumCategoryCosts = (categoryCosts) => {
                 return (categoryCosts.totalOtherCogs +
                     categoryCosts.otherFulfillmentCost +
@@ -2950,19 +2704,21 @@ const createConfigs = (overrides = {}) => ({
                     categoryCosts.opexCost +
                     categoryCosts.totalOtherCost);
             };
-            (0, vitest_1.it)('should maintain identity with single order-level COGS entry', () => {
+            it('should maintain identity with single order-level COGS entry', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 25, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 25, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(sumOfCategories).toBe(25);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(25);
             });
-            (0, vitest_1.it)('should maintain identity with single line-item-level entry', () => {
+            it('should maintain identity with single line-item-level entry', () => {
                 const lineItems = [
                     createLineItem({ lineItemId: 'li-1', quantity: 3 }),
                     createLineItem({ lineItemId: 'li-2', quantity: 2 }),
@@ -2970,16 +2726,18 @@ const createConfigs = (overrides = {}) => ({
                 const context = createContext({ lineItems, totalQuantity: 5 });
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 4, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 4, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(sumOfCategories).toBe(20);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(20);
             });
-            (0, vitest_1.it)('should maintain identity with mixed order-level and line-item-level entries across all categories', () => {
+            it('should maintain identity with mixed order-level and line-item-level entries across all categories', () => {
                 const lineItems = [
                     createLineItem({ lineItemId: 'li-1', quantity: 2 }),
                     createLineItem({ lineItemId: 'li-2', quantity: 3, refundedQuantity: 1 }),
@@ -3011,17 +2769,17 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(5);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(5);
-                (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(15);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(5);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(3);
-                (0, vitest_1.expect)(sumOfCategories).toBe(53);
-            });
-            (0, vitest_1.it)('should maintain identity when entries are filtered out by date range', () => {
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(10);
+                expect(result.categoryCosts.otherTransactionCost).toBe(5);
+                expect(result.categoryCosts.marketingCost).toBe(5);
+                expect(result.categoryCosts.agencyFeesCost).toBe(15);
+                expect(result.categoryCosts.opexCost).toBe(5);
+                expect(result.categoryCosts.totalOtherCost).toBe(3);
+                expect(sumOfCategories).toBe(53);
+            });
+            it('should maintain identity when entries are filtered out by date range', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -3049,13 +2807,13 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(sumOfCategories).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(0);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(10);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.marketingCost).toBe(0);
             });
-            (0, vitest_1.it)('should maintain identity when entries are filtered out by cost filters', () => {
+            it('should maintain identity when entries are filtered out by cost filters', () => {
                 const lineItems = [
                     createLineItem({
                         lineItemId: 'li-1',
@@ -3101,13 +2859,13 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(10);
-                (0, vitest_1.expect)(sumOfCategories).toBe(20);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.otherTransactionCost).toBe(10);
+                expect(sumOfCategories).toBe(20);
             });
-            (0, vitest_1.it)('should maintain identity with multiple entries in same category', () => {
+            it('should maintain identity with multiple entries in same category', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -3120,11 +2878,11 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(30);
-                (0, vitest_1.expect)(sumOfCategories).toBe(30);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.totalOtherCogs).toBe(30);
+                expect(sumOfCategories).toBe(30);
             });
-            (0, vitest_1.it)('should maintain identity with legacy category mappings', () => {
+            it('should maintain identity with legacy category mappings', () => {
                 const configs = createConfigs({
                     order: {
                         entries: [
@@ -3138,29 +2896,29 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(15);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(28);
-                (0, vitest_1.expect)(sumOfCategories).toBe(43);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.otherTransactionCost).toBe(15);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(28);
+                expect(sumOfCategories).toBe(43);
             });
-            (0, vitest_1.it)('should maintain identity with empty config', () => {
+            it('should maintain identity with empty config', () => {
                 const configs = createConfigs({
                     order: { entries: [] },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(sumOfCategories).toBe(0);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(0);
             });
-            (0, vitest_1.it)('should maintain identity with null config', () => {
+            it('should maintain identity with null config', () => {
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(inputTotal);
-                (0, vitest_1.expect)(sumOfCategories).toBe(0);
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(0);
             });
-            (0, vitest_1.it)('should maintain identity with currency conversion', () => {
+            it('should maintain identity with currency conversion', () => {
                 const exchangeRates = {
                     USD: { EUR: 0.85, GBP: 0.73 },
                     EUR: { USD: 1.18, GBP: 0.86 },
@@ -3169,11 +2927,7 @@ const createConfigs = (overrides = {}) => ({
                     order: {
                         entries: [
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs', currency: 'EUR' }),
-                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
-                                flatAmount: 20,
-                                category: 'fulfillment',
-                                currency: 'GBP',
-                            }),
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 20, category: 'fulfillment', currency: 'GBP' }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 15, category: 'marketing', currency: 'USD' }),
                         ],
                     },
@@ -3181,11 +2935,11 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', exchangeRates);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBeCloseTo(10 * 1.18, 5);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(15);
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.totalOtherCogs).toBeCloseTo(10 * 1.18, 5);
+                expect(result.categoryCosts.marketingCost).toBe(15);
             });
-            (0, vitest_1.it)('should maintain identity with percentage-based entries', () => {
+            it('should maintain identity with percentage-based entries', () => {
                 const context = createContext({
                     totalProductCost: 100,
                     totalShipping: 50,
@@ -3207,15 +2961,15 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(10);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(20);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(5.4);
-                (0, vitest_1.expect)(sumOfCategories).toBe(55.4);
-            });
-            (0, vitest_1.it)('should maintain identity with weight-based entries', () => {
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(10);
+                expect(result.categoryCosts.otherTransactionCost).toBe(10);
+                expect(result.categoryCosts.marketingCost).toBe(20);
+                expect(result.categoryCosts.opexCost).toBe(5.4);
+                expect(sumOfCategories).toBe(55.4);
+            });
+            it('should maintain identity with weight-based entries', () => {
                 const context = createContext({ totalWeight: 1500 });
                 const configs = createConfigs({
                     order: {
@@ -3231,10 +2985,10 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0.75);
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0.75);
             });
-            (0, vitest_1.it)('should maintain identity with weight-tiered entries', () => {
+            it('should maintain identity with weight-tiered entries', () => {
                 const context = createContext({ totalWeight: 750 });
                 const configs = createConfigs({
                     order: {
@@ -3254,10 +3008,10 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(8);
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(8);
             });
-            (0, vitest_1.it)('should maintain identity with quantity-tiered entries', () => {
+            it('should maintain identity with quantity-tiered entries', () => {
                 const context = createContext({
                     lineItems: [
                         createLineItem({ lineItemId: '1', quantity: 5 }),
@@ -3281,27 +3035,29 @@ const createConfigs = (overrides = {}) => ({
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
                 const sumOfCategories = sumCategoryCosts(result.categoryCosts);
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(18);
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(18);
             });
         });
-        (0, vitest_1.describe)('no double-counting between categories', () => {
-            (0, vitest_1.it)('should route each entry to exactly one category', () => {
+        describe('no double-counting between categories', () => {
+            it('should route each entry to exactly one category', () => {
                 const configs = createConfigs({
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 100, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 100, category: 'cogs' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBe(100);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBe(0);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBe(0);
-            });
-            (0, vitest_1.it)('should not double-count when entry matches multiple conditions', () => {
+                expect(result.categoryCosts.totalOtherCogs).toBe(100);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
+                expect(result.categoryCosts.marketingCost).toBe(0);
+                expect(result.categoryCosts.agencyFeesCost).toBe(0);
+                expect(result.categoryCosts.opexCost).toBe(0);
+                expect(result.categoryCosts.totalOtherCost).toBe(0);
+            });
+            it('should not double-count when entry matches multiple conditions', () => {
                 const lineItems = [
                     createLineItem({
                         lineItemId: 'li-1',
@@ -3334,12 +3090,12 @@ const createConfigs = (overrides = {}) => ({
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBe(50);
-                (0, vitest_1.expect)(result.orderLevelOtherCost + result.lineItemLevelOtherCost).toBe(50);
+                expect(result.categoryCosts.otherTransactionCost).toBe(50);
+                expect(result.orderLevelOtherCost + result.lineItemLevelOtherCost).toBe(50);
             });
         });
-        (0, vitest_1.describe)('handling/gateway/shipping costs are separate from category costs', () => {
-            (0, vitest_1.it)('should not include handling costs in category cost sum', () => {
+        describe('handling/gateway/shipping costs are separate from category costs', () => {
+            it('should not include handling costs in category cost sum', () => {
                 const lineItems = [
                     createLineItem({ lineItemId: 'li-1', quantity: 2, variantHandlingFee: 5 }),
                     createLineItem({ lineItemId: 'li-2', quantity: 1, variantHandlingFee: 3 }),
@@ -3347,7 +3103,9 @@ const createConfigs = (overrides = {}) => ({
                 const configs = createConfigs({
                     globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
                     },
                 });
                 const context = createContext({ lineItems, totalQuantity: 3 });
@@ -3359,19 +3117,21 @@ const createConfigs = (overrides = {}) => ({
                     result.categoryCosts.agencyFeesCost +
                     result.categoryCosts.opexCost +
                     result.categoryCosts.totalOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(10);
-                (0, vitest_1.expect)(result.totalHandlingCost).toBe(13);
-                (0, vitest_1.expect)(result.lineItemLevelHandlingCost).toBe(13);
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalHandlingCost).toBe(13);
+                expect(result.lineItemLevelHandlingCost).toBe(13);
             });
-            (0, vitest_1.it)('should not include gateway costs in category cost sum', () => {
+            it('should not include gateway costs in category cost sum', () => {
                 const configs = createConfigs({
                     gateway: {
                         entries: [
-                            { id: 'g1', name: 'Stripe', gatewayName: 'stripe', flatAmount: 0.3, percentRate: 2.9, currency: 'USD' },
+                            { id: 'g1', name: 'Stripe', gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD' },
                         ],
                     },
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
                     },
                 });
                 const context = createContext({ totalPrice: 100 });
@@ -3383,10 +3143,10 @@ const createConfigs = (overrides = {}) => ({
                     result.categoryCosts.agencyFeesCost +
                     result.categoryCosts.opexCost +
                     result.categoryCosts.totalOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(10);
-                (0, vitest_1.expect)(result.totalGatewayCost).toBe(3.2);
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalGatewayCost).toBe(3.2);
             });
-            (0, vitest_1.it)('should not include shipping costs in category cost sum', () => {
+            it('should not include shipping costs in category cost sum', () => {
                 const configs = createConfigs({
                     shipping: {
                         method: at_tracking_event_types_1.SHIPPING_METHOD.FIXED_RATE,
@@ -3394,7 +3154,9 @@ const createConfigs = (overrides = {}) => ({
                         currency: 'USD',
                     },
                     order: {
-                        entries: [createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'marketing' })],
+                        entries: [
+                            createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'marketing' }),
+                        ],
                     },
                 });
                 const result = cost_calculator_service_1.CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
@@ -3405,18 +3167,18 @@ const createConfigs = (overrides = {}) => ({
                     result.categoryCosts.agencyFeesCost +
                     result.categoryCosts.opexCost +
                     result.categoryCosts.totalOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBe(10);
-                (0, vitest_1.expect)(result.totalShippingCost).toBe(15);
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalShippingCost).toBe(15);
             });
         });
-        (0, vitest_1.describe)('stress test: large realistic order with all cost types', () => {
-            (0, vitest_1.it)('should maintain accounting identity with complex realistic order', () => {
+        describe('stress test: large realistic order with all cost types', () => {
+            it('should maintain accounting identity with complex realistic order', () => {
                 const lineItems = [
                     createLineItem({
                         lineItemId: 'li-1',
                         quantity: 5,
                         refundedQuantity: 0,
-                        variantHandlingFee: 1.5,
+                        variantHandlingFee: 1.50,
                         filterContext: { tags: ['electronics'], productId: '100', variantId: '200', vendor: 'Samsung' },
                     }),
                     createLineItem({
@@ -3430,17 +3192,17 @@ const createConfigs = (overrides = {}) => ({
                         lineItemId: 'li-3',
                         quantity: 2,
                         refundedQuantity: 0,
-                        variantHandlingFee: 2.0,
+                        variantHandlingFee: 2.00,
                         filterContext: { tags: ['premium', 'electronics'], productId: '102', variantId: '202', vendor: 'Apple' },
                     }),
                 ];
                 const context = createContext({
                     orderCreatedAt: '2024-06-15T10:00:00Z',
-                    totalPrice: 850.0,
-                    grossSalePrice: 920.0,
-                    netSalePrice: 780.0,
-                    totalProductCost: 425.0,
-                    totalShipping: 25.0,
+                    totalPrice: 850.00,
+                    grossSalePrice: 920.00,
+                    netSalePrice: 780.00,
+                    totalProductCost: 425.00,
+                    totalShipping: 25.00,
                     totalWeight: 2500,
                     totalQuantity: 10,
                     hasRefund: true,
@@ -3460,7 +3222,7 @@ const createConfigs = (overrides = {}) => ({
                 };
                 const configs = createConfigs({
                     globalProductOverride: {
-                        globalHandlingFee: 0.5,
+                        globalHandlingFee: 0.50,
                         currency: 'USD',
                     },
                     gateway: {
@@ -3469,7 +3231,7 @@ const createConfigs = (overrides = {}) => ({
                                 id: 'stripe',
                                 name: 'Stripe',
                                 gatewayName: 'stripe',
-                                flatAmount: 0.3,
+                                flatAmount: 0.30,
                                 percentRate: 2.9,
                                 currency: 'USD',
                             },
@@ -3484,7 +3246,7 @@ const createConfigs = (overrides = {}) => ({
                                 countries: ['US'],
                                 isDefault: false,
                                 rateType: at_tracking_event_types_1.SHIPPING_RATE_TYPE.FLAT,
-                                flatAmount: 12.0,
+                                flatAmount: 12.00,
                                 currency: 'USD',
                             },
                             {
@@ -3507,7 +3269,7 @@ const createConfigs = (overrides = {}) => ({
                         entries: [
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                                 id: 'packaging-base',
-                                flatAmount: 2.0,
+                                flatAmount: 2.00,
                                 category: 'cogs',
                             }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PCT_COGS, {
@@ -3537,7 +3299,7 @@ const createConfigs = (overrides = {}) => ({
                             }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_ORDER, {
                                 id: 'agency-retainer-allocation',
-                                flatAmount: 8.0,
+                                flatAmount: 8.00,
                                 currency: 'EUR',
                                 category: 'agency_fees',
                             }),
@@ -3548,12 +3310,12 @@ const createConfigs = (overrides = {}) => ({
                             }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
                                 id: 'refund-processing',
-                                flatAmount: 5.0,
+                                flatAmount: 5.00,
                                 category: 'opex',
                             }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
                                 id: 'restocking-fee',
-                                flatAmount: 3.0,
+                                flatAmount: 3.00,
                                 category: 'other',
                             }),
                             createEntry(at_tracking_event_types_1.ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
@@ -3577,22 +3339,22 @@ const createConfigs = (overrides = {}) => ({
                     result.categoryCosts.opexCost +
                     result.categoryCosts.totalOtherCost;
                 const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
-                (0, vitest_1.expect)(sumOfCategories).toBeCloseTo(inputTotal, 5);
-                (0, vitest_1.expect)(Number.isFinite(sumOfCategories)).toBe(true);
-                (0, vitest_1.expect)(sumOfCategories).toBeGreaterThanOrEqual(0);
-                (0, vitest_1.expect)(Number.isFinite(result.totalHandlingCost)).toBe(true);
-                (0, vitest_1.expect)(Number.isFinite(result.totalGatewayCost)).toBe(true);
-                (0, vitest_1.expect)(Number.isFinite(result.totalShippingCost)).toBe(true);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCogs).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.otherFulfillmentCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.otherTransactionCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.marketingCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.agencyFeesCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.opexCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.categoryCosts.totalOtherCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.totalHandlingCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.totalGatewayCost).toBeGreaterThan(0);
-                (0, vitest_1.expect)(result.totalShippingCost).toBeGreaterThan(0);
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(Number.isFinite(sumOfCategories)).toBe(true);
+                expect(sumOfCategories).toBeGreaterThanOrEqual(0);
+                expect(Number.isFinite(result.totalHandlingCost)).toBe(true);
+                expect(Number.isFinite(result.totalGatewayCost)).toBe(true);
+                expect(Number.isFinite(result.totalShippingCost)).toBe(true);
+                expect(result.categoryCosts.totalOtherCogs).toBeGreaterThan(0);
+                expect(result.categoryCosts.otherFulfillmentCost).toBeGreaterThan(0);
+                expect(result.categoryCosts.otherTransactionCost).toBeGreaterThan(0);
+                expect(result.categoryCosts.marketingCost).toBeGreaterThan(0);
+                expect(result.categoryCosts.agencyFeesCost).toBeGreaterThan(0);
+                expect(result.categoryCosts.opexCost).toBeGreaterThan(0);
+                expect(result.categoryCosts.totalOtherCost).toBeGreaterThan(0);
+                expect(result.totalHandlingCost).toBeGreaterThan(0);
+                expect(result.totalGatewayCost).toBeGreaterThan(0);
+                expect(result.totalShippingCost).toBeGreaterThan(0);
             });
         });
     });