@jetta/blocks-allocator 0.2.0 → 0.2.1-1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.2.0",
+    "version": "0.2.1-1",
     "description": "Blocks wall allocation library",
     "main": "src/index.js",
     "exports": {
@@ -40,13 +40,14 @@
     "author": "",
     "license": "ISC",
     "dependencies": {
+        "@jetta/axle-load-calculator": "^0.4.1",
         "@jetta/empty-spaces-manager": "^0.1.1-0",
         "@jetta/item-amount-controller": "0.1.0-0",
         "@jetta/logger": "^2.0.1",
         "@jetta/lp-framework": "2.1.0-6",
         "@jetta/number-compare": "^3.0.2-4",
         "@jetta/stacking-constraints": "^1.1.0",
-        "@jetta/tie-ratio-block-creator-core": "1.2.2-3",
+        "@jetta/tie-ratio-block-creator-core": "1.2.2-5",
         "@jetta/z-intersected-block-creator": "^0.0.1-42",
         "@jettacargo/single-item-block-creator-core": "2.0.1-0",
         "@jettacargo/spiral-block-creator-core": "2.1.2",

package/src/Allocation_Attempt.js

@@ -22,12 +22,14 @@ class Allocation_Attempt
     #item_list
     #amount_controller
     #allocator
+    #transport
 
     constructor(input_state)
     {
         this.#item_list  = input_state.items_to_allocate
         this.#amount_controller  = new Item_Amount_Controller(input_state.items_to_allocate)
         this.#allocator          = new Block_Allocator()
+        this.#transport          = input_state.transport
     }
 
     /**
@@ -103,7 +105,8 @@ class Allocation_Attempt
             this.#item_list,
             block_amount_map,
             effective_item_list,
-            picking_continuity_seed
+            picking_continuity_seed,
+            this.#transport
         )
         this.#update_state(container, allocation_output)
         mark_trace_outcome(TRACE_CONTEXT.BLOCK_WALL_ALLOCATED)

package/src/Allocation_Optimization/Block_Allocator.js

@@ -19,7 +19,8 @@ class Block_Allocator
         item_list,
         block_amount_map,
         effective_item_list,
-        picking_continuity_seed
+        picking_continuity_seed,
+        transport
     )
     {
         this.#next_group_id = resolve_next_group_id(container, this.#next_group_id)
@@ -47,7 +48,8 @@ class Block_Allocator
             item_amount_map,
             container,
             picking_continuity_seed,
-            optimized_blocks.block_instance_item_queues
+            optimized_blocks.block_instance_item_queues,
+            transport
         )
 
         if (block_builder_output.allocated_item_list.length === 0)
@@ -85,7 +87,8 @@ class Block_Allocator
         item_amount_map,
         container,
         picking_continuity_seed,
-        block_instance_item_queues
+        block_instance_item_queues,
+        transport
     )
     {
         const block_builder_data = this.#create_blocks_builder_data(
@@ -94,7 +97,8 @@ class Block_Allocator
             item_list,
             item_amount_map,
             container,
-            picking_continuity_seed
+            picking_continuity_seed,
+            transport
         )
         block_builder_data.block_instance_item_queues = block_instance_item_queues ?? new Map()
         const block_builder        = new Block_Builder(block_builder_data)
@@ -109,7 +113,8 @@ class Block_Allocator
         item_list,
         item_amount_map,
         container,
-        picking_continuity_seed
+        picking_continuity_seed,
+        transport
     )
     {
         return {
@@ -119,7 +124,8 @@ class Block_Allocator
             item_amount_map: item_amount_map,
             container: container,
             picking_continuity_seed: picking_continuity_seed,
-            next_group_id: this.#next_group_id
+            next_group_id: this.#next_group_id,
+            transport: transport
         }
     }
 

package/src/Allocation_Optimization/block_builder/Block_Wall_Builder.js

@@ -12,6 +12,7 @@ const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
 const assert_tie_ratio_block_matches_orientation_below = require('./assert_tie_ratio_block_matches_orientation_below')
 const snap_elevated_block_wall_items = require('./snap_elevated_block_wall_items')
 const should_omit_block_group_id = require('./should_omit_block_group_id')
+const assert_layout_fits_axle_load = require('../item_consumption_heuristic/axle_load/assert_layout_fits_axle_load')
 const allocated_items_weight_sum = (item_list) => item_list.reduce((acc, item) => acc + item.get_weight(), 0)
 
 /**
@@ -124,7 +125,8 @@ function build_a_block(chosen_block, is_single_slot, state, wall_data, pending_w
         wall_data.allocated_blocks_amount,
         state.container_supported_weight,
         item_position,
-        state.last_chosen_item_id
+        state.last_chosen_item_id,
+        pending_wall_allocated_items
     )
     let realigned_item_list = item_in_block_list
     try
@@ -143,6 +145,11 @@ function build_a_block(chosen_block, is_single_slot, state, wall_data, pending_w
             state,
             pending_wall_allocated_items
         )
+        assert_layout_fits_axle_load(
+            wall_data,
+            pending_wall_allocated_items,
+            realigned_item_list
+        )
     }
     catch (error)
     {

package/src/Allocation_Optimization/block_builder/Blocks_Builder.js

@@ -15,11 +15,13 @@ module.exports = class Block_Builder
             container: block_builder_data.container,
             picking_continuity_seed: block_builder_data.picking_continuity_seed,
             block_instance_item_queues: block_builder_data.block_instance_item_queues ?? new Map(),
+            transport: block_builder_data.transport,
             heuristic: new Slots_Items_Assigner(
                 block_builder_data.space_to_allocate,
                 block_builder_data.item_list,
                 block_builder_data.item_amount_map.copy(),
-                block_builder_data.container
+                block_builder_data.container,
+                block_builder_data.transport
             ),
             allocated_blocks_amount: {},
             next_group_id: block_builder_data.next_group_id ?? 0

package/src/Allocation_Optimization/block_builder/Slot_Item_Assigner.js

@@ -9,7 +9,8 @@ module.exports = function assign_item_to_slots(
     allocated_blocks_amount,
     container_supported_weight,
     item_position,
-    picking_continuity_seed
+    picking_continuity_seed,
+    pending_wall_allocated_items
 )
 {
     try
@@ -18,7 +19,8 @@ module.exports = function assign_item_to_slots(
             block,
             container_supported_weight,
             item_position,
-            picking_continuity_seed
+            picking_continuity_seed,
+            pending_wall_allocated_items
         )
         return assigned_item_list
     }

package/src/Allocation_Optimization/item_consumption_heuristic/Item_Chooser.js

@@ -14,6 +14,7 @@ const {
     sort_stacking_slots_by_proximity
 } = require('./Stack_Slot_Calculator')
 const { order_items_by_capacity_bias } = require('./Capacity_Bias_Item_Order')
+const candidate_item_fits_axle_load = require('./axle_load/candidate_item_fits_axle_load')
 
 /**
  * Chooses an item from available items by distributing them into stacking slots by weight
@@ -50,10 +51,10 @@ function prefer_same_id(data)
     const allocation_item = item_list.find(item => item.get_id() === previous_chosen_item_id)
     if (allocation_item)
     {
-        const result = is_stacking_valid(container, allocation_item, item_position, data.block)
-        if (result.is_valid)
+        const accepted_item = try_accept_candidate(data, container, allocation_item, item_position)
+        if (accepted_item)
         {
-            return result.allocated_item
+            return accepted_item
         }
     }
 
@@ -83,10 +84,10 @@ function choose_item_with_heuristic(data)
         while (candidate_items.length > 0)
         {
             const allocation_item = get_item(candidate_items, qty_of_slots, container)
-            const result = is_stacking_valid(container, allocation_item, item_position, data.block)
-            if (result.is_valid)
+            const accepted_item = try_accept_candidate(data, container, allocation_item, item_position)
+            if (accepted_item)
             {
-                return result.allocated_item
+                return accepted_item
             }
 
             remove_item_from_candidate_list(candidate_items, allocation_item)
@@ -97,7 +98,14 @@ function choose_item_with_heuristic(data)
     throw new No_Suitable_Item_Exception(ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM, [slot_label])
 }
 
-function is_stacking_valid(container, allocation_item, item_position, block)
+/**
+ * @param {object} data
+ * @param {object} container
+ * @param {object} allocation_item
+ * @param {object} item_position
+ * @returns {object|undefined}
+ */
+function try_accept_candidate(data, container, allocation_item, item_position)
 {
     const allocated_item = new Allocated_Item(
         allocation_item,
@@ -105,19 +113,19 @@ function is_stacking_valid(container, allocation_item, item_position, block)
         item_position.y,
         item_position.z
     )
-    if (should_defer_loose_on_block_stacking_validation(block))
+    if (!candidate_item_fits_axle_load(data, allocated_item))
     {
-        return {
-            is_valid: true,
-            allocated_item
-        }
+        return undefined
     }
-    const is_valid = container.is_a_valid_stacking(allocated_item)
-
-    return {
-        is_valid,
-        allocated_item
+    if (should_defer_loose_on_block_stacking_validation(data.block))
+    {
+        return allocated_item
+    }
+    if (!container.is_a_valid_stacking(allocated_item))
+    {
+        return undefined
     }
+    return allocated_item
 }
 
 function should_defer_loose_on_block_stacking_validation(block)

package/src/Allocation_Optimization/item_consumption_heuristic/Slots_Items_Assigner.js

@@ -1,7 +1,7 @@
 const choose_item_for_slot = require('./Item_For_Slot_Chooser')
 const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
 const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
-const Allocated_Item = require('../../models/Allocated_Item')
+const assign_one_plan_slot = require('./assign_one_plan_slot')
 const { block_has_sufficient_shape_stock } = require('../block_builder/block_shape_stock')
 const { Logger } = require('@jetta/logger')
 const logger = new Logger('Item Consumption Heuristic')
@@ -26,6 +26,12 @@ function process_one_slot(data)
     return { allocated_item, next_weight }
 }
 
+function pending_items_for_slot(pending_wall_allocated_items, allocated_item_list, index)
+{
+    const filled_slots = allocated_item_list.slice(0, index).filter(Boolean)
+    return (pending_wall_allocated_items ?? []).concat(filled_slots)
+}
+
 /**
  * Assigns items to block slots using a consumption heuristic (slot order and stacking).
  */
@@ -35,18 +41,21 @@ class Item_Consumption_Heuristic
     #item_map = {}
     #item_amount_map
     #container
+    #transport
 
     /**
      * @param {object[]} item_list - Items available for allocation.
      * @param {object} item_amount_map - Tracks remaining amount per item.
      * @param {object} container - Target container.
+     * @param {object} [transport] - Transport holding the axle env template.
      */
-    constructor(empty_space, item_list, item_amount_map, container)
+    constructor(empty_space, item_list, item_amount_map, container, transport)
     {
         this.#empty_space = empty_space
         this.#item_map = build_item_map(item_list)
         this.#item_amount_map = item_amount_map
         this.#container = container
+        this.#transport = transport
     }
 
     /**
@@ -55,9 +64,16 @@ class Item_Consumption_Heuristic
      * @param {number} container_supported_weight - Supported weight for the layer.
      * @param {object} item_position - Base block position { x, y, z } before per-slot offsets (from space / block placement).
      * @param {string|undefined} picking_continuity_seed - Prior SKU id to prefer on the first slot.
+     * @param {object[]} [pending_wall_allocated_items] - Items already chosen in this wall.
      * @returns {object[]|undefined} Allocated items, or undefined if a non-rethrown error occurred.
      */
-    assign_items_to_slots(block, container_supported_weight, item_position, picking_continuity_seed)
+    assign_items_to_slots(
+        block,
+        container_supported_weight,
+        item_position,
+        picking_continuity_seed,
+        pending_wall_allocated_items
+    )
     {
         const slot_count = block.get_slot_list().length
         if (slot_count === 0)
@@ -76,7 +92,8 @@ class Item_Consumption_Heuristic
             block,
             Number(container_supported_weight),
             item_position,
-            picking_continuity_seed
+            picking_continuity_seed,
+            pending_wall_allocated_items
         )
     }
 
@@ -86,9 +103,16 @@ class Item_Consumption_Heuristic
      * @param {string[]} slot_item_ids - Item ids per slot (same order as ordered slots).
      * @param {number} container_supported_weight
      * @param {object} item_position
+     * @param {object[]} [pending_wall_allocated_items]
      * @returns {object[]}
      */
-    assign_items_from_plan(block, slot_item_ids, container_supported_weight, item_position)
+    assign_items_from_plan(
+        block,
+        slot_item_ids,
+        container_supported_weight,
+        item_position,
+        pending_wall_allocated_items
+    )
     {
         const slot_list = order_slots_by_y(block.get_slot_list())
         const allocated_item_list = []
@@ -97,31 +121,22 @@ class Item_Consumption_Heuristic
         {
             const slot = slot_list[index]
             const item_id = slot_item_ids[index]
-            const allocation_item = this.#item_map[item_id]
-            if (!allocation_item || allocation_item.get_amount() <= 0)
-            {
-                throw new No_Suitable_Item_Exception(
-                    ALLOCATOR_MESSAGE.LP_PLAN_ITEM_UNAVAILABLE,
-                    [String(item_id), slot.to_string()]
-                )
-            }
-
-            const current_item_position = this.#update_item_position(item_position, slot)
-            const allocated_item = new Allocated_Item(
-                allocation_item,
-                current_item_position.x,
-                current_item_position.y,
-                current_item_position.z
-            )
-
-            if (!this.#container.is_a_valid_stacking(allocated_item))
-            {
-                throw new No_Suitable_Item_Exception(
-                    ALLOCATOR_MESSAGE.LP_PLAN_ITEM_STACKING_FAILED,
-                    [String(item_id), slot.to_string()]
-                )
-            }
-
+            const allocated_item = assign_one_plan_slot({
+                item_id,
+                slot,
+                allocation_item: this.#item_map[item_id],
+                item_position: this.#update_item_position(item_position, slot),
+                container: this.#container,
+                axle_probe: {
+                    transport: this.#transport,
+                    container: this.#container,
+                    pending_axle_items: pending_items_for_slot(
+                        pending_wall_allocated_items,
+                        allocated_item_list,
+                        allocated_item_list.length
+                    )
+                }
+            })
             this.#item_amount_map.discount_single_item(allocated_item)
             allocated_item_list.push(allocated_item)
         }
@@ -139,7 +154,13 @@ class Item_Consumption_Heuristic
         }
     }
 
-    #assign_items_for_ordered_slots(block, initial_weight, starting_item_position, picking_continuity_seed)
+    #assign_items_for_ordered_slots(
+        block,
+        initial_weight,
+        starting_item_position,
+        picking_continuity_seed,
+        pending_wall_allocated_items
+    )
     {
         const slot_list = order_slots_by_y(block.get_slot_list())
         const allocated_item_list = new Array(slot_list.length)
@@ -162,7 +183,13 @@ class Item_Consumption_Heuristic
                 item_amount_map: provisional_amount_map,
                 previous_chosen_item_id,
                 qty_of_slots,
-                item_position: current_item_position
+                item_position: current_item_position,
+                transport: this.#transport,
+                pending_axle_items: pending_items_for_slot(
+                    pending_wall_allocated_items,
+                    allocated_item_list,
+                    index
+                )
             })
             allocated_item_list[index] = result.allocated_item
             current_weight = result.next_weight

