@adtrackify/at-service-common 3.19.23 → 3.19.25

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

@@ -0,0 +1,3318 @@
+import { ORDER_COST_ENTRY_TYPE, SHIPPING_METHOD, SHIPPING_RATE_TYPE, WEIGHT_UNIT, COST_FILTER_MODE, } from '@adtrackify/at-tracking-event-types';
+import { CostCalculatorService } from '../../../services/cost/cost-calculator-service';
+jest.mock('../../../helpers/logging-helper', () => ({
+    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const emptyRatesMap = {};
+const createLineItem = (overrides = {}) => ({
+    lineItemId: '1',
+    quantity: 1,
+    refundedQuantity: 0,
+    filterContext: {
+        tags: [],
+        productId: '100',
+        variantId: '200',
+    },
+    ...overrides,
+});
+const createContext = (overrides = {}) => ({
+    orderCreatedAt: '2024-06-15T10:00:00Z',
+    totalPrice: 100,
+    grossSalePrice: 120,
+    netSalePrice: 90,
+    totalProductCost: 40,
+    totalShipping: 10,
+    totalWeight: 500,
+    totalQuantity: 3,
+    hasRefund: false,
+    orderFilterContext: {
+        tags: [],
+        paymentGateways: ['stripe'],
+        shippingTitles: ['Standard'],
+    },
+    lineItems: [createLineItem()],
+    ...overrides,
+});
+const createEntry = (type, overrides = {}) => ({
+    id: 'e1',
+    name: 'Test Entry',
+    type,
+    flatAmount: 5,
+    percentRate: 0,
+    currency: 'USD',
+    category: 'ops',
+    channel: 'all',
+    createdAt: '2024-01-01T00:00:00Z',
+    updatedAt: '2024-01-01T00:00:00Z',
+    ...overrides,
+});
+const createConfigs = (overrides = {}) => ({
+    globalProductOverride: null,
+    order: null,
+    gateway: null,
+    shipping: null,
+    ...overrides,
+});
+describe('CostCalculatorService', () => {
+    describe('isDateInRange', () => {
+        it('should return true when no date bounds', () => {
+            expect(CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z')).toBe(true);
+        });
+        it('should return true when order date is within range', () => {
+            expect(CostCalculatorService.isDateInRange('2024-06-15T10:00:00Z', '2024-01-01T00:00:00Z', '2024-12-31T23:59:59Z')).toBe(true);
+        });
+        it('should return false when order date is before effectiveFrom', () => {
+            expect(CostCalculatorService.isDateInRange('2023-06-15T10:00:00Z', '2024-01-01T00:00:00Z')).toBe(false);
+        });
+        it('should return false when order date is after effectiveTo', () => {
+            expect(CostCalculatorService.isDateInRange('2025-06-15T10:00:00Z', undefined, '2024-12-31T23:59:59Z')).toBe(false);
+        });
+        it('should return true for invalid order date', () => {
+            expect(CostCalculatorService.isDateInRange('invalid-date', '2024-01-01T00:00:00Z')).toBe(true);
+        });
+    });
+    describe('findMatchingWeightTierAmount', () => {
+        it('should return 0 for empty tiers', () => {
+            expect(CostCalculatorService.findMatchingWeightTierAmount([], 500, undefined)).toBe(0);
+            expect(CostCalculatorService.findMatchingWeightTierAmount(undefined, 500, undefined)).toBe(0);
+        });
+        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 },
+            ];
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 250, undefined)).toBe(5);
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 750, undefined)).toBe(10);
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 2000, undefined)).toBe(15);
+        });
+        it('should return 0 when no tier matches', () => {
+            const tiers = [{ weightMin: 100, weightMax: 200, flatAmount: 5 }];
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 50, undefined)).toBe(0);
+        });
+        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 },
+            ];
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 100, WEIGHT_UNIT.OUNCES)).toBe(2);
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, WEIGHT_UNIT.OUNCES)).toBe(8);
+        });
+        it('should return 0 when tier has null flatAmount', () => {
+            const tiers = [{ weightMin: 0, weightMax: 1000, flatAmount: null }];
+            expect(CostCalculatorService.findMatchingWeightTierAmount(tiers, 500, undefined)).toBe(0);
+        });
+    });
+    describe('findQuantityTierAmount', () => {
+        it('should return 0 for empty tiers', () => {
+            expect(CostCalculatorService.findQuantityTierAmount([], 5)).toBe(0);
+            expect(CostCalculatorService.findQuantityTierAmount(undefined, 5)).toBe(0);
+        });
+        it('should find correct tier', () => {
+            const tiers = [
+                { quantityMin: 1, quantityMax: 10, flatAmount: 2 },
+                { quantityMin: 11, quantityMax: null, flatAmount: 1 },
+            ];
+            expect(CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(2);
+            expect(CostCalculatorService.findQuantityTierAmount(tiers, 20)).toBe(1);
+        });
+        it('should return 0 when quantity is below all tiers', () => {
+            const tiers = [
+                { quantityMin: 5, quantityMax: 10, flatAmount: 2 },
+                { quantityMin: 11, quantityMax: null, flatAmount: 1 },
+            ];
+            expect(CostCalculatorService.findQuantityTierAmount(tiers, 2)).toBe(0);
+        });
+        it('should return 0 when tier has null flatAmount', () => {
+            const tiers = [{ quantityMin: 1, quantityMax: 10, flatAmount: null }];
+            expect(CostCalculatorService.findQuantityTierAmount(tiers, 5)).toBe(0);
+        });
+    });
+    describe('calculateHandlingCost', () => {
+        const initLineItemCosts = (lineItemIds = ['1']) => {
+            const result = {};
+            for (const id of lineItemIds) {
+                result[id] = { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 };
+            }
+            return result;
+        };
+        it('should return 0 when no globalProductOverride', () => {
+            const configs = createConfigs();
+            const lineItems = [createLineItem({ quantity: 1 })];
+            const liCosts = initLineItemCosts();
+            expect(CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should apply flat fee per line item (not multiplied by quantity)', () => {
+            const configs = createConfigs({
+                globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
+            });
+            const lineItems = [createLineItem({ lineItemId: '1', quantity: 3 })];
+            const liCosts = initLineItemCosts();
+            const result = CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
+            expect(result).toBe(2);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(2);
+        });
+        it('should sum across multiple line items', () => {
+            const configs = createConfigs({
+                globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
+            });
+            const lineItems = [
+                createLineItem({ lineItemId: '1', quantity: 2 }),
+                createLineItem({ lineItemId: '2', quantity: 3 }),
+            ];
+            const liCosts = initLineItemCosts(['1', '2']);
+            const result = CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
+            expect(result).toBe(4);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(2);
+            expect(liCosts['2'].totalLineItemHandlingCost).toBe(2);
+        });
+        it('should convert currency when config currency differs from order currency', () => {
+            const configs = createConfigs({
+                globalProductOverride: { globalHandlingFee: 10, currency: 'EUR' },
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            const lineItems = [createLineItem({ quantity: 1 })];
+            const liCosts = initLineItemCosts();
+            const result = CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', rates);
+            expect(result).toBeCloseTo(11);
+        });
+        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();
+            expect(CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap)).toBe(5);
+        });
+        it('should add global handling fee on top of existing per-variant handling cost', () => {
+            const configs = createConfigs({
+                globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
+            });
+            const lineItems = [createLineItem({ lineItemId: '1', quantity: 3 })];
+            const liCosts = initLineItemCosts();
+            liCosts['1'].totalLineItemHandlingCost = 4.5;
+            CostCalculatorService.calculateHandlingCost(configs, lineItems, liCosts, 'USD', emptyRatesMap);
+            expect(liCosts['1'].totalLineItemHandlingCost).toBe(6.5);
+        });
+    });
+    describe('calculateGatewayCost', () => {
+        it('should return 0 when no gateway config', () => {
+            const configs = createConfigs();
+            expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should return 0 when no matching gateway', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+            });
+            expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should calculate flat + percent for matching gateway', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+            });
+            const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
+            expect(result).toBeCloseTo(3.20);
+        });
+        it('should be case-insensitive for gateway name', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'Stripe', flatAmount: 1, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+            });
+            expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(1);
+        });
+        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: '',
+                        }],
+                },
+            });
+            expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should convert flat amount from entry currency', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'stripe', flatAmount: 1, percentRate: 0, currency: 'EUR', createdAt: '', updatedAt: '' }],
+                },
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', rates);
+            expect(result).toBeCloseTo(1.1);
+        });
+        it('should pick first matching gateway when multiple entries exist', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [
+                        { 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 = CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
+            expect(result).toBeCloseTo(3.20);
+        });
+        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: '',
+                        }],
+                },
+            });
+            expect(CostCalculatorService.calculateGatewayCost(configs, ['stripe'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should match gateway when order has multiple gateways', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'paypal', flatAmount: 0.50, percentRate: 3.0, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+            });
+            const result = CostCalculatorService.calculateGatewayCost(configs, ['stripe', 'paypal'], 100, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap);
+            expect(result).toBeCloseTo(3.50);
+        });
+    });
+    describe('calculateShippingCost', () => {
+        it('should return 0 when no shipping config', () => {
+            const configs = createConfigs();
+            expect(CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should return shopify amount for SHOPIFY_CHARGES method', () => {
+            const configs = createConfigs({
+                shipping: { method: SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 15.50, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15.50);
+        });
+        it('should return fixed rate for FIXED_RATE method', () => {
+            const configs = createConfigs({
+                shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 8.99, currency: 'USD' },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 10, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(8.99);
+        });
+        it('should convert fixed rate from shipping currency', () => {
+            const configs = createConfigs({
+                shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 10, currency: 'GBP' },
+            });
+            const rates = { GBP: { USD: 1.27 } };
+            const result = CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', rates);
+            expect(result).toBeCloseTo(12.7);
+        });
+        it('should match shipping profile by country', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [
+                        {
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        },
+                        {
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        },
+                    ],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
+        });
+        it('should fall back to default profile', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [
+                        {
+                            id: 'p1', name: 'US Profile', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        },
+                        {
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 15, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        },
+                    ],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(15);
+        });
+        it('should handle weight-tiered profile', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [{
+                            id: 'p1', name: 'Weight', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'USD',
+                            weightUnit: WEIGHT_UNIT.GRAMS,
+                            weightTiers: [
+                                { weightMin: 0, weightMax: 500, flatAmount: 5 },
+                                { weightMin: 501, weightMax: null, flatAmount: 10 },
+                            ],
+                            createdAt: '', updatedAt: '',
+                        }],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 300, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(5);
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 700, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(10);
+        });
+        it('should return 0 when no shipping profile matches (no country match, no default)', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [{
+                            id: 'p1', name: 'US Only', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'CA', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(0);
+        });
+        it('should skip expired shipping profile and fall back to default', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [
+                        {
+                            id: 'p1', name: 'US Expired', countries: ['US'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 5, currency: 'USD',
+                            effectiveTo: '2024-01-01T00:00:00Z',
+                            createdAt: '', updatedAt: '',
+                        },
+                        {
+                            id: 'p2', name: 'Default', countries: [], isDefault: true,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 12, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        },
+                    ],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(12);
+        });
+        it('should convert weight-tiered shipping profile amount from profile currency', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'EUR',
+                    profiles: [{
+                            id: 'p1', name: 'EU Weight', countries: ['DE'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED, currency: 'EUR',
+                            weightUnit: WEIGHT_UNIT.GRAMS,
+                            weightTiers: [
+                                { weightMin: 0, weightMax: 500, flatAmount: 5 },
+                                { weightMin: 501, weightMax: null, flatAmount: 10 },
+                            ],
+                            createdAt: '', updatedAt: '',
+                        }],
+                },
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'DE', 300, '2024-06-15T10:00:00Z', 'USD', rates)).toBeCloseTo(5.5);
+        });
+        it('should be case-insensitive for shipping profile country matching', () => {
+            const configs = createConfigs({
+                shipping: {
+                    method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                    currency: 'USD',
+                    profiles: [{
+                            id: 'p1', name: 'US', countries: ['us'], isDefault: false,
+                            rateType: SHIPPING_RATE_TYPE.FLAT, flatAmount: 7, currency: 'USD',
+                            createdAt: '', updatedAt: '',
+                        }],
+                },
+            });
+            expect(CostCalculatorService.calculateShippingCost(configs, 0, 'US', 500, '2024-06-15T10:00:00Z', 'USD', emptyRatesMap)).toBe(7);
+        });
+    });
+    describe('calculateOtherCostEntry', () => {
+        const initLineItemCosts = () => ({
+            '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+        });
+        it('should calculate PER_ORDER flat amount as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 3 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(3);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should calculate PER_LINE_ITEM with quantity as line-item-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
+            const liCosts = initLineItemCosts();
+            const context = createContext({ lineItems: [createLineItem({ quantity: 3 })] });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+        });
+        it('should accumulate PER_LINE_ITEM costs across multiple line items as line-item-level', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '3': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 1 }),
+                    createLineItem({ lineItemId: '3', quantity: 5 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            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);
+        });
+        it('should calculate BY_ORDER_WEIGHT with flat amount as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, { flatAmount: 0.01 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in KILOGRAMS (totalWeight is grams from Shopify)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                weightUnit: WEIGHT_UNIT.KILOGRAMS,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 5, flatAmount: 3 },
+                    { weightMin: 5.01, weightMax: 20, flatAmount: 8 },
+                    { weightMin: 20.01, weightMax: null, flatAmount: 15 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(8);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 25000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(15);
+        });
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in POUNDS', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                weightUnit: WEIGHT_UNIT.POUNDS,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 10, flatAmount: 5 },
+                    { weightMin: 10.01, weightMax: null, flatAmount: 12 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 10000 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(12);
+        });
+        it('should calculate BY_ORDER_WEIGHT with weight tiers in GRAMS (no conversion needed)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                weightUnit: WEIGHT_UNIT.GRAMS,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 1000, flatAmount: 2 },
+                    { weightMin: 1001, weightMax: null, flatAmount: 7 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 1500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(7);
+        });
+        it('should calculate BY_ORDER_WEIGHT with weight tiers and no weightUnit (treats as grams)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                weightUnit: undefined,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 1000, flatAmount: 4 },
+                    { weightMin: 1001, weightMax: null, flatAmount: 9 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(4);
+        });
+        it('should calculate BY_ORDER_WEIGHT with flat amount and KILOGRAMS unit (converts weight before multiplying)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                flatAmount: 0.50,
+                weightUnit: WEIGHT_UNIT.KILOGRAMS,
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 2000 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(1);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should calculate BY_ORDER_WEIGHT with flat amount and POUNDS unit (converts weight before multiplying)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                flatAmount: 2.00,
+                weightUnit: WEIGHT_UNIT.POUNDS,
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 453.592 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBeCloseTo(2);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should calculate BY_LINE_ITEM_QUANTITY with flat amount as line-item-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 0.50 });
+            const liCosts = initLineItemCosts();
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts, 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(5);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(5);
+        });
+        it('should calculate BY_LINE_ITEM_QUANTITY with tiers per line item quantity', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
+                    { quantityMin: 6, quantityMax: null, flatAmount: 2 },
+                ],
+            });
+            const liCosts1 = initLineItemCosts();
+            const result1 = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 3 })] }), liCosts1, 'USD', emptyRatesMap);
+            expect(result1.lineItemLevel).toBe(3);
+            expect(result1.orderLevel).toBe(0);
+            const liCosts2 = initLineItemCosts();
+            const result2 = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts2, 'USD', emptyRatesMap);
+            expect(result2.lineItemLevel).toBe(2);
+            expect(result2.orderLevel).toBe(0);
+        });
+        it('should calculate BY_LINE_ITEM_QUANTITY with multiple line items at different tiers', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
+                    { quantityMin: 6, quantityMax: null, flatAmount: 2 },
+                ],
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 8 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(5);
+            expect(result.orderLevel).toBe(0);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(3);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(2);
+        });
+        it('should calculate BY_ORDER_QUANTITY with flat amount as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 0.50 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should calculate BY_ORDER_QUANTITY with tiers as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 1, quantityMax: 5, flatAmount: 3 },
+                    { quantityMin: 6, quantityMax: null, flatAmount: 2 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 3 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(2);
+        });
+        it('should calculate BY_ORDER_QUANTITY with multiple tiers correctly', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 1, quantityMax: 10, flatAmount: 5 },
+                    { quantityMin: 11, quantityMax: 50, flatAmount: 3 },
+                    { quantityMin: 51, quantityMax: null, flatAmount: 1 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 1 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 25 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(3);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 100 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(1);
+        });
+        it('should return 0 for BY_ORDER_QUANTITY when quantity does not match any tier', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 5, quantityMax: 10, flatAmount: 3 },
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 2 }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should calculate BY_ORDER_QUANTITY with empty quantityIntervals using flat amount', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 2, quantityIntervals: [] });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 7 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(14);
+        });
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when line item quantity is below all tiers', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                quantityIntervals: [{ quantityMin: 5, quantityMax: 10, flatAmount: 3 }],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 2 })] }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(0);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should apply BY_LINE_ITEM_QUANTITY filters per line item, skipping non-matching ones', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                flatAmount: 1,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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' } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(4);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+        });
+        it('should convert flat amount for BY_ORDER_QUANTITY', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, { flatAmount: 5, currency: 'GBP' });
+            const rates = { GBP: { USD: 1.27 } };
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 10 }), initLineItemCosts(), 'USD', rates);
+            expect(result.orderLevel).toBeCloseTo(63.5);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should convert tier amount currency for BY_ORDER_QUANTITY', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                currency: 'EUR',
+                quantityIntervals: [{ quantityMin: 1, quantityMax: null, flatAmount: 10 }],
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalQuantity: 5 }), initLineItemCosts(), 'USD', rates);
+            expect(result.orderLevel).toBeCloseTo(11);
+        });
+        it('should return 0 for BY_ORDER_QUANTITY when order filters do not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                flatAmount: 5,
+                filters: { orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['wholesale'] } },
+            });
+            const context = createContext({
+                totalQuantity: 10,
+                orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should calculate PER_REFUND_ORDER when hasRefund as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { flatAmount: 5 });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: true }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ hasRefund: false }), initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should calculate PER_REFUND_LINE_ITEM as line-item-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 2 });
+            const liCosts = initLineItemCosts();
+            const context = createContext({
+                hasRefund: true,
+                lineItems: [createLineItem({ refundedQuantity: 2 })],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(4);
+        });
+        it('should skip PER_REFUND_LINE_ITEM when refundedQuantity is 0', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 2 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should only count refunded line items for PER_REFUND_LINE_ITEM with mixed refund/non-refund', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 3 });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '3': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            const context = createContext({
+                hasRefund: true,
+                lineItems: [
+                    createLineItem({ lineItemId: '1', refundedQuantity: 2 }),
+                    createLineItem({ lineItemId: '2', refundedQuantity: 0 }),
+                    createLineItem({ lineItemId: '3', refundedQuantity: 1 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(9);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['3'].totalLineItemOtherCost).toBe(3);
+        });
+        it('should calculate PCT_COGS as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalProductCost: 50 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(5);
+        });
+        it('should calculate PCT_SHIPPING as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { percentRate: 5 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalShipping: 20 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(1);
+        });
+        it('should calculate PCT_TOTAL_SALES as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 2 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalPrice: 200 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(4);
+        });
+        it('should calculate PCT_GROSS_SALES as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { percentRate: 3 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ grossSalePrice: 150 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBeCloseTo(4.5);
+        });
+        it('should calculate PCT_NET_SALES as order-level cost', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: 4 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ netSalePrice: 80 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(3.2);
+        });
+        it('should return 0 for PCT_COGS when totalProductCost is 0', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalProductCost: 0 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should return 0 for PCT_SHIPPING when totalShipping is 0', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { percentRate: 5 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalShipping: 0 }), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should return 0 for PER_ORDER when flatAmount is 0', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 0 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should return 0 for PER_LINE_ITEM when quantity is 0', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2 });
+            const context = createContext({ lineItems: [createLineItem({ quantity: 0 })] });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should return 0 for unknown entry type', () => {
+            const entry = createEntry('UNKNOWN_TYPE', { flatAmount: 5 });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should convert flat amount for BY_ORDER_WEIGHT (flat * weight mode)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, { flatAmount: 2, currency: 'EUR' });
+            const rates = { EUR: { USD: 1.1 } };
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 500 }), initLineItemCosts(), 'USD', rates);
+            expect(result.orderLevel).toBeCloseTo(1100);
+        });
+        it('should convert tier amount for BY_ORDER_WEIGHT with tiers + currency', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                currency: 'EUR',
+                weightUnit: WEIGHT_UNIT.GRAMS,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 500, flatAmount: 5 },
+                    { weightMin: 501, weightMax: null, flatAmount: 10 },
+                ],
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, createContext({ totalWeight: 300 }), initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(5.5);
+        });
+        it('should convert flat amount for BY_LINE_ITEM_QUANTITY', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 5, currency: 'GBP' });
+            const rates = { GBP: { USD: 1.27 } };
+            const liCosts = initLineItemCosts();
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext({ lineItems: [createLineItem({ quantity: 10 })] }), liCosts, 'USD', rates);
+            expect(result.lineItemLevel).toBeCloseTo(63.5);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should return 0 when order-level filters do not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] } },
+            });
+            const context = createContext({ orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' } });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap);
+            expect(result.orderLevel).toBe(0);
+        });
+        it('should convert flat amount from entry currency', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: 'EUR' });
+            const rates = { EUR: { USD: 1.1 } };
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, createContext(), initLineItemCosts(), 'USD', rates);
+            expect(result.orderLevel).toBeCloseTo(11);
+        });
+        it('should return 0 for PER_ORDER when product filter does not match any line item', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_ORDER when product filter matches a line item', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P100'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should apply PER_ORDER when at least one of multiple line items matches product filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: 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' } }),
+                ],
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for BY_ORDER_WEIGHT when productTags filter does not match any line item', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                flatAmount: 0.01,
+                filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['fragile'] } },
+            });
+            const context = createContext({
+                totalWeight: 500,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['lightweight'] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply BY_ORDER_WEIGHT when productTags filter matches a line item', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                flatAmount: 0.01,
+                filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['fragile'] } },
+            });
+            const context = createContext({
+                totalWeight: 500,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: ['fragile'] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when productVendors filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                flatAmount: 0.5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
+        });
+        it('should apply BY_LINE_ITEM_QUANTITY when productVendors filter matches', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                flatAmount: 0.5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ quantity: 10, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(5);
+        });
+        it('should return 0 for PCT_GROSS_SALES when productTypes filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                percentRate: 3,
+                filters: { productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Electronics'] } },
+            });
+            const context = createContext({
+                grossSalePrice: 150,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Clothing' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PCT_GROSS_SALES when productTypes filter matches', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                percentRate: 3,
+                filters: { productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Electronics'] } },
+            });
+            const context = createContext({
+                grossSalePrice: 150,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], productType: 'Electronics' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
+        });
+        it('should return 0 for PCT_NET_SALES when productCategories filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, {
+                percentRate: 5,
+                filters: { productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Home > Kitchen'] } },
+            });
+            const context = createContext({
+                netSalePrice: 80,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Sports' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for PCT_TOTAL_SALES when products filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, {
+                percentRate: 2,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
+            });
+            const context = createContext({
+                totalPrice: 200,
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for PCT_COGS when product filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
+                percentRate: 10,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apple'] } },
+            });
+            const context = createContext({
+                totalProductCost: 50,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Samsung' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for PCT_SHIPPING when product filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, {
+                percentRate: 5,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P500'] } },
+            });
+            const context = createContext({
+                totalShipping: 20,
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for PER_REFUND_ORDER when product filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                hasRefund: true,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_REFUND_ORDER when product filter matches and hasRefund', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                hasRefund: true,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should only apply PER_LINE_ITEM cost to line items matching product filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 2,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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' } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+        });
+        it('should return 0 for PER_LINE_ITEM when no line items match product filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 2,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3, filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } }),
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
+        });
+        it('should only apply PER_REFUND_LINE_ITEM cost to refunded line items matching product filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
+                flatAmount: 3,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P1'] } },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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: [] } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+        });
+        it('should check both order and product filters for PER_ORDER (both must pass)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: {
+                    countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                    productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                },
+            });
+            const contextPass = createContext({
+                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'US' },
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
+            });
+            expect(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' } })],
+            });
+            expect(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' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, contextOrderFail, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for BY_ORDER_WEIGHT when order-level country filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                flatAmount: 0.01,
+                filters: { countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] } },
+            });
+            const context = createContext({
+                totalWeight: 500,
+                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], shipCountryCode: 'CA' },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should return 0 for BY_LINE_ITEM_QUANTITY when orderTags filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                flatAmount: 0.5,
+                filters: { orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['wholesale'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ quantity: 10 })],
+                orderFilterContext: { tags: ['retail'], paymentGateways: [], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
+        });
+        it('should return 0 for PCT_GROSS_SALES when orderPaymentGateways filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                percentRate: 3,
+                filters: { orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] } },
+            });
+            const context = createContext({
+                grossSalePrice: 150,
+                orderFilterContext: { tags: [], paymentGateways: ['paypal'], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PCT_GROSS_SALES when orderPaymentGateways filter matches', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                percentRate: 3,
+                filters: { orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] } },
+            });
+            const context = createContext({
+                grossSalePrice: 150,
+                orderFilterContext: { tags: [], paymentGateways: ['stripe'], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBeCloseTo(4.5);
+        });
+        it('should return 0 for PER_LINE_ITEM when orderShippingTitles filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 2,
+                filters: { orderShippingTitles: { mode: COST_FILTER_MODE.INCLUDE, values: ['Express'] } },
+            });
+            const context = createContext({
+                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: ['Standard'] },
+                lineItems: [createLineItem({ quantity: 3 })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
+        });
+        it('should return 0 for PCT_COGS when orderSourceNames filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
+                percentRate: 10,
+                filters: { orderSourceNames: { mode: COST_FILTER_MODE.INCLUDE, values: ['web'] } },
+            });
+            const context = createContext({
+                totalProductCost: 50,
+                orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [], sourceName: 'pos' },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_ORDER when EXCLUDE product filter does not match any line item vendor', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for PER_ORDER when EXCLUDE product filter matches all line items', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } }),
+                ],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_ORDER when product filter mode is ALL', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.ALL, values: [] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'anything' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for PER_ORDER when multiple product filters set and no single line item satisfies all', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: {
+                    productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                    productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+                },
+            });
+            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' } }),
+                ],
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_ORDER when one line item satisfies all product filters', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: {
+                    productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                    productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+                },
+            });
+            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' } }),
+                ],
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should match PER_ORDER with productId_variantId composite filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P100_V200'] } },
+            });
+            const matchContext = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V200', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+            const noMatchContext = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P100', variantId: 'V999', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should convert currency AND evaluate product filters for PER_ORDER', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 10,
+                currency: 'EUR',
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const rates = { EUR: { USD: 1.1 } };
+            const matchContext = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBeCloseTo(11);
+            const noMatchContext = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Adidas' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', rates).orderLevel).toBe(0);
+        });
+        it('should evaluate weight tiers AND product filters for BY_ORDER_WEIGHT', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                weightUnit: WEIGHT_UNIT.KILOGRAMS,
+                weightIntervals: [
+                    { weightMin: 0, weightMax: 5, flatAmount: 3 },
+                    { weightMin: 5.01, weightMax: null, flatAmount: 8 },
+                ],
+                filters: { productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Heavy Items'] } },
+            });
+            const matchContext = createContext({
+                totalWeight: 2000,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], category: 'Heavy Items' } })],
+            });
+            expect(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' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should evaluate quantity tiers AND product filters for BY_LINE_ITEM_QUANTITY', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                quantityIntervals: [
+                    { quantityMin: 1, quantityMax: 10, flatAmount: 2 },
+                    { quantityMin: 11, quantityMax: null, flatAmount: 1 },
+                ],
+                filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['bulk'] } },
+            });
+            const matchContext = createContext({
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['bulk'] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, matchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(2);
+            const noMatchContext = createContext({
+                lineItems: [createLineItem({ quantity: 5, filterContext: { productId: 'P1', variantId: 'V1', tags: ['single'] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, noMatchContext, initLineItemCosts(), 'USD', emptyRatesMap).lineItemLevel).toBe(0);
+        });
+        it('should apply PER_LINE_ITEM to line items NOT matching EXCLUDE product filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 2,
+                filters: { productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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' } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(4);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(4);
+        });
+        it('should apply PER_LINE_ITEM selectively when multiple product filters used', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 1,
+                filters: {
+                    productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                    productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+                },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '3': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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' } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(2);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(2);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['3'].totalLineItemOtherCost).toBe(0);
+        });
+        it('should return 0 for PER_REFUND_ORDER when product filter matches but hasRefund is false', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                hasRefund: false,
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_REFUND_LINE_ITEM only to refunded line items NOT matching EXCLUDE filter', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
+                flatAmount: 3,
+                filters: { products: { mode: COST_FILTER_MODE.EXCLUDE, values: ['P1'] } },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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: [] } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(3);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(0);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(3);
+        });
+        it('should apply PER_ORDER when EXCLUDE order filter does not match', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] } },
+            });
+            const context = createContext({
+                orderFilterContext: { tags: ['vip'], paymentGateways: [], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for PER_ORDER when EXCLUDE order filter matches', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] } },
+            });
+            const context = createContext({
+                orderFilterContext: { tags: ['test'], paymentGateways: [], shippingTitles: [] },
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should handle undefined filter context fields (missing vendor, productType, category)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should handle EXCLUDE filter with undefined filter context field (undefined treated as not matching)', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should return 0 for PER_ORDER when INCLUDE productTags filter and line item has empty tags', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(0);
+        });
+        it('should apply PER_ORDER when EXCLUDE productTags filter and line item has empty tags', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                flatAmount: 5,
+                filters: { productTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['sale'] } },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ filterContext: { productId: 'P1', variantId: 'V1', tags: [] } })],
+            });
+            expect(CostCalculatorService.calculateOtherCostEntry(entry, context, initLineItemCosts(), 'USD', emptyRatesMap).orderLevel).toBe(5);
+        });
+        it('should apply PER_LINE_ITEM only to line items matching product filter when order filter also passes', () => {
+            const entry = createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                flatAmount: 2,
+                filters: {
+                    countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                    productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                },
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+                '2': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            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' } }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOtherCostEntry(entry, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.lineItemLevel).toBe(6);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(6);
+            expect(liCosts['2'].totalLineItemOtherCost).toBe(0);
+        });
+    });
+    describe('calculateOtherCost', () => {
+        it('should return 0 when no order config', () => {
+            const configs = createConfigs();
+            const result = CostCalculatorService.calculateOtherCost(configs, createContext(), {}, 'USD', emptyRatesMap);
+            expect(result.total).toBe(0);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should sum multiple entries and separate order-level costs', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 3 }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 2 }),
+                    ],
+                },
+            });
+            const liCosts = { '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 } };
+            const result = CostCalculatorService.calculateOtherCost(configs, createContext(), liCosts, 'USD', emptyRatesMap);
+            expect(result.total).toBe(5);
+            expect(result.orderLevel).toBe(5);
+            expect(result.lineItemLevel).toBe(0);
+        });
+        it('should accumulate lineItemCosts from multiple PER_LINE_ITEM entries', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'e1', flatAmount: 2 }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'e2', flatAmount: 3 }),
+                    ],
+                },
+            });
+            const context = createContext({
+                lineItems: [createLineItem({ lineItemId: '1', quantity: 2 })],
+            });
+            const liCosts = {
+                '1': { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 },
+            };
+            const result = CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.total).toBe(10);
+            expect(result.orderLevel).toBe(0);
+            expect(result.lineItemLevel).toBe(10);
+            expect(liCosts['1'].totalLineItemOtherCost).toBe(10);
+        });
+        it('should skip entries outside date range', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 3, effectiveFrom: '2025-01-01T00:00:00Z' }),
+                    ],
+                },
+            });
+            const liCosts = {};
+            const result = CostCalculatorService.calculateOtherCost(configs, createContext(), liCosts, 'USD', emptyRatesMap);
+            expect(result.total).toBe(0);
+        });
+        it('should only sum entries whose filters pass (mixed filter results)', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'e1', flatAmount: 3,
+                            filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'e2', flatAmount: 7,
+                            filters: { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P999'] } },
+                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                            id: 'e3', percentRate: 2,
+                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'e4', flatAmount: 10,
+                            filters: { countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['CA'] } },
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({
+                grossSalePrice: 120,
+                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 result = CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
+            expect(result.total).toBeCloseTo(5.4);
+            expect(result.orderLevel).toBeCloseTo(5.4);
+        });
+        it('should sum PER_ORDER and PER_LINE_ITEM entries together and separate by level', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 5 }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'e2', flatAmount: 2 }),
+                    ],
+                },
+            });
+            const context = createContext({
+                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 = CostCalculatorService.calculateOtherCost(configs, context, liCosts, 'USD', emptyRatesMap);
+            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);
+        });
+    });
+    describe('calculateLineItemHandlingCosts', () => {
+        it('should return 0 for no handling fee', () => {
+            const result = CostCalculatorService.calculateLineItemHandlingCosts([createLineItem()]);
+            expect(result['1']).toBe(0);
+        });
+        it('should multiply handling fee by quantity', () => {
+            const result = CostCalculatorService.calculateLineItemHandlingCosts([
+                createLineItem({ lineItemId: '1', quantity: 3, variantHandlingFee: 1.5 }),
+            ]);
+            expect(result['1']).toBe(4.5);
+        });
+        it('should handle multiple line items', () => {
+            const result = CostCalculatorService.calculateLineItemHandlingCosts([
+                createLineItem({ lineItemId: '1', quantity: 2, variantHandlingFee: 1 }),
+                createLineItem({ lineItemId: '2', quantity: 1, variantHandlingFee: 3 }),
+            ]);
+            expect(result['1']).toBe(2);
+            expect(result['2']).toBe(3);
+        });
+    });
+    describe('calculateOrderCosts', () => {
+        it('should return default result when configs is null', () => {
+            const result = CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
+            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.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+                shipping: { method: SHIPPING_METHOD.SHOPIFY_CHARGES, currency: 'USD' },
+                order: {
+                    entries: [createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 1 })],
+                },
+            });
+            const context = createContext({
+                totalShipping: 10,
+                lineItems: [createLineItem({ variantHandlingFee: 0.5, quantity: 2 })],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(3);
+            expect(result.totalHandlingCost).toBe(3);
+            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(3);
+        });
+        it('should handle partial configs', () => {
+            const configs = createConfigs({
+                gateway: {
+                    entries: [{ gatewayName: 'stripe', flatAmount: 0.30, percentRate: 0, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            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(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'e1', flatAmount: 5,
+                            filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } },
+                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'e2', flatAmount: 10,
+                            filters: { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Puma'] } },
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({
+                        lineItemId: '1',
+                        quantity: 1,
+                        filterContext: { productId: 'P1', variantId: 'V1', tags: [], vendor: 'Nike' },
+                    }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.totalOtherCost).toBe(5);
+            expect(result.orderLevelOtherCost).toBe(5);
+        });
+        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.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+                shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 5, currency: 'USD' },
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 3 }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'e2', flatAmount: 1 }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { id: 'e3', percentRate: 2 }),
+                    ],
+                },
+            });
+            const context = createContext({
+                totalPrice: 200,
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3, variantHandlingFee: 0.5 }),
+                    createLineItem({ lineItemId: '2', quantity: 2, variantHandlingFee: 1 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.orderLevelHandlingCost).toBe(0);
+            expect(result.lineItemLevelHandlingCost).toBe(5.5);
+            expect(result.totalHandlingCost).toBe(5.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(2.5);
+            expect(result.lineItemCosts['2'].totalLineItemHandlingCost).toBe(3);
+        });
+        it('should maintain decimal precision with Big.js', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 33.33 }),
+                    ],
+                },
+            });
+            const context = createContext({ totalPrice: 99.99 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.totalOtherCost).toBeCloseTo(33.326667, 4);
+        });
+    });
+    describe('calculateOtherCost - category routing', () => {
+        it('should route COGS category costs to totalOtherCogs', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'cogs1', flatAmount: 10, category: 'cogs' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'cogs2', flatAmount: 5, category: 'cogs' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            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: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'ful1', flatAmount: 8, category: 'fulfillment' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(8);
+            expect(result.categoryCosts.totalOtherCogs).toBe(0);
+        });
+        it('should route TRANSACTION category costs to otherTransactionCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { id: 'tx1', percentRate: 3, category: 'transaction' }),
+                    ],
+                },
+            });
+            const context = createContext({ totalPrice: 100 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherTransactionCost).toBe(3);
+        });
+        it('should route MARKETING category costs to marketingCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'mkt1', flatAmount: 25, category: 'marketing' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.marketingCost).toBe(25);
+        });
+        it('should route AGENCY_FEES category costs to agencyFeesCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { id: 'agency1', percentRate: 15, category: 'agency_fees' }),
+                    ],
+                },
+            });
+            const context = createContext({ grossSalePrice: 200 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.agencyFeesCost).toBe(30);
+        });
+        it('should route OPEX category costs to opexCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 12, category: 'opex' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.opexCost).toBe(12);
+        });
+        it('should route OTHER category costs to totalOtherCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 7, category: 'other' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCost).toBe(7);
+        });
+        it('should route legacy payment_fees to TRANSACTION (otherTransactionCost)', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'legacy1', flatAmount: 2.5, category: 'payment_fees' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherTransactionCost).toBe(2.5);
+            expect(result.categoryCosts.totalOtherCost).toBe(0);
+        });
+        it('should route legacy packaging to FULFILLMENT (otherFulfillmentCost)', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'legacy2', flatAmount: 1.75, category: 'packaging' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(1.75);
+            expect(result.categoryCosts.totalOtherCost).toBe(0);
+        });
+        it('should route unknown category to totalOtherCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'unknown1', flatAmount: 3, category: 'unknown_category_xyz' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCost).toBe(3);
+        });
+        it('should route undefined/null category to totalOtherCost', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'nocat1', flatAmount: 4, category: undefined }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'nocat2', flatAmount: 6, category: null }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCost).toBe(10);
+        });
+        it('should accumulate costs across multiple entries of the same category', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'ful1', flatAmount: 5, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'ful2', flatAmount: 3, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'ful3', flatAmount: 2, category: 'fulfillment' }),
+                    ],
+                },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 2 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(18);
+        });
+        it('should route costs to multiple categories correctly', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'cogs1', flatAmount: 10, category: 'cogs' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'ful1', flatAmount: 5, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { id: 'tx1', percentRate: 2, category: 'transaction' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'mkt1', flatAmount: 15, category: 'marketing' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'agency1', flatAmount: 8, category: 'agency_fees' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 20, category: 'opex' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 3, category: 'other' }),
+                    ],
+                },
+            });
+            const context = createContext({ totalPrice: 100 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            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(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'cogs_li', flatAmount: 2, category: 'cogs' }),
+                        createEntry(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 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(7.5);
+        });
+        it('should handle PCT_COGS entry type with category routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { id: 'pct_cogs', percentRate: 10, category: 'cogs' }),
+                    ],
+                },
+            });
+            const context = createContext({ totalProductCost: 50 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCogs).toBe(5);
+        });
+        it('should handle PCT_SHIPPING entry type routed to fulfillment', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { id: 'pct_ship', percentRate: 20, category: 'fulfillment' }),
+                    ],
+                },
+            });
+            const context = createContext({ totalShipping: 25 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
+        });
+        it('should handle refund costs with category routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { id: 'refund1', flatAmount: 15, category: 'opex' }),
+                    ],
+                },
+            });
+            const context = createContext({ hasRefund: true });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.opexCost).toBe(15);
+        });
+        it('should not apply refund costs when hasRefund is false', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { id: 'refund1', flatAmount: 15, category: 'opex' }),
+                    ],
+                },
+            });
+            const context = createContext({ hasRefund: false });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.opexCost).toBe(0);
+        });
+        it('should respect date ranges in category cost routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'valid',
+                            flatAmount: 10,
+                            category: 'marketing',
+                            effectiveFrom: '2024-01-01T00:00:00Z',
+                            effectiveTo: '2024-12-31T23:59:59Z',
+                        }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                            id: 'expired',
+                            flatAmount: 20,
+                            category: 'marketing',
+                            effectiveFrom: '2023-01-01T00:00:00Z',
+                            effectiveTo: '2023-12-31T23:59:59Z',
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.marketingCost).toBe(10);
+        });
+        it('should return default categoryCosts when configs is null', () => {
+            const result = CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts).toEqual({
+                totalOtherCogs: 0,
+                otherFulfillmentCost: 0,
+                otherTransactionCost: 0,
+                marketingCost: 0,
+                agencyFeesCost: 0,
+                opexCost: 0,
+                totalOtherCost: 0,
+            });
+        });
+        it('should return default categoryCosts when order config is null', () => {
+            const configs = createConfigs({ order: null });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts).toEqual({
+                totalOtherCogs: 0,
+                otherFulfillmentCost: 0,
+                otherTransactionCost: 0,
+                marketingCost: 0,
+                agencyFeesCost: 0,
+                opexCost: 0,
+                totalOtherCost: 0,
+            });
+        });
+        it('should handle mixed legacy and new categories', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'new_tx', flatAmount: 5, category: 'transaction' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'legacy_pf', flatAmount: 3, category: 'payment_fees' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'new_ful', flatAmount: 4, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'legacy_pkg', flatAmount: 2, category: 'packaging' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherTransactionCost).toBe(8);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(6);
+        });
+        it('should handle weight-based costs with category routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                            id: 'weight1',
+                            flatAmount: 0.01,
+                            weightUnit: WEIGHT_UNIT.GRAMS,
+                            category: 'fulfillment',
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({ totalWeight: 1000 });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(10);
+        });
+        it('should handle quantity-based costs with category routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                            id: 'qty1',
+                            flatAmount: 0.5,
+                            category: 'fulfillment',
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({ lineItems: [createLineItem({ quantity: 10 })] });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
+        });
+        it('should handle BY_ORDER_QUANTITY costs with category routing', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY, {
+                            id: 'qty-order',
+                            quantityIntervals: [
+                                { quantityMin: 1, quantityMax: 5, flatAmount: 10 },
+                                { quantityMin: 6, quantityMax: null, flatAmount: 5 },
+                            ],
+                            category: 'cogs',
+                        }),
+                    ],
+                },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 4 }),
+                    createLineItem({ lineItemId: '2', quantity: 3 }),
+                ],
+                totalQuantity: 7,
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCogs).toBe(5);
+            expect(result.orderLevelOtherCost).toBe(5);
+            expect(result.lineItemLevelOtherCost).toBe(0);
+        });
+        it('should continue processing other entries when one entry fails', () => {
+            const configs = createConfigs({
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'good1', flatAmount: 10, category: 'cogs' }),
+                        {
+                            ...createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT),
+                            id: 'problematic',
+                            weightIntervals: [{ weightMin: NaN, weightMax: null, flatAmount: 5 }],
+                            category: 'fulfillment',
+                        },
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'good2', flatAmount: 5, category: 'marketing' }),
+                    ],
+                },
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+            expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            expect(result.categoryCosts.marketingCost).toBe(5);
+        });
+    });
+    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.30, percentRate: 2.9, currency: 'USD', createdAt: '', updatedAt: '' }],
+                },
+                shipping: { method: SHIPPING_METHOD.FIXED_RATE, fixedRateAmount: 7, currency: 'USD' },
+                order: {
+                    entries: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'cogs1', flatAmount: 5, category: 'cogs' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'ful1', flatAmount: 3, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { id: 'tx1', percentRate: 1, category: 'transaction' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'mkt1', flatAmount: 2, category: 'marketing' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'agency1', flatAmount: 10, category: 'agency_fees' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'opex1', flatAmount: 8, category: 'opex' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'other1', flatAmount: 4, category: 'other' }),
+                    ],
+                },
+            });
+            const context = createContext({
+                totalPrice: 200,
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 2, variantHandlingFee: 0.5 }),
+                    createLineItem({ lineItemId: '2', quantity: 3, variantHandlingFee: 0.75 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            expect(result.lineItemLevelHandlingCost).toBe(6.25);
+            expect(result.totalHandlingCost).toBe(6.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: [
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'order_cogs', flatAmount: 10, category: 'cogs' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'li_cogs', flatAmount: 2, category: 'cogs' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'order_ful', flatAmount: 5, category: 'fulfillment' }),
+                        createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { id: 'li_ful', flatAmount: 1, category: 'fulfillment' }),
+                    ],
+                },
+            });
+            const context = createContext({
+                lineItems: [
+                    createLineItem({ lineItemId: '1', quantity: 3 }),
+                    createLineItem({ lineItemId: '2', quantity: 2 }),
+                ],
+            });
+            const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+            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);
+        });
+    });
+    describe('defensive coding - malformed input handling', () => {
+        describe('empty and missing entries', () => {
+            it('should handle empty entries array', () => {
+                const configs = createConfigs({
+                    order: { entries: [] },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.categoryCosts.totalOtherCost).toBe(0);
+                expect(result.totalOtherCost).toBe(0);
+            });
+            it('should handle undefined entries', () => {
+                const configs = createConfigs({
+                    order: { entries: undefined },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts).toEqual({
+                    totalOtherCogs: 0,
+                    otherFulfillmentCost: 0,
+                    otherTransactionCost: 0,
+                    marketingCost: 0,
+                    agencyFeesCost: 0,
+                    opexCost: 0,
+                    totalOtherCost: 0,
+                });
+            });
+            it('should handle null entries', () => {
+                const configs = createConfigs({
+                    order: { entries: null },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts).toEqual({
+                    totalOtherCogs: 0,
+                    otherFulfillmentCost: 0,
+                    otherTransactionCost: 0,
+                    marketingCost: 0,
+                    agencyFeesCost: 0,
+                    opexCost: 0,
+                    totalOtherCost: 0,
+                });
+            });
+        });
+        describe('malformed entry data', () => {
+            it('should handle entry with undefined flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: undefined, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
+            });
+            it('should handle entry with null flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: null, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(0);
+            });
+            it('should handle entry with NaN flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: NaN, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
+            });
+            it('should handle entry with negative flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: -10, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(-10);
+            });
+            it('should handle entry with Infinity flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: Infinity, category: 'marketing' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(typeof result.categoryCosts.marketingCost).toBe('number');
+            });
+            it('should handle entry with string flatAmount', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: '10.50', category: 'opex' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.opexCost).toBe(10.5);
+            });
+        });
+        describe('malformed percent rates', () => {
+            it('should handle undefined percentRate', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: undefined, category: 'transaction' }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalPrice: 100 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
+            });
+            it('should handle null percentRate', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { percentRate: null, category: 'agency_fees' }),
+                        ],
+                    },
+                });
+                const context = createContext({ grossSalePrice: 200 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.agencyFeesCost).toBe(0);
+            });
+            it('should handle negative percentRate', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: -5, category: 'marketing' }),
+                        ],
+                    },
+                });
+                const context = createContext({ netSalePrice: 100 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.marketingCost).toBe(-5);
+            });
+            it('should handle percentRate over 100', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 150, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalProductCost: 50 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(75);
+            });
+        });
+        describe('malformed context data', () => {
+            it('should handle zero totalPrice for percent calculations', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'transaction' }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalPrice: 0 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
+            });
+            it('should handle negative totalPrice', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 10, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalPrice: -100 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(-10);
+            });
+            it('should handle empty lineItems array', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const context = createContext({ lineItems: [] });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+                expect(result.lineItemCosts).toEqual({});
+            });
+            it('should handle lineItems with zero quantity', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 5, category: 'marketing' }),
+                        ],
+                    },
+                });
+                const context = createContext({
+                    lineItems: [createLineItem({ quantity: 0 })],
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.marketingCost).toBe(0);
+            });
+            it('should handle undefined orderCreatedAt', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'cogs',
+                                effectiveFrom: '2024-01-01T00:00:00Z',
+                                effectiveTo: '2024-12-31T23:59:59Z',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: undefined });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(typeof result.categoryCosts.totalOtherCogs).toBe('number');
+            });
+            it('should handle invalid orderCreatedAt format', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'opex',
+                                effectiveFrom: '2024-01-01T00:00:00Z',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: 'not-a-date' });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.opexCost).toBe(10);
+            });
+        });
+        describe('currency edge cases', () => {
+            it('should handle empty currency string', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: '', category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+            });
+            it('should handle null order currency', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), null, emptyRatesMap);
+                expect(typeof result.categoryCosts.otherFulfillmentCost).toBe('number');
+            });
+            it('should handle missing exchange rates', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, currency: 'EUR', category: 'transaction' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', {});
+                expect(typeof result.categoryCosts.otherTransactionCost).toBe('number');
+            });
+        });
+        describe('weight and quantity tier edge cases', () => {
+            it('should fall back to flat mode when weightIntervals array is empty', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                weightIntervals: [],
+                                flatAmount: 5,
+                                category: 'fulfillment',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalWeight: 1000 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(5000);
+            });
+            it('should fall back to flat mode when quantityIntervals array is empty', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                                quantityIntervals: [],
+                                flatAmount: 5,
+                                category: 'cogs',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ lineItems: [createLineItem({ quantity: 10 })] });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(50);
+            });
+            it('should handle weight outside all tier ranges', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                weightIntervals: [
+                                    { weightMin: 0, weightMax: 100, flatAmount: 5 },
+                                    { weightMin: 101, weightMax: 500, flatAmount: 10 },
+                                ],
+                                weightUnit: WEIGHT_UNIT.GRAMS,
+                                category: 'fulfillment',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalWeight: 1000 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+            });
+            it('should handle zero totalWeight', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                flatAmount: 0.01,
+                                weightUnit: WEIGHT_UNIT.GRAMS,
+                                category: 'marketing',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalWeight: 0 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.marketingCost).toBe(0);
+            });
+            it('should handle negative totalWeight', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                flatAmount: 0.01,
+                                weightUnit: WEIGHT_UNIT.GRAMS,
+                                category: 'opex',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalWeight: -100 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(typeof result.categoryCosts.opexCost).toBe('number');
+            });
+        });
+        describe('filter context edge cases', () => {
+            it('should handle undefined orderFilterContext', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderFilterContext: undefined });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(typeof result.categoryCosts.totalOtherCogs).toBe('number');
+            });
+            it('should handle empty tags array in filter context', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'fulfillment',
+                                filters: {
+                                    orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['VIP'] },
+                                },
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({
+                    orderFilterContext: { tags: [], paymentGateways: [], shippingTitles: [] },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0);
+            });
+        });
+        describe('date range edge cases', () => {
+            it('should handle entry with effectiveFrom after effectiveTo', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'transaction',
+                                effectiveFrom: '2025-01-01T00:00:00Z',
+                                effectiveTo: '2024-01-01T00:00:00Z',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherTransactionCost).toBe(0);
+            });
+            it('should handle entry with same effectiveFrom and effectiveTo', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'agency_fees',
+                                effectiveFrom: '2024-06-15T10:00:00Z',
+                                effectiveTo: '2024-06-15T10:00:00Z',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.agencyFeesCost).toBe(10);
+            });
+            it('should handle invalid effectiveFrom format', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'opex',
+                                effectiveFrom: 'invalid-date',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.opexCost).toBe(10);
+            });
+        });
+        describe('concurrent category accumulation', () => {
+            it('should correctly accumulate when multiple entries have same ID but different categories', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'same-id', flatAmount: 10, category: 'cogs' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'same-id', flatAmount: 5, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                expect(result.categoryCosts.totalOtherCogs).toBe(10);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(5);
+            });
+            it('should handle maximum number of entries without performance degradation', () => {
+                const entries = Array.from({ length: 100 }, (_, i) => createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                    id: `entry-${i}`,
+                    flatAmount: 1,
+                    category: ['cogs', 'fulfillment', 'transaction', 'marketing', 'agency_fees', 'opex', 'other'][i % 7],
+                }));
+                const configs = createConfigs({
+                    order: { entries },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const totalCost = result.categoryCosts.totalOtherCogs +
+                    result.categoryCosts.otherFulfillmentCost +
+                    result.categoryCosts.otherTransactionCost +
+                    result.categoryCosts.marketingCost +
+                    result.categoryCosts.agencyFeesCost +
+                    result.categoryCosts.opexCost +
+                    result.categoryCosts.totalOtherCost;
+                expect(totalCost).toBe(100);
+            });
+        });
+    });
+    describe('Accounting Identity Tests', () => {
+        describe('sum of category costs equals order + line-item level costs', () => {
+            const sumCategoryCosts = (categoryCosts) => {
+                return (categoryCosts.totalOtherCogs +
+                    categoryCosts.otherFulfillmentCost +
+                    categoryCosts.otherTransactionCost +
+                    categoryCosts.marketingCost +
+                    categoryCosts.agencyFeesCost +
+                    categoryCosts.opexCost +
+                    categoryCosts.totalOtherCost);
+            };
+            it('should maintain identity with single order-level COGS entry', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 25, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(25);
+            });
+            it('should maintain identity with single line-item-level entry', () => {
+                const lineItems = [
+                    createLineItem({ lineItemId: 'li-1', quantity: 3 }),
+                    createLineItem({ lineItemId: 'li-2', quantity: 2 }),
+                ];
+                const context = createContext({ lineItems, totalQuantity: 5 });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 4, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(20);
+            });
+            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 }),
+                ];
+                const context = createContext({
+                    lineItems,
+                    totalQuantity: 5,
+                    totalWeight: 1000,
+                    totalProductCost: 50,
+                    totalShipping: 10,
+                    totalPrice: 100,
+                    grossSalePrice: 120,
+                    netSalePrice: 90,
+                    hasRefund: true,
+                });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, { flatAmount: 2, category: 'fulfillment' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 5, category: 'transaction' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, { flatAmount: 1, category: 'marketing' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, { flatAmount: 15, category: 'agency_fees' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10, category: 'opex' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, { flatAmount: 3, category: 'other' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                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: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'cogs',
+                                effectiveFrom: '2024-01-01T00:00:00Z',
+                                effectiveTo: '2024-12-31T23:59:59Z',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 20,
+                                category: 'fulfillment',
+                                effectiveFrom: '2025-01-01T00:00:00Z',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 30,
+                                category: 'marketing',
+                                effectiveFrom: '2023-01-01T00:00:00Z',
+                                effectiveTo: '2023-12-31T23:59:59Z',
+                            }),
+                        ],
+                    },
+                });
+                const context = createContext({ orderCreatedAt: '2024-06-15T10:00:00Z' });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                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);
+            });
+            it('should maintain identity when entries are filtered out by cost filters', () => {
+                const lineItems = [
+                    createLineItem({
+                        lineItemId: 'li-1',
+                        quantity: 2,
+                        filterContext: { tags: ['sale'], productId: '100', variantId: '200' },
+                    }),
+                    createLineItem({
+                        lineItemId: 'li-2',
+                        quantity: 3,
+                        filterContext: { tags: ['premium'], productId: '101', variantId: '201' },
+                    }),
+                ];
+                const context = createContext({
+                    lineItems,
+                    totalQuantity: 5,
+                    orderFilterContext: {
+                        tags: ['wholesale'],
+                        paymentGateways: ['stripe'],
+                        shippingTitles: ['Standard'],
+                    },
+                });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 10,
+                                category: 'cogs',
+                                filters: { orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['wholesale'] } },
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 20,
+                                category: 'fulfillment',
+                                filters: { orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['retail'] } },
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                                flatAmount: 5,
+                                category: 'transaction',
+                                filters: { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } },
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                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);
+            });
+            it('should maintain identity with multiple entries in same category', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 10, category: 'cogs' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e2', flatAmount: 15, category: 'cogs' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e3', flatAmount: 5, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.totalOtherCogs).toBe(30);
+                expect(sumOfCategories).toBe(30);
+            });
+            it('should maintain identity with legacy category mappings', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'payment_fees' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 20, category: 'packaging' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 5, category: 'transaction' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 8, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(result.categoryCosts.otherTransactionCost).toBe(15);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(28);
+                expect(sumOfCategories).toBe(43);
+            });
+            it('should maintain identity with empty config', () => {
+                const configs = createConfigs({
+                    order: { entries: [] },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(0);
+            });
+            it('should maintain identity with null config', () => {
+                const result = CostCalculatorService.calculateOrderCosts(null, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBe(inputTotal);
+                expect(sumOfCategories).toBe(0);
+            });
+            it('should maintain identity with currency conversion', () => {
+                const exchangeRates = {
+                    USD: { EUR: 0.85, GBP: 0.73 },
+                    EUR: { USD: 1.18, GBP: 0.86 },
+                };
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs', currency: 'EUR' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 20, category: 'fulfillment', currency: 'GBP' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 15, category: 'marketing', currency: 'USD' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', exchangeRates);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.totalOtherCogs).toBeCloseTo(10 * 1.18, 5);
+                expect(result.categoryCosts.marketingCost).toBe(15);
+            });
+            it('should maintain identity with percentage-based entries', () => {
+                const context = createContext({
+                    totalProductCost: 100,
+                    totalShipping: 50,
+                    totalPrice: 200,
+                    grossSalePrice: 250,
+                    netSalePrice: 180,
+                });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, { percentRate: 10, category: 'cogs' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_SHIPPING, { percentRate: 20, category: 'fulfillment' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, { percentRate: 5, category: 'transaction' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, { percentRate: 8, category: 'marketing' }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, { percentRate: 3, category: 'opex' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                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: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                flatAmount: 0.5,
+                                weightUnit: WEIGHT_UNIT.KILOGRAMS,
+                                category: 'fulfillment',
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(0.75);
+            });
+            it('should maintain identity with weight-tiered entries', () => {
+                const context = createContext({ totalWeight: 750 });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                category: 'fulfillment',
+                                weightUnit: WEIGHT_UNIT.GRAMS,
+                                weightIntervals: [
+                                    { weightMin: 0, weightMax: 500, flatAmount: 5 },
+                                    { weightMin: 501, weightMax: 1000, flatAmount: 8 },
+                                    { weightMin: 1001, weightMax: null, flatAmount: 12 },
+                                ],
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(8);
+            });
+            it('should maintain identity with quantity-tiered entries', () => {
+                const context = createContext({
+                    lineItems: [
+                        createLineItem({ lineItemId: '1', quantity: 5 }),
+                        createLineItem({ lineItemId: '2', quantity: 15 }),
+                    ],
+                });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                                category: 'fulfillment',
+                                quantityIntervals: [
+                                    { quantityMin: 1, quantityMax: 10, flatAmount: 10 },
+                                    { quantityMin: 11, quantityMax: 50, flatAmount: 8 },
+                                    { quantityMin: 51, quantityMax: null, flatAmount: 5 },
+                                ],
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = sumCategoryCosts(result.categoryCosts);
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                expect(sumOfCategories).toBeCloseTo(inputTotal, 5);
+                expect(result.categoryCosts.otherFulfillmentCost).toBe(18);
+            });
+        });
+        describe('no double-counting between categories', () => {
+            it('should route each entry to exactly one category', () => {
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { id: 'e1', flatAmount: 100, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                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',
+                        quantity: 2,
+                        refundedQuantity: 1,
+                        filterContext: { tags: ['sale', 'premium'], productId: '100', variantId: '200', vendor: 'acme' },
+                    }),
+                ];
+                const context = createContext({
+                    lineItems,
+                    totalQuantity: 2,
+                    hasRefund: true,
+                    orderFilterContext: {
+                        tags: ['wholesale', 'vip'],
+                        paymentGateways: ['stripe', 'paypal'],
+                        shippingTitles: ['Express', 'Standard'],
+                    },
+                });
+                const configs = createConfigs({
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                flatAmount: 50,
+                                category: 'transaction',
+                                filters: {
+                                    orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['wholesale', 'vip'] },
+                                },
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                expect(result.categoryCosts.otherTransactionCost).toBe(50);
+                expect(result.orderLevelOtherCost + result.lineItemLevelOtherCost).toBe(50);
+            });
+        });
+        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 }),
+                ];
+                const configs = createConfigs({
+                    globalProductOverride: { globalHandlingFee: 2, currency: 'USD' },
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'cogs' }),
+                        ],
+                    },
+                });
+                const context = createContext({ lineItems, totalQuantity: 3 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = result.categoryCosts.totalOtherCogs +
+                    result.categoryCosts.otherFulfillmentCost +
+                    result.categoryCosts.otherTransactionCost +
+                    result.categoryCosts.marketingCost +
+                    result.categoryCosts.agencyFeesCost +
+                    result.categoryCosts.opexCost +
+                    result.categoryCosts.totalOtherCost;
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalHandlingCost).toBe(17);
+                expect(result.lineItemLevelHandlingCost).toBe(17);
+            });
+            it('should not include gateway costs in category cost sum', () => {
+                const configs = createConfigs({
+                    gateway: {
+                        entries: [
+                            { id: 'g1', name: 'Stripe', gatewayName: 'stripe', flatAmount: 0.30, percentRate: 2.9, currency: 'USD' },
+                        ],
+                    },
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'fulfillment' }),
+                        ],
+                    },
+                });
+                const context = createContext({ totalPrice: 100 });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', emptyRatesMap);
+                const sumOfCategories = result.categoryCosts.totalOtherCogs +
+                    result.categoryCosts.otherFulfillmentCost +
+                    result.categoryCosts.otherTransactionCost +
+                    result.categoryCosts.marketingCost +
+                    result.categoryCosts.agencyFeesCost +
+                    result.categoryCosts.opexCost +
+                    result.categoryCosts.totalOtherCost;
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalGatewayCost).toBe(3.2);
+            });
+            it('should not include shipping costs in category cost sum', () => {
+                const configs = createConfigs({
+                    shipping: {
+                        method: SHIPPING_METHOD.FIXED_RATE,
+                        fixedRateAmount: 15,
+                        currency: 'USD',
+                    },
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, { flatAmount: 10, category: 'marketing' }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, createContext(), 'USD', emptyRatesMap);
+                const sumOfCategories = result.categoryCosts.totalOtherCogs +
+                    result.categoryCosts.otherFulfillmentCost +
+                    result.categoryCosts.otherTransactionCost +
+                    result.categoryCosts.marketingCost +
+                    result.categoryCosts.agencyFeesCost +
+                    result.categoryCosts.opexCost +
+                    result.categoryCosts.totalOtherCost;
+                expect(sumOfCategories).toBe(10);
+                expect(result.totalShippingCost).toBe(15);
+            });
+        });
+        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.50,
+                        filterContext: { tags: ['electronics'], productId: '100', variantId: '200', vendor: 'Samsung' },
+                    }),
+                    createLineItem({
+                        lineItemId: 'li-2',
+                        quantity: 3,
+                        refundedQuantity: 1,
+                        variantHandlingFee: 0.75,
+                        filterContext: { tags: ['accessories'], productId: '101', variantId: '201', vendor: 'Generic' },
+                    }),
+                    createLineItem({
+                        lineItemId: 'li-3',
+                        quantity: 2,
+                        refundedQuantity: 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.00,
+                    grossSalePrice: 920.00,
+                    netSalePrice: 780.00,
+                    totalProductCost: 425.00,
+                    totalShipping: 25.00,
+                    totalWeight: 2500,
+                    totalQuantity: 10,
+                    hasRefund: true,
+                    orderFilterContext: {
+                        tags: ['online', 'marketing-campaign'],
+                        paymentGateways: ['stripe'],
+                        shippingTitles: ['Express Shipping'],
+                        shipCountryCode: 'US',
+                    },
+                    lineItems,
+                });
+                const exchangeRates = {
+                    USD: { EUR: 0.85, GBP: 0.73, CAD: 1.35 },
+                    EUR: { USD: 1.18 },
+                    GBP: { USD: 1.37 },
+                    CAD: { USD: 0.74 },
+                };
+                const configs = createConfigs({
+                    globalProductOverride: {
+                        globalHandlingFee: 0.50,
+                        currency: 'USD',
+                    },
+                    gateway: {
+                        entries: [
+                            {
+                                id: 'stripe',
+                                name: 'Stripe',
+                                gatewayName: 'stripe',
+                                flatAmount: 0.30,
+                                percentRate: 2.9,
+                                currency: 'USD',
+                            },
+                        ],
+                    },
+                    shipping: {
+                        method: SHIPPING_METHOD.SHIPPING_PROFILES,
+                        profiles: [
+                            {
+                                id: 'us-flat',
+                                name: 'US Flat Rate',
+                                countries: ['US'],
+                                isDefault: false,
+                                rateType: SHIPPING_RATE_TYPE.FLAT,
+                                flatAmount: 12.00,
+                                currency: 'USD',
+                            },
+                            {
+                                id: 'default',
+                                name: 'Default',
+                                countries: [],
+                                isDefault: true,
+                                rateType: SHIPPING_RATE_TYPE.WEIGHT_TIERED,
+                                weightUnit: WEIGHT_UNIT.KILOGRAMS,
+                                weightTiers: [
+                                    { weightMin: 0, weightMax: 1, flatAmount: 8 },
+                                    { weightMin: 1.001, weightMax: 5, flatAmount: 15 },
+                                    { weightMin: 5.001, weightMax: null, flatAmount: 25 },
+                                ],
+                                currency: 'USD',
+                            },
+                        ],
+                    },
+                    order: {
+                        entries: [
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                id: 'packaging-base',
+                                flatAmount: 2.00,
+                                category: 'cogs',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_COGS, {
+                                id: 'inventory-shrinkage',
+                                percentRate: 2,
+                                category: 'cogs',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM, {
+                                id: 'pick-pack',
+                                flatAmount: 0.75,
+                                category: 'fulfillment',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT, {
+                                id: 'packing-materials',
+                                flatAmount: 0.002,
+                                category: 'fulfillment',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES, {
+                                id: 'platform-fee',
+                                percentRate: 1.5,
+                                category: 'transaction',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES, {
+                                id: 'affiliate-commission',
+                                percentRate: 5,
+                                category: 'marketing',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_ORDER, {
+                                id: 'agency-retainer-allocation',
+                                flatAmount: 8.00,
+                                currency: 'EUR',
+                                category: 'agency_fees',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PCT_NET_SALES, {
+                                id: 'overhead-allocation',
+                                percentRate: 3,
+                                category: 'opex',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER, {
+                                id: 'refund-processing',
+                                flatAmount: 5.00,
+                                category: 'opex',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM, {
+                                id: 'restocking-fee',
+                                flatAmount: 3.00,
+                                category: 'other',
+                            }),
+                            createEntry(ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY, {
+                                id: 'misc-per-unit',
+                                quantityIntervals: [
+                                    { quantityMin: 1, quantityMax: 5, flatAmount: 2 },
+                                    { quantityMin: 6, quantityMax: 20, flatAmount: 1.5 },
+                                    { quantityMin: 21, quantityMax: null, flatAmount: 1 },
+                                ],
+                                category: 'other',
+                            }),
+                        ],
+                    },
+                });
+                const result = CostCalculatorService.calculateOrderCosts(configs, context, 'USD', exchangeRates);
+                const sumOfCategories = result.categoryCosts.totalOtherCogs +
+                    result.categoryCosts.otherFulfillmentCost +
+                    result.categoryCosts.otherTransactionCost +
+                    result.categoryCosts.marketingCost +
+                    result.categoryCosts.agencyFeesCost +
+                    result.categoryCosts.opexCost +
+                    result.categoryCosts.totalOtherCost;
+                const inputTotal = result.orderLevelOtherCost + result.lineItemLevelOtherCost;
+                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);
+            });
+        });
+    });
+});
+//# sourceMappingURL=cost-calculator-service.spec.js.map