dexbot 1.4.10 → 1.4.12

package/dist/modules/order/grid.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/grid.ts - Grid Engine
  *
@@ -94,67 +93,12 @@
  *
  * ===============================================================================
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateGapSlots = calculateGapSlots;
-exports.isGridBloated = isGridBloated;
-exports.isGridBloatGraceActive = isGridBloatGraceActive;
-exports.clearGridBloatFlag = clearGridBloatFlag;
-exports.getSizingContext = getSizingContext;
-exports._getSizingContext = _getSizingContext;
-exports.createOrderGrid = createOrderGrid;
-exports.loadGrid = loadGrid;
-exports.initializeGrid = initializeGrid;
-exports.recalculateGrid = recalculateGrid;
-exports.checkAndUpdateGridIfNeeded = checkAndUpdateGridIfNeeded;
-exports._recalculateGridOrderSizesFromBlockchain = _recalculateGridOrderSizesFromBlockchain;
-exports.updateGridFromBlockchainSnapshot = updateGridFromBlockchainSnapshot;
-exports.compareGrids = compareGrids;
-exports.monitorDivergence = monitorDivergence;
-exports.calculateCurrentSpread = calculateCurrentSpread;
-exports.checkSpreadCondition = checkSpreadCondition;
-exports.checkGridHealth = checkGridHealth;
-exports.checkWindowDust = checkWindowDust;
-exports.hasAnyDust = hasAnyDust;
-exports.getDustOrders = getDustOrders;
-exports.determineOrderSideByFunds = determineOrderSideByFunds;
-exports.prepareSpreadCorrectionOrders = prepareSpreadCorrectionOrders;
-const constants_1 = require("../constants");
-const { GRID_COMPARISON } = constants_1.GRID_LIMITS;
-const Format = __importStar(require("./format"));
-const asymmetric_bounds_1 = require("../../market_adapter/core/asymmetric_bounds");
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { ORDER_TYPES, ORDER_STATES, COW_ACTIONS, DEFAULT_CONFIG, GRID_LIMITS, TIMING, PIPELINE_TIMING, MARKET_ADAPTER, INCREMENT_BOUNDS } from '../constants.js';
+const { GRID_COMPARISON } = GRID_LIMITS;
+import * as Format from './format.js';
+import { resolveMaxAsymmetryFactor, applyAsymmetricBounds, } from '../../market_adapter/core/asymmetric_bounds.js';
 // FIX: Extract magic numbers to named constants for maintainability
 const GRID_CONSTANTS = {
     RMS_PERCENTAGE_SCALE: 100, // Convert RMS percentage threshold from percent to decimal
@@ -167,16 +111,16 @@ function _snapshotFundState(manager) {
         sellLocked: Number(manager.accountTotals?.sellLocked || 0),
     };
 }
-const math_1 = require("./utils/math");
-const order_1 = require("./utils/order");
-const system_1 = require("./utils/system");
-const withPoolRef_1 = require("./utils/withPoolRef");
-const market_adapter_whitelist_1 = require("../market_adapter_whitelist");
-const errors_1 = require("../utils/errors");
-function calculateGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride) {
-    return (0, math_1.calculateGapSlots)(incrementPercent, targetSpreadPercent, gridLimitsOverride ?? constants_1.GRID_LIMITS);
+import { floatToBlockchainInt, getPrecisionByOrderType, getPrecisionsForManager, calculateOrderCreationFees, calculateOrderSizes, calculateRotationOrderSizes, calculateAvailableFundsValue, calculateGridSideDivergenceMetric, getPrecisionSlack, getMinAbsoluteOrderSize, getSingleDustThreshold, getGridBestPrices, calculateSpreadFromOrders, allocateFundsByWeights, calculateGapSlots as _mathGapSlots, findPriceCollision, getBtsSide, getSellStartIdx, resolveGapBand, countGapBandSpread, adjustBudgetForBtsFees, } from './utils/math.js';
+import { filterOrdersByType, checkSizesBeforeMinimum, checkSizeThreshold, resolveConfiguredPriceBound, shouldFlagOutOfSpread, isOrderHealthy, isPhantomOrder, isSlotAvailable, isOrderOnChain, isOrderPlaced, hasOnChainId, isEmptyGridSlot, parseSlotIndex, calculateIdealBoundary, assignGridRoles, resolveOnChainRetypeType } from './utils/order.js';
+import { loadAmaCenterPrice, loadAmaCenterSnapshot, withBlockchainRetry } from './utils/system.js';
+import { derivePriceWithPoolRef } from './utils/withPoolRef.js';
+import { getWhitelistFlags } from '../market_adapter_whitelist.js';
+import { getErrorMessage } from '../utils/errors.js';
+export function calculateGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride) {
+    return _mathGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride ?? GRID_LIMITS);
 }