package/src/Allocation_Optimization/item_consumption_heuristic/assign_one_plan_slot.js

@@ -0,0 +1,53 @@
+const Allocated_Item = require('../../models/Allocated_Item')
+const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
+const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
+const candidate_item_fits_axle_load = require('./axle_load/candidate_item_fits_axle_load')
+
+/**
+ * Places one LP-plan item onto a slot, validating stacking and axle load.
+ * @param {object} data
+ * @returns {object}
+ */
+function assign_one_plan_slot(data)
+{
+    const allocated_item = create_plan_allocated_item(data)
+    if (!data.container.is_a_valid_stacking(allocated_item))
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.LP_PLAN_ITEM_STACKING_FAILED,
+            [String(data.item_id), data.slot.to_string()]
+        )
+    }
+    if (!candidate_item_fits_axle_load(data.axle_probe, allocated_item))
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM,
+            [data.slot.to_string()]
+        )
+    }
+    return allocated_item
+}
+
+/**
+ * @param {object} data
+ * @returns {object}
+ */
+function create_plan_allocated_item(data)
+{
+    const allocation_item = data.allocation_item
+    if (!allocation_item || allocation_item.get_amount() <= 0)
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.LP_PLAN_ITEM_UNAVAILABLE,
+            [String(data.item_id), data.slot.to_string()]
+        )
+    }
+    return new Allocated_Item(
+        allocation_item,
+        data.item_position.x,
+        data.item_position.y,
+        data.item_position.z
+    )
+}
+
+module.exports = assign_one_plan_slot

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/assert_layout_fits_axle_load.js

@@ -0,0 +1,26 @@
+const No_Suitable_Item_Exception = require('../../block_builder/exceptions/No_Suitable_Item_Exception')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+const layout_fits_axle_load = require('./layout_fits_axle_load')
+
+/**
+ * Throws when the realigned block items would overload axles.
+ * @param {object} wall_data
+ * @param {object[]} pending_wall_allocated_items
+ * @param {object[]} realigned_item_list
+ * @returns {void}
+ */
+function assert_layout_fits_axle_load(wall_data, pending_wall_allocated_items, realigned_item_list)
+{
+    const extra_items = (pending_wall_allocated_items ?? []).concat(realigned_item_list)
+    const fits = layout_fits_axle_load({
+        transport: wall_data.transport,
+        container: wall_data.container,
+        extra_items
+    })
+    if (!fits)
+    {
+        throw new No_Suitable_Item_Exception(ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM)
+    }
+}
+
+module.exports = assert_layout_fits_axle_load

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/axle_load_exceeds_limit.js

@@ -0,0 +1,51 @@
+const { gt } = require('@jetta/number-compare')
+
+/**
+ * Whether any container axle row exceeds the folga-adjusted final max.
+ * @param {object} env - Calculator output env with containers[].pesoEixos.
+ * @param {number} folga_percent - Slack percent (10 means 110% of pesoMaxFinal).
+ * @returns {boolean}
+ */
+function axle_load_exceeds_limit(env, folga_percent)
+{
+    const axle_rows = collect_peso_eixos_rows(env)
+    for (const axle of axle_rows)
+    {
+        if (axle_row_exceeds_limit(axle, folga_percent))
+        {
+            return true
+        }
+    }
+    return false
+}
+
+/**
+ * @param {object} env
+ * @returns {object[]}
+ */
+function collect_peso_eixos_rows(env)
+{
+    const containers = env.containers ?? []
+    const rows = []
+    for (const container of containers)
+    {
+        const axle_list = container.pesoEixos ?? []
+        rows.push(...axle_list)
+    }
+    return rows
+}
+
+/**
+ * @param {object} axle
+ * @param {number} folga_percent
+ * @returns {boolean}
+ */
+function axle_row_exceeds_limit(axle, folga_percent)
+{
+    const loaded_kilograms = Number(axle.pesoCarregadoFinal ?? 0)
+    const max_kilograms = Number(axle.pesoMaxFinal ?? 0)
+    const limit_kilograms = max_kilograms * (1 + folga_percent / 100)
+    return gt(loaded_kilograms, limit_kilograms)
+}
+
+module.exports = axle_load_exceeds_limit

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/candidate_item_fits_axle_load.js