-function isGridBloated(manager, orders) {
+export function isGridBloated(manager, orders) {
     const gridSize = Array.isArray(orders) ? orders.length : orders.size;
     if (!gridSize || !manager?.config)
         return { bloated: false };
@@ -186,11 +130,11 @@ function isGridBloated(manager, orders) {
         return { bloated: false };
     const targetSpreadPct = config.targetSpreadPercent || incPct * 2;
     const orderList = Array.isArray(orders) ? orders : Array.from(orders.values());
-    const numBuyActive = orderList.filter((o) => o.type === constants_1.ORDER_TYPES.BUY &&
-        (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL) &&
+    const numBuyActive = orderList.filter((o) => o.type === ORDER_TYPES.BUY &&
+        (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL) &&
         o.orderId).length;
-    const numSellActive = orderList.filter((o) => o.type === constants_1.ORDER_TYPES.SELL &&
-        (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL) &&
+    const numSellActive = orderList.filter((o) => o.type === ORDER_TYPES.SELL &&
+        (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL) &&
         o.orderId).length;
     const placedCount = numBuyActive + numSellActive;
     if (!placedCount)
@@ -221,7 +165,7 @@ function isGridBloated(manager, orders) {
         }
     }
     const railEstimate = Math.max(expectedTotal, placedCount);
-    const buffer = (config.gridLimits?.MIN_SPREAD_ORDERS ?? constants_1.GRID_LIMITS.MIN_SPREAD_ORDERS);
+    const buffer = (config.gridLimits?.MIN_SPREAD_ORDERS ?? GRID_LIMITS.MIN_SPREAD_ORDERS);
     const maxAllowed = railEstimate + gapSlots + buffer;
     return {
         bloated: gridSize > maxAllowed,
@@ -241,8 +185,8 @@ function isGridBloated(manager, orders) {
  * @param {Object} manager - OrderManager instance.
  * @returns {{active: boolean, elapsed: number, graceMs: number}}
  */
-function isGridBloatGraceActive(manager) {
-    const graceMs = Number(constants_1.TIMING?.GRID_BLOAT_RESYNC_GRACE_MS) || constants_1.TIMING.GRID_BLOAT_RESYNC_GRACE_MS;
+export function isGridBloatGraceActive(manager) {
+    const graceMs = Number(TIMING?.GRID_BLOAT_RESYNC_GRACE_MS) || TIMING.GRID_BLOAT_RESYNC_GRACE_MS;
     if (!manager._gridBloatDetectedAt) {
         return { active: false, elapsed: 0, graceMs };
     }
@@ -254,7 +198,7 @@ function isGridBloatGraceActive(manager) {
  * returned to normal. Shared so both call sites use the same key.
  * @param {Object} manager - OrderManager instance.
  */
-function clearGridBloatFlag(manager) {
+export function clearGridBloatFlag(manager) {
     delete manager._gridBloatDetectedAt;
 }
 /**
@@ -265,7 +209,7 @@ function clearGridBloatFlag(manager) {
  * @param {'buy'|'sell'} side
  * @returns {Promise<import('./types').SizingContext|null>}
  */
-async function getSizingContext(manager, side) {
+export async function getSizingContext(manager, side) {
     return await _getSizingContext(manager, side);
 }
 /**
@@ -277,7 +221,7 @@ async function getSizingContext(manager, side) {
  * @returns {Promise<import('./types').SizingContext|null>}
  * @private
  */
-async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
+export async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
     if (!manager || !manager.assets)
         return null;
     // 1. Ensure fund state is fresh before sizing
@@ -286,7 +230,7 @@ async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
     }
     const snap = manager.getChainFundsSnapshot ? manager.getChainFundsSnapshot() : {};
     const isBuy = side === 'buy';
-    const type = isBuy ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+    const type = isBuy ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
     // 2. Determine base budget: Always use ALLOCATED funds (respects botFunds %)
     // This ensures the bot only "thinks" about the capital it is allowed to use.
     let budget = isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0);
@@ -297,15 +241,15 @@ async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
         const targetBuy = Math.max(0, manager.config.activeOrders?.buy ?? 1);
         const targetSell = Math.max(0, manager.config.activeOrders?.sell ?? 1);
         const totalTarget = targetBuy + targetSell;
-        const btsOrderType = (0, math_1.getBtsSide)(manager.config?.assetA, manager.config?.assetB);
-        const isBtsSide = isBuy ? (btsOrderType === constants_1.ORDER_TYPES.BUY) : (btsOrderType === constants_1.ORDER_TYPES.SELL);
-        const formulaBudget = (0, math_1.calculateOrderCreationFees)(manager.config.assetA, manager.config.assetB, totalTarget, manager.config?.feeParams?.BTS_RESERVATION_MULTIPLIER);
-        budget = (0, math_1.adjustBudgetForBtsFees)(budget, isBtsSide, formulaBudget, manager.config.min_BTS_value || 0, Format.toFiniteNumber(manager.funds?.btsBalance?.free, 0), Format.toFiniteNumber(isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0)), Format.toFiniteNumber(snap.allocatedBuy || 0)
+        const btsOrderType = getBtsSide(manager.config?.assetA, manager.config?.assetB);
+        const isBtsSide = isBuy ? (btsOrderType === ORDER_TYPES.BUY) : (btsOrderType === ORDER_TYPES.SELL);
+        const formulaBudget = calculateOrderCreationFees(manager.config.assetA, manager.config.assetB, totalTarget, manager.config?.feeParams?.BTS_RESERVATION_MULTIPLIER);
+        budget = adjustBudgetForBtsFees(budget, isBtsSide, formulaBudget, manager.config.min_BTS_value || 0, Format.toFiniteNumber(manager.funds?.btsBalance?.free, 0), Format.toFiniteNumber(isBuy ? (snap.allocatedBuy || 0) : (snap.allocatedSell || 0)), Format.toFiniteNumber(snap.allocatedBuy || 0)
             + Format.toFiniteNumber(snap.allocatedSell || 0));
     }
     return {
         budget,
-        precision: (0, math_1.getPrecisionByOrderType)(manager.assets, type),
+        precision: getPrecisionByOrderType(manager.assets, type),
         config: manager.config
     };
 }
@@ -358,7 +302,7 @@ async function _getSizingContext(manager, side, { skipRecalc = false } = {}) {
  * @param {import('./types').GridConfig} config - Grid configuration
  * @returns {import('./types').GridCreationResult}
  */
-function createOrderGrid(config) {
+export function createOrderGrid(config) {
     const { startPrice, minPrice, maxPrice, incrementPercent } = config;
     // FIX: Add comprehensive input validation to prevent silent grid creation failures
     if (!Number.isFinite(startPrice)) {
@@ -388,7 +332,7 @@ function createOrderGrid(config) {
     // Fall back to the canonical INCREMENT_BOUNDS when the config omits
     // incrementBounds. Without this, a non-positive incrementPercent (e.g. 0)
     // silently passes validation and the geometric loop below spins forever.
-    const incrementBounds = config.incrementBounds || constants_1.INCREMENT_BOUNDS;
+    const incrementBounds = config.incrementBounds || INCREMENT_BOUNDS;
     const minPercent = incrementBounds.MIN_PERCENT;
     const maxPercent = incrementBounds.MAX_PERCENT;
     if (incrementPercent <= 0 || incrementPercent < minPercent || incrementPercent > maxPercent) {
@@ -439,7 +383,7 @@ function createOrderGrid(config) {
     // Determine the boundary and assign roles (BUY/SPREAD/SELL) to each slot.
     //
     // STRATEGY: Center the spread gap around startPrice
-    const boundaryIdx = (0, order_1.calculateIdealBoundary)(priceLevels.map((p) => ({ price: p })), startPrice, gapSlots);
+    const boundaryIdx = calculateIdealBoundary(priceLevels.map((p) => ({ price: p })), startPrice, gapSlots);
     // ================================================================================
     // STEP 4: CREATE ORDER OBJECTS
     // ================================================================================
@@ -448,12 +392,12 @@ function createOrderGrid(config) {
         id: `slot-${i}`,
         price,
         type: null, // assigned below
-        state: constants_1.ORDER_STATES.VIRTUAL,
+        state: ORDER_STATES.VIRTUAL,
         size: 0
     }));
-    const updatedOrders = (0, order_1.assignGridRoles)(orders, boundaryIdx, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES);
-    const buyCount = updatedOrders.filter((o) => o.type === constants_1.ORDER_TYPES.BUY).length;
-    const sellCount = updatedOrders.filter((o) => o.type === constants_1.ORDER_TYPES.SELL).length;
+    const updatedOrders = assignGridRoles(orders, boundaryIdx, gapSlots, ORDER_TYPES, ORDER_STATES);
+    const buyCount = updatedOrders.filter((o) => o.type === ORDER_TYPES.BUY).length;
+    const sellCount = updatedOrders.filter((o) => o.type === ORDER_TYPES.SELL).length;
     if (buyCount === 0 || sellCount === 0) {
         throw new Error(`Grid generation produced an imbalanced rail (buy=${buyCount}, sell=${sellCount}) for ` +
             `startPrice=${startPrice}, bounds=[${minPrice}, ${maxPrice}], incrementPercent=${incrementPercent}, ` +
@@ -503,15 +447,15 @@ function _clearOrderCachesLogic(manager) {
  * @param {number|null} [boundaryIdx=null] - The master boundary index.
  * @returns {Promise<void>}
  */
-async function loadGrid(manager, grid, boundaryIdx = null) {
+export async function loadGrid(manager, grid, boundaryIdx = null) {
     if (!Array.isArray(grid))
         return;
     return await manager._gridLock.acquire(async () => {
         try {
-            await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
+            await withBlockchainRetry(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
         }
         catch (e) {
-            manager.logger?.log?.(`Asset initialization failed during grid load: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+            manager.logger?.log?.(`Asset initialization failed during grid load: ${getErrorMessage(e)}`, 'warn');
         }
         // RC-2: Use logic helper
         _clearOrderCachesLogic(manager);
@@ -540,14 +484,14 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             const gapSlots = calculateGapSlots(manager.config?.incrementPercent, manager.config?.targetSpreadPercent, manager.config?.gridLimits);
             manager._gapSlots = gapSlots;
             const buyEndIdx = boundaryIdx;
-            const sellStartIdx = (0, math_1.getSellStartIdx)(boundaryIdx, gapSlots);
+            const sellStartIdx = getSellStartIdx(boundaryIdx, gapSlots);
             let reassignCount = 0;
             grid = grid.map((slot, i) => {
                 const correctType = (i <= buyEndIdx)
-                    ? constants_1.ORDER_TYPES.BUY
+                    ? ORDER_TYPES.BUY
                     : (i >= sellStartIdx)
-                        ? constants_1.ORDER_TYPES.SELL
-                        : constants_1.ORDER_TYPES.SPREAD;
+                        ? ORDER_TYPES.SELL
+                        : ORDER_TYPES.SPREAD;
                 // DEFENSIVE BACKSTOP: a VIRTUAL slot with no orderId and
                 // zero size is side-neutral — it is a reusable placeholder
                 // that may be activated on either rail.  Storing a stale
@@ -562,10 +506,10 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                 // boundary-shift and strategy re-plan paths use
                 // assignGridRoles (order.ts) with assignOnChain, where
                 // geometry-based typing wins.
-                if ((0, order_1.isEmptyGridSlot)(slot, slot, { allowNullType: true })) {
-                    if (slot.type !== constants_1.ORDER_TYPES.SPREAD)
+                if (isEmptyGridSlot(slot, slot, { allowNullType: true })) {
+                    if (slot.type !== ORDER_TYPES.SPREAD)
                         reassignCount++;
-                    return { ...slot, type: constants_1.ORDER_TYPES.SPREAD };
+                    return { ...slot, type: ORDER_TYPES.SPREAD };
                 }
                 if (slot.type !== correctType) {
                     let newType = correctType;
@@ -583,8 +527,8 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                     // to a number by initializeGrid), which makes every
                     // comparison false and wrongly resolves below-center
                     // slots to SELL.
-                    if (newType === constants_1.ORDER_TYPES.SPREAD && (0, order_1.isOrderOnChain)(slot)) {
-                        newType = (0, order_1.resolveOnChainRetypeType)(slot, i, buyEndIdx, constants_1.ORDER_TYPES);
+                    if (newType === ORDER_TYPES.SPREAD && isOrderOnChain(slot)) {
+                        newType = resolveOnChainRetypeType(slot, i, buyEndIdx, ORDER_TYPES);
                     }
                     reassignCount++;
                     return { ...slot, type: newType };
@@ -612,7 +556,7 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
                 manager._gridBloatDetectedAt = Date.now();
                 if (typeof manager.requestStructuralGridResync === 'function') {
                     manager.requestStructuralGridResync('grid-bloat-detected', { reason: `Grid size ${d.gridSize} exceeds maximum ${d.maxAllowed}` }).catch((err) => {
-                        manager.logger?.log?.(`[GRID-BLOAT] Structural resync request failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        manager.logger?.log?.(`[GRID-BLOAT] Structural resync request failed: ${getErrorMessage(err)}`, 'error');
                     });
                 }
             }
@@ -623,9 +567,9 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             // RC-2: Use applyOrderUpdate (PRIVATE/UNLOCKED)
             for (const order of grid) {
                 let currentOrder = order;
-                if ((0, order_1.isPhantomOrder)(order)) {
+                if (isPhantomOrder(order)) {
                     manager.logger?.log?.(`Sanitizing corrupted order ${order.id}: ACTIVE/PARTIAL without orderId -> VIRTUAL`, 'warn');
-                    currentOrder = { ...order, state: constants_1.ORDER_STATES.VIRTUAL };
+                    currentOrder = { ...order, state: ORDER_STATES.VIRTUAL };
                 }
                 await manager._applyOrderUpdate(currentOrder, 'grid-load', { skipAccounting: true });
             }
@@ -638,8 +582,8 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
             // at creation) so the count is order-independent, matching the
             // accountant (accounting.ts).  Fall back to array position only
             // for ids that are not grid slot ids.
-            const spreadCount = (0, math_1.countGapBandSpread)(manager, grid, (o, i) => {
-                const idx = (0, order_1.parseSlotIndex)(o?.id);
+            const spreadCount = countGapBandSpread(manager, grid, (o, i) => {
+                const idx = parseSlotIndex(o?.id);
                 return idx === null ? i : idx;
             });
             manager.initialSpreadCount = spreadCount;
@@ -652,20 +596,29 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
         manager.logger?.log?.(`Loaded ${manager.orders.size} orders from persisted grid.`, 'info');
     });
 }
+function resolveMinScaleSlots(primary, secondary) {
+    const p = Number(primary);
+    if (Number.isFinite(p))
+        return Math.max(0, Math.floor(p));
+    const s = Number(secondary);
+    if (Number.isFinite(s))
+        return Math.max(0, Math.floor(s));
+    return MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MIN_SCALE_SLOTS;
+}
 /**
- * Initialize the order grid with blockchain-aware sizing.
- * @param {import('./types').OrderManager} manager - The manager instance.
- * @returns {Promise<void>}
- * @throws {Error} If initialization fails or account totals are missing.
- */
-async function initializeGrid(manager) {
+     * Initialize and orchestrate the order grid.
+     *
+     * @return {Promise<void>}
+     * @throws {Error} If initialization fails or account totals are missing.
+     */
+export async function initializeGrid(manager) {
     if (!manager)
         throw new Error('initializeGrid requires a manager instance');
     try {
-        await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
+        await withBlockchainRetry(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
     }
     catch (e) {
-        manager.logger?.log?.(`Asset initialization failed during grid init: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+        manager.logger?.log?.(`Asset initialization failed during grid init: ${getErrorMessage(e)}`, 'warn');
     }
     // FIX: Add explicit state validation to prevent cryptic errors later
     if (!manager.assets || !manager.assets.assetA || !manager.assets.assetB) {
@@ -680,7 +633,7 @@ async function initializeGrid(manager) {
     if (typeof mpRaw !== 'number' || isNaN(mpRaw)) {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await (0, withPoolRef_1.derivePriceWithPoolRef)(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto', manager.config.poolRef);
+            const derived = await derivePriceWithPoolRef(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto', manager.config.poolRef);
             if (derived) {
                 manager.logger?.log?.(`[DIAGNOSTIC] initializeGrid: Derived new startPrice=${derived.toFixed(8)} (mode=${manager.config.priceMode || 'auto'})`, 'info');
                 manager.config.startPrice = Number(derived);
@@ -690,7 +643,7 @@ async function initializeGrid(manager) {
             }
         }
         catch (err) {
-            manager.logger?.log?.(`Failed to derive market price: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+            manager.logger?.log?.(`Failed to derive market price: ${getErrorMessage(err)}`, 'warn');
             throw err; // Re-throw to prevent "pool" string reaching numeric math
         }
     }
@@ -706,7 +659,7 @@ async function initializeGrid(manager) {
     let gp = mp;
     let gpSource = 'startPrice';
     let amaSnapshot = null;
-    const whitelistFlags = (0, market_adapter_whitelist_1.getWhitelistFlags)(manager.config.botKey);
+    const whitelistFlags = getWhitelistFlags(manager.config.botKey);
     const isGridRangeScalingWhitelisted = whitelistFlags.asymmetricBounds === true;
     let gridPriceOffsetPct = 0;
     const gpRaw = manager.config.gridPrice;
@@ -719,7 +672,7 @@ async function initializeGrid(manager) {
     else if (gpMode === 'pool' || gpMode === 'book') {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await (0, withPoolRef_1.derivePriceWithPoolRef)(BitShares, manager.config.assetA, manager.config.assetB, gpMode, manager.config.poolRef);
+            const derived = await derivePriceWithPoolRef(BitShares, manager.config.assetA, manager.config.assetB, gpMode, manager.config.poolRef);
             if (derived) {
                 gp = Number(derived);
                 gpSource = gpMode;
@@ -730,12 +683,12 @@ async function initializeGrid(manager) {
             }
         }
         catch (err) {
-            manager.logger?.log?.(`initializeGrid: ${gpMode} gridPrice derivation failed: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+            manager.logger?.log?.(`initializeGrid: ${gpMode} gridPrice derivation failed: ${getErrorMessage(err)}`, 'warn');
         }
     }
     else if (/^ama(?:[1-4])?$/.test(gpMode || '')) {
-        amaSnapshot = (0, system_1.loadAmaCenterSnapshot)(manager.config.botKey);
-        const amaCenter = amaSnapshot?.gridCenterPrice ?? (0, system_1.loadAmaCenterPrice)(manager.config.botKey);
+        amaSnapshot = loadAmaCenterSnapshot(manager.config.botKey);
+        const amaCenter = amaSnapshot?.gridCenterPrice ?? loadAmaCenterPrice(manager.config.botKey);
         if (Number.isFinite(amaCenter) && amaCenter > 0) {
             gp = amaCenter;
             gpSource = 'ama';
@@ -750,14 +703,16 @@ async function initializeGrid(manager) {
             manager.logger?.log?.(`initializeGrid: AMA center unavailable for gridPrice, falling back to startPrice`, 'warn');
         }
     }
-    const minP = (0, order_1.resolveConfiguredPriceBound)(manager.config.minPrice, constants_1.DEFAULT_CONFIG.minPrice, gp, 'min');
-    const maxP = (0, order_1.resolveConfiguredPriceBound)(manager.config.maxPrice, constants_1.DEFAULT_CONFIG.maxPrice, gp, 'max');
+    const minP = resolveConfiguredPriceBound(manager.config.minPrice, DEFAULT_CONFIG.minPrice, gp, 'min');
+    const maxP = resolveConfiguredPriceBound(manager.config.maxPrice, DEFAULT_CONFIG.maxPrice, gp, 'max');
     // Asymmetric bound adjustment: widen the bound in the AMA trend direction
     // and tighten the opposite side, giving the grid more room when the center
     // trails price. Uses slope data from the dynamicgrid.json snapshot.
     let resolvedMinP = minP;
     let resolvedMaxP = maxP;
     let rangeScalingFactor = null;
+    let appliedTrend = null;
+    let minScaleSlots = null;
     if (gpSource === 'ama' && Number.isFinite(minP) && Number.isFinite(maxP)
         && isGridRangeScalingWhitelisted) {
         const dw = amaSnapshot?.dynamicWeights;
@@ -768,8 +723,8 @@ async function initializeGrid(manager) {
             ? amaSnapshot.asymmetricBounds
             : null;
         if (dw) {
-            const maxAsymmetryFactor = (0, asymmetric_bounds_1.resolveMaxAsymmetryFactor)(manager.config.asymmetricBounds?.maxAsymmetryFactor, dw?.maxAsymmetryFactor, constants_1.MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR);
-            const adjustment = (0, asymmetric_bounds_1.applyAsymmetricBounds)({
+            const maxAsymmetryFactor = resolveMaxAsymmetryFactor(manager.config.asymmetricBounds?.maxAsymmetryFactor, dw?.maxAsymmetryFactor, MARKET_ADAPTER.ASYMMETRIC_BOUNDS_MAX_ASYMMETRY_FACTOR);
+            const adjustment = applyAsymmetricBounds({
                 centerPrice: gp,
                 minPrice: minP,
                 maxPrice: maxP,
@@ -782,6 +737,8 @@ async function initializeGrid(manager) {
                 resolvedMinP = adjustment.resolvedMinPrice;
                 resolvedMaxP = adjustment.resolvedMaxPrice;
                 rangeScalingFactor = Number(adjustment.appliedAsymmetryFactor);
+                appliedTrend = (dw?.trend === 'UP' || dw?.trend === 'DOWN') ? dw.trend : null;
+                minScaleSlots = resolveMinScaleSlots(manager.config.asymmetricBounds?.minScaleSlots, dw?.minScaleSlots);
                 manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${dw.trend} slopeOffset=${dw.slopeOffset.toFixed(4)} `
                     + `raw=${((adjustment.rawAsymmetryFactor ?? 0) * 100).toFixed(1)}% `
                     + `cap=${((maxAsymmetryFactor ?? 0) * 100).toFixed(0)}% `
@@ -803,6 +760,8 @@ async function initializeGrid(manager) {
                 resolvedMaxP = gp * ((maxP / gp) * (1 + asymmetry));
             }
             rangeScalingFactor = asymmetry;
+            appliedTrend = rootTrend;
+            minScaleSlots = resolveMinScaleSlots(manager.config.asymmetricBounds?.minScaleSlots, rootBounds.minScaleSlots);
             manager.logger?.log?.(`[BOUND-ASYMMETRY] trend=${rootTrend} `
                 + `asymmetry=${(asymmetry * 100).toFixed(1)}% `
                 + `(root-level) min ${(minP ?? 0).toFixed(8)}→${(resolvedMinP ?? 0).toFixed(8)} `
@@ -831,6 +790,35 @@ async function initializeGrid(manager) {
             gridStartPrice = clamped;
         }
     }
+    // Narrowing-side slot guard: range scaling tightens one bound toward the
+    // center. Without a floor this can collapse that side into a near-center
+    // sliver holding few or zero active orders. Guarantee at least
+    // minScaleSlots price levels remain between the grid center and the
+    // tightened bound (in multiples of incrementPercent). The widened side
+    // still extends freely.
+    if (appliedTrend && Number.isFinite(gridStartPrice) && gridStartPrice > 0) {
+        const inc = Number(manager.config.incrementPercent);
+        const mss = Number.isFinite(minScaleSlots) ? Math.floor(Number(minScaleSlots)) : 0;
+        if (Number.isFinite(inc) && inc > 0 && mss > 0) {
+            const stepMult = 1 + (inc / 100);
+            if (appliedTrend === 'DOWN' && resolvedMaxP != null) {
+                const keepAbove = gridStartPrice * Math.pow(stepMult, mss);
+                if (resolvedMaxP < keepAbove) {
+                    manager.logger?.log?.(`[BOUND-ASYMMETRY] narrowing-side guard: max ${resolvedMaxP.toFixed(8)} collapses ` +
+                        `${mss} levels; holding at ${keepAbove.toFixed(8)}`, 'info');
+                    resolvedMaxP = keepAbove;
+                }
+            }
+            else if (appliedTrend === 'UP' && resolvedMinP != null) {
+                const belowMin = gridStartPrice * Math.pow(1 - (inc / 100), mss);
+                if (resolvedMinP > belowMin) {
+                    manager.logger?.log?.(`[BOUND-ASYMMETRY] narrowing-side guard would pull min ${resolvedMinP.toFixed(8)} ` +
+                        `short of ${mss} levels; holding at ${belowMin.toFixed(8)}`, 'info');
+                    resolvedMinP = belowMin;
+                }
+            }
+        }
+    }
     manager.config.minPrice = resolvedMinP;
     manager.config.maxPrice = resolvedMaxP;
     manager._lastGridPricingContext = {
@@ -845,14 +833,14 @@ async function initializeGrid(manager) {
     // Ensure percentage-based funds are resolved before sizing
     try {
         if (manager.accountId && !manager.accountTotals) {
-            await manager.waitForAccountTotals(constants_1.TIMING.ACCOUNT_TOTALS_TIMEOUT_MS);
+            await manager.waitForAccountTotals(TIMING.ACCOUNT_TOTALS_TIMEOUT_MS);
         }
     }
     catch (e) {
-        manager.logger?.log?.(`Failed to load account totals: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+        manager.logger?.log?.(`Failed to load account totals: ${getErrorMessage(e)}`, 'warn');
         // FIX: Add error handling - cannot proceed with grid initialization without account totals
         // Continuing would create grid with 0 fund allocation, rendering it non-functional
-        throw new Error(`Cannot initialize grid without account totals: ${(0, errors_1.getErrorMessage)(e)}`);
+        throw new Error(`Cannot initialize grid without account totals: ${getErrorMessage(e)}`);
     }
     const { orders, boundaryIdx, initialSpreadCount, gapSlots } = createOrderGrid({
         ...manager.config,
@@ -871,13 +859,13 @@ async function initializeGrid(manager) {
                 manager.notifyBoundaryUpdate(boundaryIdx);
             }
             catch (err) {
-                manager.logger?.log?.(`Error notifying boundary update: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+                manager.logger?.log?.(`Error notifying boundary update: ${getErrorMessage(err)}`, 'warn');
             }
         }
     }
-    const minSellSize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.SELL, manager.assets);
-    const minBuySize = (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.BUY, manager.assets);
-    const { A: precA, B: precB } = (0, math_1.getPrecisionsForManager)(manager.assets);
+    const minSellSize = getMinAbsoluteOrderSize(ORDER_TYPES.SELL, manager.assets);
+    const minBuySize = getMinAbsoluteOrderSize(ORDER_TYPES.BUY, manager.assets);
+    const { A: precA, B: precB } = getPrecisionsForManager(manager.assets);
     // Use centralized sizing context for both sides.
     // Resolve funds once upfront so both contexts share the same snapshot,
     // avoiding a redundant recalculateFunds inside the second _getSizingContext call.
@@ -886,17 +874,17 @@ async function initializeGrid(manager) {
     const buyCtx = await _getSizingContext(manager, 'buy', { skipRecalc: true });
     if (!sellCtx || !buyCtx)
         throw new Error('Failed to retrieve sizing context for grid initialization');
-    let sizedOrders = (0, math_1.calculateOrderSizes)(orders, manager.config, sellCtx.budget, buyCtx.budget, minSellSize, minBuySize, precA, precB);
+    let sizedOrders = calculateOrderSizes(orders, manager.config, sellCtx.budget, buyCtx.budget, minSellSize, minBuySize, precA, precB);
     // Verification of sizes
-    const sells = (0, order_1.filterOrdersByType)(sizedOrders, constants_1.ORDER_TYPES.SELL).map((o) => Number(o.size || 0));
-    const buys = (0, order_1.filterOrdersByType)(sizedOrders, constants_1.ORDER_TYPES.BUY).map((o) => Number(o.size || 0));
-    if ((0, order_1.checkSizesBeforeMinimum)(sells, minSellSize, precA) || (0, order_1.checkSizesBeforeMinimum)(buys, minBuySize, precB)) {
+    const sells = filterOrdersByType(sizedOrders, ORDER_TYPES.SELL).map((o) => Number(o.size || 0));
+    const buys = filterOrdersByType(sizedOrders, ORDER_TYPES.BUY).map((o) => Number(o.size || 0));
+    if (checkSizesBeforeMinimum(sells, minSellSize, precA) || checkSizesBeforeMinimum(buys, minBuySize, precB)) {
         throw new Error('Calculated orders fall below minimum allowable size.');
     }
     // Check for warning if orders are near minimal size (regression fix)
-    const warningSellSize = minSellSize > 0 ? (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.SELL, manager.assets, 100) : 0;
-    const warningBuySize = minBuySize > 0 ? (0, math_1.getMinAbsoluteOrderSize)(constants_1.ORDER_TYPES.BUY, manager.assets, 100) : 0;
-    if ((0, order_1.checkSizeThreshold)(sells, warningSellSize, precA, false) || (0, order_1.checkSizeThreshold)(buys, warningBuySize, precB, false)) {
+    const warningSellSize = minSellSize > 0 ? getMinAbsoluteOrderSize(ORDER_TYPES.SELL, manager.assets, 100) : 0;
+    const warningBuySize = minBuySize > 0 ? getMinAbsoluteOrderSize(ORDER_TYPES.BUY, manager.assets, 100) : 0;
+    if (checkSizeThreshold(sells, warningSellSize, precA, false) || checkSizeThreshold(buys, warningBuySize, precB, false)) {
         manager.logger?.log?.("WARNING: Order grid contains orders near minimum size. To ensure the bot runs properly, consider increasing the funds of your bot.", "warn");
     }
     // RC-2: Wrap atomic changes in grid lock
@@ -941,13 +929,13 @@ async function initializeGrid(manager) {
  * @param {string} opts.privateKey - Private key.
  * @returns {Promise<void>}
  */
-async function recalculateGrid(manager, opts) {
+export async function recalculateGrid(manager, opts) {
     const { readOpenOrdersFn, chainOrders, account, privateKey } = opts;
     // Suppress invariant warnings during full resync
     manager.startBootstrap();
     // Total timeout across all steps — prevents indefinite hang even if
     // an individual withBlockchainRetry step pins the event loop.
-    const totalTimeoutMs = constants_1.PIPELINE_TIMING.TIMEOUT_MS * 2; // 10 min
+    const totalTimeoutMs = PIPELINE_TIMING.TIMEOUT_MS * 2; // 10 min
     let _resyncAborted = false;
     const work = (async () => {
         try {
@@ -956,24 +944,24 @@ async function recalculateGrid(manager, opts) {
                 return;
             // #1: Initialize assets with timeout + retry + node failover
             try {
-                await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
+                await withBlockchainRetry(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
             }
             catch (e) {
-                manager.logger?.log?.(`Asset initialization failed during resync: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+                manager.logger?.log?.(`Asset initialization failed during resync: ${getErrorMessage(e)}`, 'warn');
             }
             if (_resyncAborted)
                 return;
             // #2: Fetch account totals with timeout + retry + node failover
-            await (0, system_1.withBlockchainRetry)(() => manager.fetchAccountTotals(), 'fetchAccountTotals', { logger: manager.logger });
+            await withBlockchainRetry(() => manager.fetchAccountTotals(), 'fetchAccountTotals', { logger: manager.logger });
             if (_resyncAborted)
                 return;
             // #3: Read open orders with timeout + retry + node failover
-            const chainOpenOrders = await (0, system_1.withBlockchainRetry)(() => readOpenOrdersFn(), 'readOpenOrders', { logger: manager.logger });
+            const chainOpenOrders = await withBlockchainRetry(() => readOpenOrdersFn(), 'readOpenOrders', { logger: manager.logger });
             if (_resyncAborted)
                 return;
             if (!Array.isArray(chainOpenOrders))
                 return;
-            await (0, system_1.withBlockchainRetry)(() => manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true }), 'syncFromOpenOrders', { logger: manager.logger });
+            await withBlockchainRetry(() => manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true }), 'syncFromOpenOrders', { logger: manager.logger });
             if (_resyncAborted)
                 return;
             // resetFunds under _fundLock + snapshot; persistGrid outside lock to
@@ -1013,8 +1001,8 @@ async function recalculateGrid(manager, opts) {
                 await reconcileGridOrders({ manager, config: manager.config, account, privateKey, chainOrders, chainOpenOrders });
             }
             catch (err) {
-                manager.logger?.log?.(`Error during startup order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
-                throw new Error(`Grid recalculation failed during order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`);
+                manager.logger?.log?.(`Error during startup order reconciliation: ${getErrorMessage(err)}`, 'error');
+                throw new Error(`Grid recalculation failed during order reconciliation: ${getErrorMessage(err)}`);
             }
             if (_resyncAborted)
                 return;
@@ -1045,20 +1033,20 @@ async function recalculateGrid(manager, opts) {
  * @param {import('./types').OrderManager} manager - Manager instance with order state
  * @returns {import('./types').SideUpdateFlags}
  */
-function checkAndUpdateGridIfNeeded(manager) {
+export function checkAndUpdateGridIfNeeded(manager) {
     const threshold = manager.config?.gridLimits?.GRID_REGENERATION_PERCENTAGE;
     const chainSnap = manager.getChainFundsSnapshot();
     const gridBuy = Number(manager.funds?.total?.grid?.buy || 0);
     const gridSell = Number(manager.funds?.total?.grid?.sell || 0);
     const result = { buyUpdated: false, sellUpdated: false };
     const sides = [
-        { name: 'buy', grid: gridBuy, orderType: constants_1.ORDER_TYPES.BUY },
-        { name: 'sell', grid: gridSell, orderType: constants_1.ORDER_TYPES.SELL }
+        { name: 'buy', grid: gridBuy, orderType: ORDER_TYPES.BUY },
+        { name: 'sell', grid: gridSell, orderType: ORDER_TYPES.SELL }
     ];
     for (const s of sides) {
         if (s.grid <= 0)
             continue;
-        const availableFunds = (0, math_1.calculateAvailableFundsValue)(s.name, manager.accountTotals, manager.funds, manager.config.assetA, manager.config.assetB, manager.config.activeOrders, manager.config.min_BTS_value, manager.config.feeParams ?? null);
+        const availableFunds = calculateAvailableFundsValue(s.name, manager.accountTotals, manager.funds, manager.config.assetA, manager.config.assetB, manager.config.activeOrders, manager.config.min_BTS_value, manager.config.feeParams ?? null);
         // Denominator: side's allocated capital (or chain total fallback).
         const allocated = s.name === 'buy' ? chainSnap.allocatedBuy : chainSnap.allocatedSell;
         const denominator = (allocated > 0) ? allocated : (s.grid + availableFunds);
@@ -1128,16 +1116,16 @@ function checkAndUpdateGridIfNeeded(manager) {
  * @param {import('./types').OrderManager} manager - OrderManager instance
  * @param {string} orderType - ORDER_TYPES.BUY or ORDER_TYPES.SELL
  * @param {Object} [options] - Options object
- * @param {import('./working_grid')} [options.workingGrid] - Working grid for COW pattern
+ * @param {import('./working_grid.js')} [options.workingGrid] - Working grid for COW pattern
  * @returns {Promise<{actions: Array, changed: boolean}|undefined>} - COW result or undefined
  * @private
  */
-async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, options = {}) {
+export async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, options = {}) {
     if (!manager.assets)
         return options?.workingGrid ? { actions: [], changed: false } : undefined;
     const workingGrid = options?.workingGrid || null;
     const collectActions = !!workingGrid;
-    const isBuy = orderType === constants_1.ORDER_TYPES.BUY;
+    const isBuy = orderType === ORDER_TYPES.BUY;
     const sideName = isBuy ? 'buy' : 'sell';
     // Use centralized sizing context (respects botFunds % allocation)
     const ctx = await _getSizingContext(manager, sideName);
@@ -1173,7 +1161,7 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
     if (allSideSlots.length === 0)
         return collectActions ? { actions: [], changed: false } : undefined;
     // Calculate geometric sizes for the ENTIRE rail
-    const newSizes = (0, math_1.calculateRotationOrderSizes)(ctx.budget, 0, allSideSlots.length, orderType, manager.config, 0, ctx.precision);
+    const newSizes = calculateRotationOrderSizes(ctx.budget, 0, allSideSlots.length, orderType, manager.config, 0, ctx.precision);
     const actions = [];
     let changed = false;
     const freeKey = isBuy ? 'buyFree' : 'sellFree';
@@ -1192,7 +1180,7 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
             // NOTE: BTS update fees are paid from BTS balance (separate from asset balance),
             // so they don't affect this asset-side size cap. Fee budgets are tracked in
             // funds.btsFeesOwed and reserved separately via btsFeesReservation.
-            const isCommitted = (0, order_1.isOrderOnChain)(slot);
+            const isCommitted = isOrderOnChain(slot);
             if (isCommitted) {
                 const currentSize = Number(slot.size || 0);
                 const delta = newSize - currentSize;
@@ -1212,8 +1200,8 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
                 }
             }
             // Use integer comparison to avoid redundant updates from float noise
-            const currentSizeInt = (0, math_1.floatToBlockchainInt)(slot.size || 0, ctx.precision);
-            const newSizeInt = (0, math_1.floatToBlockchainInt)(newSize, ctx.precision);
+            const currentSizeInt = floatToBlockchainInt(slot.size || 0, ctx.precision);
+            const newSizeInt = floatToBlockchainInt(newSize, ctx.precision);
             if (slot.size === undefined || currentSizeInt !== newSizeInt) {
                 changed = true;
                 if (collectActions) {
@@ -1221,9 +1209,9 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
                         ...slot,
                         size: newSize
                     });
-                    if (isCommitted && (0, order_1.hasOnChainId)(slot)) {
+                    if (isCommitted && hasOnChainId(slot)) {
                         actions.push({
-                            type: constants_1.COW_ACTIONS.UPDATE,
+                            type: COW_ACTIONS.UPDATE,
                             id: slot.id,
                             orderId: slot.orderId,
                             newGridId: slot.id,
@@ -1269,9 +1257,9 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
  * @param {string} orderType - 'buy', 'sell', or 'both' - which sides to update
  * @param {boolean} [fromBlockchainTimer=false] - If true, skip refetch of account totals (already current)
  * @param {number|null} [overrideBoundaryIdx=null] - Optional override for boundary index
- * @returns {Promise<{actions: Array, workingGrid: import('./working_grid'), workingIndexes: Object, workingBoundary: number, hasWorkingChanges: boolean, aborted: boolean}|null>}
+ * @returns {Promise<{actions: Array, workingGrid: import('./working_grid.js'), workingIndexes: Object, workingBoundary: number, hasWorkingChanges: boolean, aborted: boolean}|null>}
  */
-async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fromBlockchainTimer = false, overrideBoundaryIdx = null) {
+export async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fromBlockchainTimer = false, overrideBoundaryIdx = null) {
     if (!fromBlockchainTimer && manager.config?.accountId) {
         await manager.fetchAccountTotals(manager.config.accountId);
     }
@@ -1297,7 +1285,7 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
         const allSlots = Array.from(workingGrid.values())
             .filter((s) => s.price != null)
             .sort((a, b) => a.price - b.price);
-        const updatedSlots = (0, order_1.assignGridRoles)(allSlots, newBoundary, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES, { assignOnChain: true });
+        const updatedSlots = assignGridRoles(allSlots, newBoundary, gapSlots, ORDER_TYPES, ORDER_STATES, { assignOnChain: true });
         for (const slot of updatedSlots) {
             workingGrid.set(slot.id, slot);
         }
@@ -1306,13 +1294,13 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
     // Calculate size updates for each side (via existing sizing function in COW mode).
     // _recalculateGridOrderSizesFromBlockchain reads types from the working grid when
     // one is passed, so boundary-crossing slots are now correctly classified.
-    if (orderType === constants_1.ORDER_TYPES.BUY || orderType === 'both') {
-        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.BUY, { workingGrid });
+    if (orderType === ORDER_TYPES.BUY || orderType === 'both') {
+        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, ORDER_TYPES.BUY, { workingGrid });
         allActions.push(...buyResult.actions);
         hasWorkingChanges = hasWorkingChanges || buyResult.changed;
     }
-    if (orderType === constants_1.ORDER_TYPES.SELL || orderType === 'both') {
-        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.SELL, { workingGrid });
+    if (orderType === ORDER_TYPES.SELL || orderType === 'both') {
+        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, ORDER_TYPES.SELL, { workingGrid });
         allActions.push(...sellResult.actions);
         hasWorkingChanges = hasWorkingChanges || sellResult.changed;
     }
@@ -1358,7 +1346,7 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
  * @param {import('./types').OrderManager|null} [manager=null] - Manager instance (for grid lock access)
  * @returns {Promise<import('./types').GridComparisonResult>}
  */
-async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
+export async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
     if (!Array.isArray(calculatedGrid) || !Array.isArray(persistedGrid)) {
         return { buy: { metric: 0, updated: false }, sell: { metric: 0, updated: false } };
     }
@@ -1381,14 +1369,14 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
     // they are instead handled by the available-funds ratio check or follow-up correction.
     // Must be sorted ASC for calculateRotationOrderSizes to match geometric weight distribution
     const filterForRms = (orders, type) => {
-        const result = Array.isArray(orders) ? orders.filter((o) => o && o.type === type && o.state === constants_1.ORDER_STATES.ACTIVE) : [];
+        const result = Array.isArray(orders) ? orders.filter((o) => o && o.type === type && o.state === ORDER_STATES.ACTIVE) : [];
         return result
             .sort((a, b) => (a.price ?? 0) - (b.price ?? 0));
     };
-    const calculatedBuys = filterForRms(calculatedSnap, constants_1.ORDER_TYPES.BUY);
-    const calculatedSells = filterForRms(calculatedSnap, constants_1.ORDER_TYPES.SELL);
-    const persistedBuys = filterForRms(persistedSnap, constants_1.ORDER_TYPES.BUY);
-    const persistedSells = filterForRms(persistedSnap, constants_1.ORDER_TYPES.SELL);
+    const calculatedBuys = filterForRms(calculatedSnap, ORDER_TYPES.BUY);
+    const calculatedSells = filterForRms(calculatedSnap, ORDER_TYPES.SELL);
+    const persistedBuys = filterForRms(persistedSnap, ORDER_TYPES.BUY);
+    const persistedSells = filterForRms(persistedSnap, ORDER_TYPES.SELL);
     // Calculate ideal sizes for each order based on current available budget.
     // The sizing context (which includes recalculateFunds) is resolved once per side up front
     // so both buy and sell metrics share a single fund snapshot. This avoids the previous
@@ -1411,7 +1399,7 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
             return activeOrders;
         // Calculate geometric ideals for the ENTIRE side (all slots)
         try {
-            const allIdealSizes = (0, math_1.calculateRotationOrderSizes)(ctx.budget, 0, sideSlots.length, type, manager.config, 0, ctx.precision);
+            const allIdealSizes = calculateRotationOrderSizes(ctx.budget, 0, sideSlots.length, type, manager.config, 0, ctx.precision);
             // Map Ideal sizes to IDs for quick lookup
             const idealMap = new Map();
             sideSlots.forEach((slot, i) => idealMap.set(slot.id, allIdealSizes[i]));
@@ -1433,11 +1421,11 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
     const sellCtx = needsSell
         ? await _getSizingContext(manager, 'sell', { skipRecalc: true })
         : null;
-    const buyIdeals = computeSideIdeals(calculatedBuys, constants_1.ORDER_TYPES.BUY, buyCtx);
-    const sellIdeals = computeSideIdeals(calculatedSells, constants_1.ORDER_TYPES.SELL, sellCtx);
+    const buyIdeals = computeSideIdeals(calculatedBuys, ORDER_TYPES.BUY, buyCtx);
+    const sellIdeals = computeSideIdeals(calculatedSells, ORDER_TYPES.SELL, sellCtx);
     // Calculate RMS divergence metric for each side
-    const buyMetric = (0, math_1.calculateGridSideDivergenceMetric)(buyIdeals, persistedBuys, 'buy');
-    const sellMetric = (0, math_1.calculateGridSideDivergenceMetric)(sellIdeals, persistedSells, 'sell');
+    const buyMetric = calculateGridSideDivergenceMetric(buyIdeals, persistedBuys, 'buy');
+    const sellMetric = calculateGridSideDivergenceMetric(sellIdeals, persistedSells, 'sell');
     // Check if metrics exceed threshold and flag sides for regeneration
     // Set RMS_PERCENTAGE to 0 to disable RMS divergence checks
     let buyUpdated = false, sellUpdated = false;
@@ -1447,14 +1435,14 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
             // RC-3: Use Set for automatic duplicate prevention
             if (!(manager._gridSidesUpdated instanceof Set))
                 manager._gridSidesUpdated = new Set();
-            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.BUY);
+            manager._gridSidesUpdated.add(ORDER_TYPES.BUY);
             buyUpdated = true;
         }
         if (sellMetric > limit) {
             // RC-3: Use Set for automatic duplicate prevention
             if (!(manager._gridSidesUpdated instanceof Set))
                 manager._gridSidesUpdated = new Set();
-            manager._gridSidesUpdated.add(constants_1.ORDER_TYPES.SELL);
+            manager._gridSidesUpdated.add(ORDER_TYPES.SELL);
             sellUpdated = true;
         }
     }
@@ -1473,7 +1461,7 @@ async function compareGrids(calculatedGrid, persistedGrid, manager = null) {
  * @param {Array<import('./types').GridOrderSlot>} persistedGrid - Current/persisted grid
  * @returns {Promise<import('./types').DivergenceResult>}
  */
-async function monitorDivergence(manager, calculatedGrid, persistedGrid) {
+export async function monitorDivergence(manager, calculatedGrid, persistedGrid) {
     // 1. Check ratio-based divergence (available funds vs allocated)
     const ratioResult = checkAndUpdateGridIfNeeded(manager);
     if (ratioResult.buyUpdated || ratioResult.sellUpdated) {
@@ -1505,12 +1493,12 @@ async function monitorDivergence(manager, calculatedGrid, persistedGrid) {
  */
 function _getOnChainOrders(manager) {
     const onChainBuys = [
-        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.ACTIVE),
-        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.PARTIAL)
+        ...manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.ACTIVE),
+        ...manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.PARTIAL)
     ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
     const onChainSells = [
-        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.ACTIVE),
-        ...manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.PARTIAL)
+        ...manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.ACTIVE),
+        ...manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.PARTIAL)
     ].filter((o) => o?.orderId && Number(o?.size || 0) > 0);
     return { onChainBuys, onChainSells };
 }
@@ -1519,9 +1507,9 @@ function _getOnChainOrders(manager) {
  * @param {import('./types').OrderManager} manager - The manager instance.
  * @returns {number} The calculated spread percentage.
  */
-function calculateCurrentSpread(manager) {
+export function calculateCurrentSpread(manager) {
     const { onChainBuys, onChainSells } = _getOnChainOrders(manager);
-    return (0, math_1.calculateSpreadFromOrders)(onChainBuys, onChainSells);
+    return calculateSpreadFromOrders(onChainBuys, onChainSells);
 }
 /**
  * Proactive spread correction check.
@@ -1546,7 +1534,7 @@ function calculateCurrentSpread(manager) {
  * @param {Function|null} [updateOrdersOnChainBatch=null] - Optional batch update function
  * @returns {Promise<import('./types').SpreadCheckResult>}
  */
-async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatch = null) {
+export async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatch = null) {
     // CRITICAL: Acquire corrections lock to serialize spread correction operations
     // This prevents concurrent fill processing from modifying funds while we're making decisions
     let correction = null;
@@ -1560,7 +1548,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
     // Mid between best bid and best ask is the most current price the bot has.
     // Falls back to config.startPrice when either side is empty (e.g. at startup).
     const { onChainBuys, onChainSells } = _getOnChainOrders(manager);
-    const { bestBuy, bestSell } = (0, math_1.getGridBestPrices)(onChainBuys, onChainSells);
+    const { bestBuy, bestSell } = getGridBestPrices(onChainBuys, onChainSells);
     const lastPrice = (bestBuy !== null && bestSell !== null)
         ? (bestBuy + bestSell) / 2
         : Number(manager.config.startPrice) || 0;
@@ -1578,18 +1566,18 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
         const currentSpread = calculateCurrentSpread(manager);
         // Nominal spread is the configured target spread percentage.
         // Keep this fixed: doubled-side flags are fill/replacement mechanics only.
-        const nominalSpread = manager.config.targetSpreadPercent ?? constants_1.DEFAULT_CONFIG.targetSpreadPercent;
+        const nominalSpread = manager.config.targetSpreadPercent ?? DEFAULT_CONFIG.targetSpreadPercent;
         // Fixed tolerance: 0.5 steps = half increment (tighter spread check).
         const toleranceSteps = 0.5;
-        const buyCount = manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.ACTIVE)
-            .concat(manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.BUY, constants_1.ORDER_STATES.PARTIAL))
+        const buyCount = manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.ACTIVE)
+            .concat(manager.getOrdersByTypeAndState(ORDER_TYPES.BUY, ORDER_STATES.PARTIAL))
             .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
             .length;
-        const sellCount = manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.ACTIVE)
-            .concat(manager.getOrdersByTypeAndState(constants_1.ORDER_TYPES.SELL, constants_1.ORDER_STATES.PARTIAL))
+        const sellCount = manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.ACTIVE)
+            .concat(manager.getOrdersByTypeAndState(ORDER_TYPES.SELL, ORDER_STATES.PARTIAL))
             .filter((o) => o?.orderId && Number(o?.size || 0) > 0)
             .length;
-        manager.outOfSpread = (0, order_1.shouldFlagOutOfSpread)(currentSpread, nominalSpread, toleranceSteps, buyCount, sellCount, manager.config.incrementPercent);
+        manager.outOfSpread = shouldFlagOutOfSpread(currentSpread, nominalSpread, toleranceSteps, buyCount, sellCount, manager.config.incrementPercent);
         if (manager.outOfSpread === 0)
             return false;
         // Check whether the empty side is caused by boundary-at-rail-edge.
@@ -1605,7 +1593,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
             const gapSlots = manager._gapSlots ?? calculateGapSlots(manager.config.incrementPercent, manager.config.targetSpreadPercent, manager.config.gridLimits);
             const railLen = allSlots.length;
             const buyEndIdx = manager.boundaryIdx;
-            const sellStartIdx = (0, math_1.getSellStartIdx)(manager.boundaryIdx, gapSlots);
+            const sellStartIdx = getSellStartIdx(manager.boundaryIdx, gapSlots);
             const buySideCount = Math.max(0, Math.min(railLen, buyEndIdx + 1));
             const sellSideCount = Math.max(0, railLen - sellStartIdx);
             // Structural resync: both sides have room but one is empty.
@@ -1619,7 +1607,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
                     `Requesting structural grid resync to re-center.`, 'warn');
                 if (typeof manager.requestStructuralGridResync === 'function') {
                     manager.requestStructuralGridResync('boundary-at-rail-edge', { reason: `Boundary ${manager.boundaryIdx} leaves ${buySideCount} buy / ${sellSideCount} sell slots` }).catch((err) => {
-                        manager.logger?.log?.(`[SPREAD] Structural resync request failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        manager.logger?.log?.(`[SPREAD] Structural resync request failed: ${getErrorMessage(err)}`, 'error');
                     });
                 }
             }
@@ -1639,7 +1627,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
         // STARVATION FALLBACK: If the selected side has no correctable slots (e.g.
         // all SPREAD slots already filled or misaligned), try the opposite side.
         if ((placeCount + updateCount) === 0) {
-            const oppositeSide = decision.side === constants_1.ORDER_TYPES.BUY ? constants_1.ORDER_TYPES.SELL : constants_1.ORDER_TYPES.BUY;
+            const oppositeSide = decision.side === ORDER_TYPES.BUY ? ORDER_TYPES.SELL : ORDER_TYPES.BUY;
             manager.logger?.log?.(`[SPREAD] Side ${decision.side} produced zero candidates; ` +
                 `trying opposite side ${oppositeSide}.`, 'debug');
             const oppositeCorrection = await prepareSpreadCorrectionOrders(manager, oppositeSide, manager.outOfSpread);
@@ -1657,7 +1645,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
         shouldApplyCorrection = await manager._gridLock.acquire(executeSpreadCheck);
     }
     catch (err) {
-        manager.logger?.log?.(`Error checking spread condition: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+        manager.logger?.log?.(`Error checking spread condition: ${getErrorMessage(err)}`, 'error');
         // Track failure in recovery state for external monitoring.
         // Do NOT throw — the startup runtime path lacks a try/catch and
         // a throw would crash startup. The error is symptom of a deeper
@@ -1688,7 +1676,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
             // Refresh lastPrice from current grid state — the grid may
             // have changed since function entry (TOCTOU).
             const freshOnChain = _getOnChainOrders(manager);
-            const freshBest = (0, math_1.getGridBestPrices)(freshOnChain.onChainBuys, freshOnChain.onChainSells);
+            const freshBest = getGridBestPrices(freshOnChain.onChainBuys, freshOnChain.onChainSells);
             const freshPrice = (freshBest.bestBuy !== null && freshBest.bestSell !== null)
                 ? (freshBest.bestBuy + freshBest.bestSell) / 2
                 : Number(manager.config.startPrice) || 0;
@@ -1722,7 +1710,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
             return { ordersPlaced: placed + updated, partialsMoved: updated };
         }
         catch (err) {
-            manager.logger?.log?.(`Error applying spread correction on-chain: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+            manager.logger?.log?.(`Error applying spread correction on-chain: ${getErrorMessage(err)}`, 'warn');
             return { ordersPlaced: 0, partialsMoved: 0 };
         }
     }
@@ -1741,7 +1729,7 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
  * @param {Function|null} [updateOrdersOnChainBatch=null] - Optional batch update function.
  * @returns {Promise<import('./types').DustCheckResult>}
  */
-async function checkGridHealth(manager, _updateOrdersOnChainBatch = null) {
+export async function checkGridHealth(manager, _updateOrdersOnChainBatch = null) {
     if (!manager)
         return { buyDust: false, sellDust: false, buyDustOrders: [], sellDustOrders: [] };
     // Skip health checks during bootstrap to prevent spamming warnings
@@ -1767,25 +1755,25 @@ async function checkGridHealth(manager, _updateOrdersOnChainBatch = null) {
  * the sibling active order already covers that price level.
  *
  * Returns boolean flags plus the actual dust order objects so callers can act
- * on individual orders (e.g. DUST_CANCEL_DELAY_SEC auto-cancel).
+ * on individual orders (dust is cancelled immediately on detection).
  *
  * @param {import('./types').OrderManager} manager
  * @returns {Promise<import('./types').DustCheckResult>}
  */
-async function checkWindowDust(manager) {
+export async function checkWindowDust(manager) {
     if (!manager)
         return { buyDust: false, sellDust: false, buyDustOrders: [], sellDustOrders: [] };
     const allOrders = Array.from(manager.orders.values());
     const isLiveOrder = (order) => order &&
         order.orderId &&
         order.price != null &&
-        (order.state === constants_1.ORDER_STATES.ACTIVE || order.state === constants_1.ORDER_STATES.PARTIAL);
+        (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL);
     // Identify top-of-window orders (closest to market per side).
     const topBuyOrder = allOrders
-        .filter((o) => o.type === constants_1.ORDER_TYPES.BUY && isLiveOrder(o))
+        .filter((o) => o.type === ORDER_TYPES.BUY && isLiveOrder(o))
         .sort((a, b) => b.price - a.price)[0];
     const topSellOrder = allOrders
-        .filter((o) => o.type === constants_1.ORDER_TYPES.SELL && isLiveOrder(o))
+        .filter((o) => o.type === ORDER_TYPES.SELL && isLiveOrder(o))
         .sort((a, b) => a.price - b.price)[0];
     // Check if an order has a duplicate price level — an active sibling at the
     // same price within tolerance. If so, cancelling won't create a grid gap.
@@ -1793,17 +1781,17 @@ async function checkWindowDust(manager) {
     // sibling, neither qualifies and the gap is left to the rebalancer.
     // Uses the LARGER size of the two orders for tolerance calculation to prevent
     // a tiny dust order from inflating the tolerance window.
-    const hasDuplicatePriceLevel = (order, assets) => (0, math_1.findPriceCollision)(allOrders, order.id, order.price, order.size, order.type, assets, (o) => o.type === order.type && o.state === constants_1.ORDER_STATES.ACTIVE && !!o.orderId && o.price != null) != null;
+    const hasDuplicatePriceLevel = (order, assets) => findPriceCollision(allOrders, order.id, order.price, order.size, order.type, assets, (o) => o.type === order.type && o.state === ORDER_STATES.ACTIVE && !!o.orderId && o.price != null) != null;
     const assets = manager.assets;
-    const allPartials = allOrders.filter((o) => isLiveOrder(o) && o.state === constants_1.ORDER_STATES.PARTIAL);
+    const allPartials = allOrders.filter((o) => isLiveOrder(o) && o.state === ORDER_STATES.PARTIAL);
     const isTopBuy = (o) => topBuyOrder && o.id === topBuyOrder.id;
     const isTopSell = (o) => topSellOrder && o.id === topSellOrder.id;
     // Safety filter: top-of-window partials always qualify; interior partials
     // only qualify if they have a duplicate price level (no gap risk).
-    const eligibleBuyPartials = allPartials.filter((o) => o.type === constants_1.ORDER_TYPES.BUY && (isTopBuy(o) || hasDuplicatePriceLevel(o, assets)));
-    const eligibleSellPartials = allPartials.filter((o) => o.type === constants_1.ORDER_TYPES.SELL && (isTopSell(o) || hasDuplicatePriceLevel(o, assets)));
-    const buyDustOrders = await _getDustOrders(manager, eligibleBuyPartials, constants_1.ORDER_TYPES.BUY);
-    const sellDustOrders = await _getDustOrders(manager, eligibleSellPartials, constants_1.ORDER_TYPES.SELL);
+    const eligibleBuyPartials = allPartials.filter((o) => o.type === ORDER_TYPES.BUY && (isTopBuy(o) || hasDuplicatePriceLevel(o, assets)));
+    const eligibleSellPartials = allPartials.filter((o) => o.type === ORDER_TYPES.SELL && (isTopSell(o) || hasDuplicatePriceLevel(o, assets)));
+    const buyDustOrders = await _getDustOrders(manager, eligibleBuyPartials, ORDER_TYPES.BUY);
+    const sellDustOrders = await _getDustOrders(manager, eligibleSellPartials, ORDER_TYPES.SELL);
     return {
         buyDust: buyDustOrders.length > 0,
         sellDust: sellDustOrders.length > 0,
@@ -1824,7 +1812,7 @@ async function checkWindowDust(manager) {
 async function _getDustOrders(manager, partials, type) {
     if (!partials || partials.length === 0)
         return [];
-    const side = type === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const side = type === ORDER_TYPES.BUY ? 'buy' : 'sell';
     const ctx = await _getSizingContext(manager, side);
     const dustThresholdPercent = manager.config?.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE;
     const sideSlots = Array.from(manager.orders.values())
@@ -1833,7 +1821,7 @@ async function _getDustOrders(manager, partials, type) {
     if (sideSlots.length === 0)
         return [];
     const idealSizes = ctx && ctx.budget > 0
-        ? (0, math_1.allocateFundsByWeights)(ctx.budget, sideSlots.length, manager.config.weightDistribution[side], manager.config.incrementPercent / 100, type === constants_1.ORDER_TYPES.BUY, 0, ctx.precision)
+        ? allocateFundsByWeights(ctx.budget, sideSlots.length, manager.config.weightDistribution[side], manager.config.incrementPercent / 100, type === ORDER_TYPES.BUY, 0, ctx.precision)
         : [];
     // When no budget is available, idealSizes becomes [] so every
     // partial's threshold collapses to 0 — no order qualifies as dust.
@@ -1844,7 +1832,7 @@ async function _getDustOrders(manager, partials, type) {
         if (idx === -1)
             return false;
         const threshold = idealSizes.length > idx && idealSizes[idx] > 0
-            ? (0, math_1.getSingleDustThreshold)(idealSizes[idx], dustThresholdPercent)
+            ? getSingleDustThreshold(idealSizes[idx], dustThresholdPercent)
             : 0;
         return p.size < threshold;
     });
@@ -1867,8 +1855,8 @@ async function _hasAnyDust(manager, partials, type) {
  * @param {'buy'|'sell'} side
  * @returns {Promise<boolean>}
  */
-async function hasAnyDust(manager, partials, side) {
-    const type = side === 'buy' ? constants_1.ORDER_TYPES.BUY : side === 'sell' ? constants_1.ORDER_TYPES.SELL : null;
+export async function hasAnyDust(manager, partials, side) {
+    const type = side === 'buy' ? ORDER_TYPES.BUY : side === 'sell' ? ORDER_TYPES.SELL : null;
     if (!type)
         return false;
     return await _hasAnyDust(manager, partials, type);
@@ -1881,8 +1869,8 @@ async function hasAnyDust(manager, partials, side) {
  * @param {'buy'|'sell'} side
  * @returns {Promise<Array<import('./types').GridOrderSlot>>}
  */
-async function getDustOrders(manager, partials, side) {
-    const type = side === 'buy' ? constants_1.ORDER_TYPES.BUY : side === 'sell' ? constants_1.ORDER_TYPES.SELL : null;
+export async function getDustOrders(manager, partials, side) {
+    const type = side === 'buy' ? ORDER_TYPES.BUY : side === 'sell' ? ORDER_TYPES.SELL : null;
     if (!type)
         return [];
     return await _getDustOrders(manager, partials, type);
@@ -1894,7 +1882,7 @@ async function getDustOrders(manager, partials, side) {
  *   normalize sell-side funds into buy-side units for a fair cross-asset comparison.
  * @returns {{ side: import('./types').OrderType|null, reason: string }} The side to correct on, or null if insufficient funds.
  */
-function determineOrderSideByFunds(manager, currentMarketPrice) {
+export function determineOrderSideByFunds(manager, currentMarketPrice) {
     const buyAvailable = Math.min(Number(manager.funds?.available?.buy || 0), Number(manager.accountTotals?.buyFree || 0));
     const sellAvailable = Math.min(Number(manager.funds?.available?.sell || 0), Number(manager.accountTotals?.sellFree || 0));
     // Need at least some funds on a side to justify correction
@@ -1916,13 +1904,13 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
         const sellInBuyUnits = (Number.isFinite(marketPrice) && marketPrice > 0)
             ? sellAvailable * marketPrice
             : sellAvailable;
-        side = buyAvailable >= sellInBuyUnits ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+        side = buyAvailable >= sellInBuyUnits ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
     }
     else if (buyViable) {
-        side = constants_1.ORDER_TYPES.BUY;
+        side = ORDER_TYPES.BUY;
     }
     else if (sellViable) {
-        side = constants_1.ORDER_TYPES.SELL;
+        side = ORDER_TYPES.SELL;
     }
     if (!side) {
         const committedBuy = Math.max(0, Number(manager.funds?.committed?.chain?.buy || 0));
@@ -1933,17 +1921,17 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
             if (hasValidPrice) {
                 const buyComparable = committedBuy;
                 const sellComparable = committedSell * marketPrice;
-                side = buyComparable >= sellComparable ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+                side = buyComparable >= sellComparable ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
             }
             else if (committedBuy > buyMinUnit && committedSell <= sellMinUnit) {
-                side = constants_1.ORDER_TYPES.BUY;
+                side = ORDER_TYPES.BUY;
             }
             else if (committedSell > sellMinUnit && committedBuy <= buyMinUnit) {
-                side = constants_1.ORDER_TYPES.SELL;
+                side = ORDER_TYPES.SELL;
             }
             else {
                 // Deterministic fallback when both sides hold inventory but market valuation is unavailable.
-                side = constants_1.ORDER_TYPES.BUY;
+                side = ORDER_TYPES.BUY;
             }
             manager.logger?.log?.(`Spread correction using redistribution fallback on ${side} ` +
                 `(free buy=${Format.formatAmount8(buyAvailable)}, free sell=${Format.formatAmount8(sellAvailable)}, ` +
@@ -1970,7 +1958,7 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
 // the band, so this cap only binds when the opposite rail is smaller than the
 // band — i.e. an empty opposite rail (cap 0) blocks promotion entirely.
 function _collectPromotableBoundarySlots(allSlotsByPrice, railType, buyEndIdx, sellStartIdx, quota) {
-    const isBuy = railType === constants_1.ORDER_TYPES.BUY;
+    const isBuy = railType === ORDER_TYPES.BUY;
     const maxIdx = allSlotsByPrice.length - 1;
     const maxPromotable = isBuy
         ? Math.max(0, maxIdx + 1 - sellStartIdx)
@@ -1980,7 +1968,7 @@ function _collectPromotableBoundarySlots(allSlotsByPrice, railType, buyEndIdx, s
     const step = isBuy ? 1 : -1;
     for (let idx = isBuy ? buyEndIdx + 1 : sellStartIdx - 1; promoted.length < promotionQuota && (isBuy ? idx < sellStartIdx : idx > buyEndIdx); idx += step) {
         const slot = allSlotsByPrice[idx];
-        if (!slot || !(0, order_1.isSlotAvailable)(slot))
+        if (!slot || !isSlotAvailable(slot))
             break;
         promoted.push(slot);
     }
@@ -1993,15 +1981,15 @@ function _collectPromotableBoundarySlots(allSlotsByPrice, railType, buyEndIdx, s
  * @returns {Promise<import('./types').SpreadCorrectionResult>}
  * @throws {Error} If preferredSide is invalid.
  */
-async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread = 0) {
+export async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread = 0) {
     // FIX: Validate preferredSide parameter to prevent silent logic errors
-    if (preferredSide !== constants_1.ORDER_TYPES.BUY && preferredSide !== constants_1.ORDER_TYPES.SELL) {
-        throw new Error(`Invalid preferredSide: ${preferredSide}. Must be '${constants_1.ORDER_TYPES.BUY}' or '${constants_1.ORDER_TYPES.SELL}'.`);
+    if (preferredSide !== ORDER_TYPES.BUY && preferredSide !== ORDER_TYPES.SELL) {
+        throw new Error(`Invalid preferredSide: ${preferredSide}. Must be '${ORDER_TYPES.BUY}' or '${ORDER_TYPES.SELL}'.`);
     }
     const ordersToPlace = [];
     const ordersToUpdate = [];
     const railType = preferredSide;
-    const sideName = railType === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const sideName = railType === ORDER_TYPES.BUY ? 'buy' : 'sell';
     const configuredMissingSlots = Number(outOfSpread || 0);
     const missingSlots = configuredMissingSlots > 0
         ? Math.floor(configuredMissingSlots)
@@ -2030,7 +2018,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     // spread correction cycle will re-classify with the updated committed value.
     // This prevents TOCTOU-style inconsistency where slot types are chosen
     // against a boundary that was never atomically committed to manager.orders.
-    const resolved = (0, math_1.resolveGapBand)(manager);
+    const resolved = resolveGapBand(manager);
     const gapSlots = resolved.gapSlots;
     const boundaryKnown = resolved.boundaryIdx !== null && resolved.sellStartIdx !== null;
     // NOTE: `?? 0` keeps the legacy classification fallback (boundary not
@@ -2039,22 +2027,22 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     // `boundaryKnown` below: deriving a new boundary from a fabricated 0 would
     // silently commit a boundary that was never real.
     const buyEndIdx = resolved.boundaryIdx ?? 0;
-    const sellStartIdx = resolved.sellStartIdx ?? (0, math_1.getSellStartIdx)(buyEndIdx, gapSlots);
+    const sellStartIdx = resolved.sellStartIdx ?? getSellStartIdx(buyEndIdx, gapSlots);
     const getSlotCorrectType = (slot) => {
         const idx = slotIndexMap.get(slot.id);
         if (idx === undefined)
             return slot.type;
         if (idx <= buyEndIdx)
-            return constants_1.ORDER_TYPES.BUY;
+            return ORDER_TYPES.BUY;
         if (idx >= sellStartIdx)
-            return constants_1.ORDER_TYPES.SELL;
-        return constants_1.ORDER_TYPES.SPREAD;
+            return ORDER_TYPES.SELL;
+        return ORDER_TYPES.SPREAD;
     };
     let edgePartial = null;
     const partials = allOrders
         .filter((o) => getSlotCorrectType(o) === railType
-        && o.state === constants_1.ORDER_STATES.PARTIAL)
-        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
+        && o.state === ORDER_STATES.PARTIAL)
+        .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
     if (partials.length > 0) {
         edgePartial = partials[0];
         manager.logger?.log?.(`[SPREAD-CORRECTION] Identified partial order at ${edgePartial.price} for update`, 'debug');
@@ -2064,10 +2052,10 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     // in the BUY or SELL zone is excluded — it would otherwise be placed on the
     // correction side at a price the grid already considers the opposite side.
     const typedSpreadCandidates = allOrders
-        .filter((o) => o.type === constants_1.ORDER_TYPES.SPREAD
-        && (0, order_1.isSlotAvailable)(o)
+        .filter((o) => o.type === ORDER_TYPES.SPREAD
+        && isSlotAvailable(o)
         && getSlotCorrectType(o) === railType)
-        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
+        .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
         .slice(0, missingSlots);
     // Secondary candidates: orphaned virtual slots that have lost their
     // order (e.g. stale-cleaned after a race condition during a crash).
@@ -2082,12 +2070,12 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     // NOT re-activated on the stale side — doing so would compound inventory
     // at prices where the bot already traded.
     const orphanedVirtualCandidates = allOrders
-        .filter((o) => (o.type === railType || o.type === constants_1.ORDER_TYPES.SPREAD)
-        && o.state === constants_1.ORDER_STATES.VIRTUAL
+        .filter((o) => (o.type === railType || o.type === ORDER_TYPES.SPREAD)
+        && o.state === ORDER_STATES.VIRTUAL
         && !o.orderId
         && Number(o.size || 0) === 0
         && getSlotCorrectType(o) === railType)
-        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
+        .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
         .slice(0, missingSlots);
     // If the funded rail is full, the spread itself may be stale: the
     // nearest empty slots are still in the gap band. Promote contiguous
@@ -2141,8 +2129,8 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
                 return false;
             // Resolve candidate size: if zero/missing, use minimum so tolerance
             // doesn't collapse to zero (calculatePriceTolerance returns null for size <= 0).
-            const cs = (c.size && c.size > 0) ? c.size : (0, math_1.getMinAbsoluteOrderSize)(railType, manager.assets);
-            return !(0, math_1.findPriceCollision)(allOrders, c.id, c.price, cs, railType, manager.assets, (o) => (0, order_1.isOrderPlaced)(o) && o.price != null);
+            const cs = (c.size && c.size > 0) ? c.size : getMinAbsoluteOrderSize(railType, manager.assets);
+            return !findPriceCollision(allOrders, c.id, c.price, cs, railType, manager.assets, (o) => isOrderPlaced(o) && o.price != null);
         });
         const filteredCount = preFilter - spreadCandidates.length;
         if (filteredCount > 0) {
@@ -2168,14 +2156,14 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     if (!ctx || ctx.budget <= 0 || syntheticSideSlots.length === 0) {
         return { ordersToPlace: [], ordersToUpdate: [] };
     }
-    const precisionEpsilon = (0, math_1.getPrecisionSlack)(ctx.precision, 1);
-    const idealSizes = (0, math_1.allocateFundsByWeights)(ctx.budget, syntheticSideSlots.length, manager.config.weightDistribution[sideName], manager.config.incrementPercent / 100, railType === constants_1.ORDER_TYPES.BUY, 0, ctx.precision);
+    const precisionEpsilon = getPrecisionSlack(ctx.precision, 1);
+    const idealSizes = allocateFundsByWeights(ctx.budget, syntheticSideSlots.length, manager.config.weightDistribution[sideName], manager.config.incrementPercent / 100, railType === ORDER_TYPES.BUY, 0, ctx.precision);
     const idealById = new Map();
     syntheticSideSlots.forEach((slot, idx) => {
         idealById.set(slot.id, Number(idealSizes[idx] || 0));
     });
     const availableFund = Math.max(0, Math.min(Number(manager.funds?.available?.[sideName] || 0), Number(sideName === 'buy' ? manager.accountTotals?.buyFree : manager.accountTotals?.sellFree) || 0));
-    const minAbsoluteSize = (0, math_1.getMinAbsoluteOrderSize)(railType, manager.assets);
+    const minAbsoluteSize = getMinAbsoluteOrderSize(railType, manager.assets);
     const prioritizedTargets = [];
     if (edgePartial && edgePartial.id) {
         const ideal = Number(idealById.get(edgePartial.id) || 0);
@@ -2211,9 +2199,9 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
     if (totalNeeded > availableFund + precisionEpsilon) {
         let shortfall = totalNeeded - availableFund;
         const donors = sideSlots
-            .filter((o) => (0, order_1.hasOnChainId)(o) && (o.state === constants_1.ORDER_STATES.ACTIVE || o.state === constants_1.ORDER_STATES.PARTIAL))
+            .filter((o) => hasOnChainId(o) && (o.state === ORDER_STATES.ACTIVE || o.state === ORDER_STATES.PARTIAL))
             .filter((o) => !edgePartial || o.id !== edgePartial.id)
-            .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price);
+            .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price);
         for (const donor of donors) {
             if (shortfall <= precisionEpsilon)
                 break;
@@ -2227,7 +2215,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
             const donorNext = donorCurrent - reduction;
             if (donorNext <= precisionEpsilon)
                 continue;
-            if (!(0, order_1.isOrderHealthy)(donorNext, railType, manager.assets, donorIdeal || donorNext))
+            if (!isOrderHealthy(donorNext, railType, manager.assets, donorIdeal || donorNext))
                 continue;
             redistributionUpdates.push({ partialOrder: { ...donor }, newSize: donorNext });
             recoveredBudget += reduction;
@@ -2244,7 +2232,7 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
         if (target.kind === 'partial-topup') {
             const topUp = Math.min(target.needed, remainingBudget);
             const newSize = target.current + topUp;
-            if (newSize > target.current + precisionEpsilon && (0, order_1.isOrderHealthy)(newSize, railType, manager.assets, target.ideal)) {
+            if (newSize > target.current + precisionEpsilon && isOrderHealthy(newSize, railType, manager.assets, target.ideal)) {
                 ordersToUpdate.push({ partialOrder: { ...target.order }, newSize });
                 remainingBudget -= topUp;
             }
@@ -2253,13 +2241,13 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
         const createSize = Math.min(target.ideal, remainingBudget);
         if (createSize <= precisionEpsilon)
             continue;
-        if (!(0, order_1.isOrderHealthy)(createSize, railType, manager.assets, target.ideal))
+        if (!isOrderHealthy(createSize, railType, manager.assets, target.ideal))
             continue;
         ordersToPlace.push({
             ...target.order,
             type: railType,
             size: createSize,
-            state: constants_1.ORDER_STATES.VIRTUAL
+            state: ORDER_STATES.VIRTUAL
         });
         remainingBudget -= createSize;
     }
@@ -2276,14 +2264,14 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide, outOfSpread
             const idx = slotIndexMap.get(id);
             if (idx === undefined)
                 continue;
-            const dist = railType === constants_1.ORDER_TYPES.BUY
+            const dist = railType === ORDER_TYPES.BUY
                 ? idx - buyEndIdx
                 : sellStartIdx - idx;
             if (dist > maxDist)
                 maxDist = dist;
         }
         if (maxDist > 0) {
-            boundaryIdx = railType === constants_1.ORDER_TYPES.BUY
+            boundaryIdx = railType === ORDER_TYPES.BUY
                 ? buyEndIdx + maxDist
                 : buyEndIdx - maxDist;
             const maxIdx = allSlotsByPrice.length - 1;