@@ -0,0 +1,19 @@
+const layout_fits_axle_load = require('./layout_fits_axle_load')
+
+/**
+ * Whether placing this allocated item on top of pending axle items stays within axle caps.
+ * @param {object} data - Chooser bag with transport, container, pending_axle_items.
+ * @param {object} allocated_item
+ * @returns {boolean}
+ */
+function candidate_item_fits_axle_load(data, allocated_item)
+{
+    const pending_axle_items = data.pending_axle_items ?? []
+    return layout_fits_axle_load({
+        transport: data.transport,
+        container: data.container,
+        extra_items: pending_axle_items.concat(allocated_item)
+    })
+}
+
+module.exports = candidate_item_fits_axle_load

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/clone_env_with_layout_items.js

@@ -0,0 +1,26 @@
+const clone = require('../../../tools/Clone')
+const map_allocated_item_to_axle_wire = require('./map_allocated_item_to_axle_wire')
+
+/**
+ * Deep-clones the axle env template and writes current plus extra items per container.
+ * @param {object} transport
+ * @param {object} current_container
+ * @param {object[]} extra_items - Pending wall, earlier slots, and candidate for current container.
+ * @returns {object}
+ */
+function clone_env_with_layout_items(transport, current_container, extra_items)
+{
+    const env = clone(transport.get_axle_env_template())
+    const extra_item_list = extra_items ?? []
+    for (const container_data of env.containers ?? [])
+    {
+        const sequence = Number(container_data.sequencia)
+        const live_container = transport.get_containers().get(sequence)
+        const committed_items = live_container?.get_allocated_items?.() ?? []
+        const pending_items = live_container === current_container ? extra_item_list : []
+        container_data.items = committed_items.concat(pending_items).map(map_allocated_item_to_axle_wire)
+    }
+    return env
+}
+
+module.exports = clone_env_with_layout_items

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/evaluate_layout_axle_load.js

@@ -0,0 +1,43 @@
+const { calculate_weight_on_axles_physics } = require('@jetta/axle-load-calculator')
+const { Logger } = require('@jetta/logger')
+const Cargo_Profile = require('../../../models/Cargo_Profile')
+const clone_env_with_layout_items = require('./clone_env_with_layout_items')
+const axle_load_exceeds_limit = require('./axle_load_exceeds_limit')
+
+const logger = new Logger('Axle Load Slot Gate')
+
+/**
+ * Runs axle physics for the current layout plus extra items on the active container.
+ * @param {object} data
+ * @param {object} data.transport
+ * @param {object} data.container
+ * @param {object[]} data.extra_items
+ * @returns {boolean} True when no axle exceeds the folga-adjusted cap.
+ */
+function evaluate_layout_axle_load(data)
+{
+    const env = clone_env_with_layout_items(data.transport, data.container, data.extra_items)
+    try
+    {
+        return layout_is_within_axle_limit(env)
+    }
+    catch (error)
+    {
+        logger.warn(`axle calculator rejected layout: ${error.message}`)
+        return false
+    }
+}
+
+/**
+ * @param {object} env
+ * @returns {boolean}
+ */
+function layout_is_within_axle_limit(env)
+{
+    const output = calculate_weight_on_axles_physics({ envs: [env] })
+    const calculated_env = output.envs[0]
+    const folga_percent = Cargo_Profile.axle_weight_gap_percent()
+    return axle_load_exceeds_limit(calculated_env, folga_percent) === false
+}
+
+module.exports = evaluate_layout_axle_load

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/layout_fits_axle_load.js

@@ -0,0 +1,35 @@
+const Cargo_Profile = require('../../../models/Cargo_Profile')
+const evaluate_layout_axle_load = require('./evaluate_layout_axle_load')
+
+/**
+ * Returns whether the layout may be committed under the optional axle slot gate.
+ * @param {object} data
+ * @param {object} [data.transport]
+ * @param {object} [data.container]
+ * @param {object[]} [data.extra_items]
+ * @returns {boolean}
+ */
+function layout_fits_axle_load(data)
+{
+    if (!Cargo_Profile.enable_axle_load_slot_gate())
+    {
+        return true
+    }
+    if (!env_has_axles(data.transport))
+    {
+        return true
+    }
+    return evaluate_layout_axle_load(data)
+}
+
+/**
+ * @param {object|undefined} transport
+ * @returns {boolean}
+ */
+function env_has_axles(transport)
+{
+    const env = transport?.get_axle_env_template?.()
+    return Array.isArray(env?.eixos) && env.eixos.length > 0
+}
+
+module.exports = layout_fits_axle_load

package/src/Allocation_Optimization/item_consumption_heuristic/axle_load/map_allocated_item_to_axle_wire.js

@@ -0,0 +1,21 @@
+/**
+ * Maps an allocated item to the ms-faixas axle-calculator item contract.
+ * Longitudinal chassis position is JSON `y` (allocator `z`).
+ * @param {object} allocated_item
+ * @returns {object}
+ */
+function map_allocated_item_to_axle_wire(allocated_item)
+{
+    return {
+        id: allocated_item.get_id(),
+        x: allocated_item.get_x(),
+        y: allocated_item.get_z(),
+        z: allocated_item.get_y(),
+        peso: allocated_item.get_weight(),
+        comprimento: allocated_item.get_length(),
+        largura: allocated_item.get_width(),
+        altura: allocated_item.get_height()
+    }
+}
+
+module.exports = map_allocated_item_to_axle_wire

package/src/Allocation_Optimization/tie_ratio/Same_Height_Tie_Ratio_Filter.js

@@ -0,0 +1,28 @@
+const Block_Filter_Interface = require('../../space_and_block_chooser/blocks_filters/Block_Filter_Interface')
+const Cargo_Profile = require('../../models/Cargo_Profile')
+const filter_out_mixed_height_tie_ratio = require('./filter_out_mixed_height_tie_ratio')
+const has_stocked_same_height_tie_ratio = require('./has_stocked_same_height_tie_ratio')
+
+/**
+ * Post-selection filter: prefer same-height tie-ratio over mixed-height when stock allows.
+ */
+module.exports = class Same_Height_Tie_Ratio_Filter extends Block_Filter_Interface
+{
+    static run(filter_data)
+    {
+        if (!Cargo_Profile.prefer_same_height_tie_ratio_slots())
+        {
+            return filter_data.block_list
+        }
+
+        if (!has_stocked_same_height_tie_ratio(
+            filter_data.block_list,
+            filter_data.item_list || []
+        ))
+        {
+            return filter_data.block_list
+        }
+
+        return filter_out_mixed_height_tie_ratio(filter_data.block_list)
+    }
+}

package/src/Allocation_Optimization/tie_ratio/filter_out_mixed_height_tie_ratio.js

@@ -0,0 +1,20 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+
+/**
+ * Drops mixed-height tie-ratio blocks; keeps same-height tie-ratio and non-tie-ratio.
+ * @param {Array<object>} block_list
+ * @returns {Array<object>}
+ */
+function filter_out_mixed_height_tie_ratio(block_list)
+{
+    return block_list.filter((block) =>
+    {
+        if (!is_tie_ratio_block(block))
+        {
+            return true
+        }
+        return block.is_slots_of_same_measure()
+    })
+}
+
+module.exports = filter_out_mixed_height_tie_ratio

package/src/Allocation_Optimization/tie_ratio/has_stocked_same_height_tie_ratio.js

@@ -0,0 +1,40 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+const max_tie_ratio_slot_count = require('./max_tie_ratio_slot_count')
+const tie_ratio_block_has_shape_stock = require('./tie_ratio_block_has_shape_stock')
+
+/**
+ * True when a same-height tie-ratio at the max slot count has enough shape stock.
+ * Smaller same-height partials must not hide larger mixed walls.
+ * @param {Array<object>} block_list
+ * @param {Array<object>} item_list
+ * @returns {boolean}
+ */
+function has_stocked_same_height_tie_ratio(block_list, item_list)
+{
+    const target_slot_count = max_tie_ratio_slot_count(block_list)
+
+    if (target_slot_count === 0)
+    {
+        return false
+    }
+
+    for (const block of block_list)
+    {
+        if (!is_tie_ratio_block(block) || !block.is_slots_of_same_measure())
+        {
+            continue
+        }
+        if (block.get_slot_list().length !== target_slot_count)
+        {
+            continue
+        }
+        if (tie_ratio_block_has_shape_stock(block, item_list))
+        {
+            return true
+        }
+    }
+
+    return false
+}
+
+module.exports = has_stocked_same_height_tie_ratio

package/src/Allocation_Optimization/tie_ratio/is_tie_ratio_block.js

@@ -0,0 +1,12 @@
+/**
+ * True when the block reports itself as a tie-ratio block.
+ * Probe objects without the method are not tie-ratio blocks.
+ * @param {object} block
+ * @returns {boolean}
+ */
+function is_tie_ratio_block(block)
+{
+    return typeof block.is_tie_ratio_block === 'function' && block.is_tie_ratio_block()
+}
+
+module.exports = is_tie_ratio_block

package/src/Allocation_Optimization/tie_ratio/max_tie_ratio_slot_count.js

@@ -0,0 +1,24 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+
+/**
+ * Returns the largest slot count among tie-ratio blocks in the list.
+ * @param {Array<object>} block_list
+ * @returns {number}
+ */
+function max_tie_ratio_slot_count(block_list)
+{
+    let maximum = 0
+
+    for (const block of block_list)
+    {
+        if (!is_tie_ratio_block(block))
+        {
+            continue
+        }
+        maximum = Math.max(maximum, block.get_slot_list().length)
+    }
+
+    return maximum
+}
+
+module.exports = max_tie_ratio_slot_count

package/src/Allocation_Optimization/tie_ratio/tie_ratio_block_has_shape_stock.js

@@ -0,0 +1,113 @@
+const { cube_map_function } = require('../../Blocks_Preparation/Cube_Map_Function')
+
+/**
+ * Builds required shape amounts from a block's slots.
+ * @param {object} block
+ * @returns {Map<string, number>}
+ */
+function build_required_shapes(block)
+{
+    const required_shapes = new Map()
+    for (const slot of block.get_slot_list())
+    {
+        const shape_hash = cube_map_function(slot)
+        required_shapes.set(shape_hash, (required_shapes.get(shape_hash) || 0) + 1)
+    }
+    return required_shapes
+}
+
+/**
+ * Builds available shape amounts (amount counted once per SKU per unique rotation hash).
+ * @param {Array<object>} item_list
+ * @returns {Map<string, number>}
+ */
+function build_available_shapes(item_list)
+{
+    const available_shapes = new Map()
+    for (const item of item_list)
+    {
+        const unique_shape_hashes = new Set()
+        for (const rotated_item of item.get_all_rotated_options())
+        {
+            unique_shape_hashes.add(cube_map_function(rotated_item))
+        }
+        const item_amount = item.get_amount()
+        for (const shape_hash of unique_shape_hashes)
+        {
+            available_shapes.set(
+                shape_hash,
+                (available_shapes.get(shape_hash) || 0) + item_amount
+            )
+        }
+    }
+    return available_shapes
+}
+
+/**
+ * Counts units that can form any required shape (once per SKU).
+ * @param {Map<string, number>} required_shapes
+ * @param {Array<object>} item_list
+ * @returns {number}
+ */
+function count_capable_item_amount(required_shapes, item_list)
+{
+    let capable_amount = 0
+
+    for (const item of item_list)
+    {
+        const amount = item.get_amount()
+        if (amount <= 0)
+        {
+            continue
+        }
+        const can_form = item.get_all_rotated_options().some((rotated_item) =>
+            required_shapes.has(cube_map_function(rotated_item)))
+        if (can_form)
+        {
+            capable_amount += amount
+        }
+    }
+
+    return capable_amount
+}
+
+/**
+ * True when remaining item_list stock can fill the block.
+ * Combines total capable units with per-shape availability so rotation
+ * double-counting cannot keep a stale same-height five-slot alive.
+ * @param {object} block
+ * @param {Array<object>} item_list
+ * @returns {boolean}
+ */
+function tie_ratio_block_has_shape_stock(block, item_list)
+{
+    const required_shapes = build_required_shapes(block)
+    if (required_shapes.size === 0)
+    {
+        return false
+    }
+
+    let total_required = 0
+    for (const required_amount of required_shapes.values())
+    {
+        total_required += required_amount
+    }
+
+    if (count_capable_item_amount(required_shapes, item_list) < total_required)
+    {
+        return false
+    }
+
+    const available_shapes = build_available_shapes(item_list)
+    for (const [shape_hash, required_amount] of required_shapes)
+    {
+        if ((available_shapes.get(shape_hash) || 0) < required_amount)
+        {
+            return false
+        }
+    }
+
+    return true
+}
+
+module.exports = tie_ratio_block_has_shape_stock

package/src/models/Cargo_Profile.js

@@ -81,6 +81,33 @@ class Cargo_Profile
         return str_to_bool(this.#instance['allocation.blocks.enable_item_continuation_lock'], true)
     }
 
+    /**
+     * Whether slot item choice rejects SKUs that would overload axles.
+     * Defaults to false when omitted or when no cargo profile is loaded.
+     * @returns {boolean}
+     */
+    static enable_axle_load_slot_gate()
+    {
+        if (Cargo_Profile.#instance === null)
+        {
+            return false
+        }
+        return str_to_bool(this.#instance['allocation.blocks.enable_axle_load_slot_gate'], false)
+    }
+
+    /**
+     * Axle slack percent applied as pesoMaxFinal * (1 + percent / 100).
+     * @returns {number}
+     */
+    static axle_weight_gap_percent()
+    {
+        if (Cargo_Profile.#instance === null)
+        {
+            return 0
+        }
+        return finite_float_from_string_or_number(this.#instance.folga_de_peso_nos_eixos, 0)
+    }
+
     static enable_key_item_mapping()
     {
         return str_to_bool(this.#instance['allocation.blocks.preferential.enable'], true)
@@ -362,6 +389,21 @@ class Cargo_Profile
         return str_to_bool(this.#instance[key], false)
     }
 
+    /**
+     * Prefer same-height tie-ratio blocks over mixed-height when both fit.
+     * Default true when omitted.
+     * @returns {boolean}
+     */
+    static prefer_same_height_tie_ratio_slots()
+    {
+        if (Cargo_Profile.#instance === null)
+        {
+            return true
+        }
+        const key = 'allocation.blocks.prefer_same_height_tie_ratio_slots'
+        return str_to_bool(this.#instance[key], true)
+    }
+
     static tie_ratio_allocate_remainder_as_partial_blocks()
     {
         if (Cargo_Profile.#instance === null)

package/src/models/transport/Transport.js

@@ -1,4 +1,5 @@
 const create_container_map = require('./factory/Container_Factory')
+const clone = require('../../tools/Clone')
 
 /**
  * In-memory representation of one transport environment: a map of sequence → container model.
@@ -6,6 +7,7 @@ const create_container_map = require('./factory/Container_Factory')
 class Transport
 {
     #containers = new Map()
+    #axle_env_template
     /**
      * @param {object} transport_data - First element shape from `input_data.envs` (includes `containers` array).
      * @param {object|undefined} empty_space_finder_options - Optional merge tolerance for each {@link Container} finder.
@@ -13,6 +15,16 @@ class Transport
     constructor(data)
     {
         this.#containers = create_container_map(data)
+        this.#axle_env_template = clone(data.transport_data)
+    }
+
+    /**
+     * Frozen-at-construction clone of the env JSON used by axle-load physics.
+     * @returns {object}
+     */
+    get_axle_env_template()
+    {
+        return this.#axle_env_template
     }
 
     /**

package/src/space_and_block_chooser/blocks_filters/pos_selection_filters/Post_Selection_Filter_List.js

@@ -1,9 +1,11 @@
 const Blocks_Bigger_Than_Space_Filter = require('./Blocks_Bigger_Than_Space_Filter')
 const Tie_Ratio_Orientation_Filter = require('../../../Allocation_Optimization/tie_ratio/Tie_Ratio_Orientation_Filter')
 const Tie_Ratio_Vertical_Stack_Filter = require('../../../Allocation_Optimization/tie_ratio/Tie_Ratio_Vertical_Stack_Filter')
+const Same_Height_Tie_Ratio_Filter = require('../../../Allocation_Optimization/tie_ratio/Same_Height_Tie_Ratio_Filter')
 
 module.exports = [
     Blocks_Bigger_Than_Space_Filter,
     Tie_Ratio_Orientation_Filter,
-    Tie_Ratio_Vertical_Stack_Filter
-]
+    Tie_Ratio_Vertical_Stack_Filter,
+    Same_Height_Tie_Ratio_Filter
+]