@jetta/blocks-allocator 0.0.0-stage → 0.1.0-0

package/src/Allocation_Optimization/item_consumption_heuristic/Item_Chooser.js

@@ -0,0 +1,159 @@
+const No_Available_Items_Exception = require('./exceptions/No_Available_Items_Exception')
+const No_Slots_For_Items_Exception = require('./exceptions/No_Slots_For_Items_Exception')
+const Cargo_Profile = require('../../models/Cargo_Profile')
+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 { distribute_items_by_weight_range } = require('./Weight_Slot_Distribution')
+const {
+    resolve_choose_item_heuristic_context,
+    format_slot_label_for_exception
+} = require('./Choose_Item_Heuristic_Context')
+const {
+    calculate_total_stack_slots,
+    sort_stacking_slots_by_proximity
+} = require('./Stack_Slot_Calculator')
+const { order_items_by_capacity_bias } = require('./Capacity_Bias_Item_Order')
+
+/**
+ * Chooses an item from available items by distributing them into stacking slots by weight
+ * and returning the item in the slot closest to the block slot position.
+ * @param {object} data - Input bag.
+ * @param {object} [data.slot] - Slot with get_y() and get_height() (production).
+ * @param {object} [data.block_slot] - Legacy alias for slot (tests).
+ * @param {object} [data.container] - Container with get_height() and is_a_valid_stacking().
+ * @param {number} [data.height_limit] - Used with a stub container when data.container is absent.
+ * @param {object} [data.item_position] - { x, y, z }; defaults to origin when absent.
+ * @param {object[]} data.item_list - Items with get_weight().
+ * @param {number} [data.qty_of_slots] - Required when the heuristic runs.
+ * @param {string} [data.previous_chosen_item_id] - Optional previous choice.
+ * @returns {object} The chosen item.
+ * @throws {Item_Bigger_Than_Limit} When item height exceeds height_limit.
+ * @throws {Empty_Slot_Error} When no stacking slots have items.
+ * @throws {No_Available_Items_Exception} When item_list is empty.
+ * @throws {No_Suitable_Item_Exception} When no item passes stacking in any weight band.
+ */
+module.exports = function choose_item(data)
+{
+    const { item_list, previous_chosen_item_id } = data
+    if (item_list.length === 0)
+    {
+        throw new No_Available_Items_Exception()
+    }
+    const is_to_prefer_same_id = data.block.get_slot_list().length > 0 && previous_chosen_item_id !== undefined && Cargo_Profile.prefer_block_with_same_item()
+    return is_to_prefer_same_id ? prefer_same_id(data) : choose_item_with_heuristic(data)
+}
+
+function prefer_same_id(data)
+{
+    const { container, item_list, previous_chosen_item_id, item_position } = 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)
+        {
+            return result.allocated_item
+        }
+    }
+
+    return choose_item_with_heuristic(data)
+}
+
+/**
+ * Heuristic path: weight bands, proximity-ordered bands, stacking validation per candidate.
+ * @param {object} data - Input bag (see choose_item).
+ * @returns {object} Chosen item.
+ */
+function choose_item_with_heuristic(data)
+{
+    const { slot, container, item_position } = resolve_choose_item_heuristic_context(data)
+    const { item_list, qty_of_slots } = data
+    const total_slots = calculate_total_stack_slots(container.get_height(), slot)
+    const stacking_slots = distribute_items_by_weight_range(item_list, total_slots)
+    const ordered_bands = sort_stacking_slots_by_proximity(
+        stacking_slots,
+        slot.get_y(),
+        slot.get_height()
+    )
+
+    for (const band of ordered_bands)
+    {
+        const candidate_items = band.items
+        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)
+            {
+                return result.allocated_item
+            }
+
+            remove_item_from_candidate_list(candidate_items, allocation_item)
+        }
+    }
+
+    const slot_label = format_slot_label_for_exception(slot)
+    throw new No_Suitable_Item_Exception(ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM, [slot_label])
+}
+
+function is_stacking_valid(container, allocation_item, item_position, block)
+{
+    const allocated_item = new Allocated_Item(
+        allocation_item,
+        item_position.x,
+        item_position.y,
+        item_position.z
+    )
+    if (should_defer_loose_on_block_stacking_validation(block))
+    {
+        return {
+            is_valid: true,
+            allocated_item
+        }
+    }
+    const is_valid = container.is_a_valid_stacking(allocated_item)
+
+    return {
+        is_valid,
+        allocated_item
+    }
+}
+
+function should_defer_loose_on_block_stacking_validation(block)
+{
+    return Cargo_Profile.stack_loose_on_tie_ratio_blocks()
+        && block?.get_slot_list?.().length === 1
+}
+
+function remove_item_from_candidate_list(candidate_item_list, allocation_item)
+{
+    const index = candidate_item_list.indexOf(allocation_item)
+    if (index > -1)
+    {
+        candidate_item_list.splice(index, 1)
+    }
+}
+
+function get_item(item_list, qty_of_slots, container)
+{
+    if (qty_of_slots === undefined)
+    {
+        throw new No_Slots_For_Items_Exception()
+    }
+
+    if (item_list.length === 0)
+    {
+        throw new No_Available_Items_Exception()
+    }
+
+    const ordered_item_list = order_items_by_capacity_bias(item_list, container)
+    const preferable_item_list = ordered_item_list.filter(item => item.get_amount() >= qty_of_slots)
+
+    if (preferable_item_list.length > 0)
+    {
+        return preferable_item_list[0]
+    }
+
+    return ordered_item_list[0]
+}

package/src/Allocation_Optimization/item_consumption_heuristic/Item_For_Slot_Chooser.js

@@ -0,0 +1,49 @@
+const choose_item = require('./Item_Chooser')
+const get_available_items_for_slot = require('./Slot_Compatible_Items_Finder')
+const { order_items_by_capacity_bias } = require('./Capacity_Bias_Item_Order')
+const { ge } = require('@jetta/number-compare')
+const No_Suitable_Item_Exception = require('../block_builder/exceptions/No_Suitable_Item_Exception')
+const { ALLOCATOR_MESSAGE } = require('../../messages/Allocator_Message')
+
+/**
+ * Chooses an item suitable for the given slot from available items, respecting weight and stacking.
+ * @param {object} data - Container, block, slot, weight, and item maps.
+ * @returns {object} The chosen item for the slot.
+ * @throws {No_Suitable_Item_Exception} When no item fits the slot or stacking rules.
+ */
+module.exports = function choose_item_for_slot(data)
+{
+    const item_list = get_available_item_list(data)
+    return choose_item({ ...data, item_list, height_limit: data.container.get_height() })
+}
+
+/**
+ * @param {object} data
+ * @returns {object[]}
+ */
+function get_available_item_list(data)
+{
+    const { slot, container_supported_weight, item_map, item_amount_map } = data
+    const available_items_for_slot = get_available_items_for_slot(slot, item_map, item_amount_map)
+    const available_item_list = available_items_for_slot.filter(
+        item => item_supports_weight(container_supported_weight, item)
+    )
+    if (available_item_list.length === 0)
+    {
+        throw new No_Suitable_Item_Exception(
+            ALLOCATOR_MESSAGE.NO_SUITABLE_ITEM,
+            [slot.to_string()]
+        )
+    }
+    return order_items_by_capacity_bias(available_item_list, data.container)
+}
+
+/**
+ * @param {number} max_weight
+ * @param {object} item
+ * @returns {boolean}
+ */
+function item_supports_weight(max_weight, item)
+{
+    return ge(max_weight, item.get_weight())
+}

package/src/Allocation_Optimization/item_consumption_heuristic/Slot_Compatible_Items_Finder.js

@@ -0,0 +1,88 @@
+const { cube_map_function } = require('../../Blocks_Preparation/Cube_Map_Function')
+
+const dimension_index_by_item_map = new WeakMap()
+
+/**
+ * Returns items that have positive amount and fit the slot (including rotations).
+ * Builds a dimension→item index once per `item_map` instance (WeakMap-cached).
+ * @param {object} slot - Target slot.
+ * @param {object} item_map - Map of item id to item.
+ * @param {object} item_amount_map - Map of item to available amount.
+ * @returns {Array} List of compatible rotated items.
+ */
+module.exports = function get_available_items_for_slot(slot, item_map, item_amount_map)
+{
+    const dimension_index = get_or_build_dimension_index(item_map)
+    const candidates = dimension_index.get(cube_map_function(slot)) || []
+    const compatible = []
+    for (const candidate of candidates)
+    {
+        const item = item_map[candidate.item_id]
+        if (!item || item_amount_map.get_item_amount(item) <= 0)
+        {
+            continue
+        }
+        compatible.push(item.copy_rotated(item.get_rotated_item(candidate.rotation)))
+    }
+    return compatible
+}
+
+/**
+ * @param {object} item_map
+ * @returns {Map<string, Array<{ item_id: string, rotation: * }>>}
+ */
+function get_or_build_dimension_index(item_map)
+{
+    let dimension_index = dimension_index_by_item_map.get(item_map)
+    if (dimension_index)
+    {
+        return dimension_index
+    }
+    dimension_index = build_dimension_index(item_map)
+    dimension_index_by_item_map.set(item_map, dimension_index)
+    return dimension_index
+}
+
+/**
+ * @param {object} item_map
+ * @returns {Map<string, Array<{ item_id: string, rotation: * }>>}
+ */
+function build_dimension_index(item_map)
+{
+    const dimension_index = new Map()
+    for (const item_id of Object.keys(item_map))
+    {
+        index_item_rotations(dimension_index, item_map[item_id], item_id)
+    }
+    return dimension_index
+}
+
+/**
+ * @param {Map<string, Array<{ item_id: string, rotation: * }>>} dimension_index
+ * @param {object} item
+ * @param {string} item_id
+ * @returns {void}
+ */
+function index_item_rotations(dimension_index, item, item_id)
+{
+    const indexed_dimensions = new Set()
+    for (const rotation of item.get_rotations())
+    {
+        const rotated_item = item.get_rotated_item(rotation)
+        const dimension_key = cube_map_function(rotated_item)
+        if (indexed_dimensions.has(dimension_key))
+        {
+            continue
+        }
+        indexed_dimensions.add(dimension_key)
+        const candidates = dimension_index.get(dimension_key)
+        if (candidates)
+        {
+            candidates.push({ item_id, rotation })
+        }
+        else
+        {
+            dimension_index.set(dimension_key, [{ item_id, rotation }])
+        }
+    }
+}

package/src/Allocation_Optimization/item_consumption_heuristic/Slots_Items_Assigner.js

@@ -0,0 +1,182 @@
+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 { block_has_sufficient_shape_stock } = require('../block_builder/block_shape_stock')
+const { Logger } = require('@jetta/logger')
+const logger = new Logger('Item Consumption Heuristic')
+const order_slots_by_y = (slot_list) => [...slot_list].sort(compare_slot_y_asc)
+const compare_slot_y_asc = (slot_a, slot_b) => slot_a.get_y() - slot_b.get_y()
+
+function build_item_map(item_list)
+{
+    const item_map = {}
+    for (const item of item_list)
+    {
+        item_map[item.get_id()] = item
+    }
+    return item_map
+}
+
+function process_one_slot(data)
+{
+    const allocated_item = choose_item_for_slot(data)
+    data.item_amount_map.discount_single_item(allocated_item)
+    const next_weight = data.container_supported_weight - allocated_item.get_weight()
+    return { allocated_item, next_weight }
+}
+
+/**
+ * Assigns items to block slots using a consumption heuristic (slot order and stacking).
+ */
+class Item_Consumption_Heuristic
+{
+    #empty_space
+    #item_map = {}
+    #item_amount_map
+    #container
+
+    /**
+     * @param {object[]} item_list - Items available for allocation.
+     * @param {object} item_amount_map - Tracks remaining amount per item.
+     * @param {object} container - Target container.
+     */
+    constructor(empty_space, item_list, item_amount_map, container)
+    {
+        this.#empty_space = empty_space
+        this.#item_map = build_item_map(item_list)
+        this.#item_amount_map = item_amount_map
+        this.#container = container
+    }
+
+    /**
+     * Assigns one item per slot of the block, ordered by slot y, updating weight and amounts.
+     * @param {object} block - Block whose slots are to be filled.
+     * @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.
+     * @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)
+    {
+        const slot_count = block.get_slot_list().length
+        if (slot_count === 0)
+        {
+            return []
+        }
+        if (!block_has_sufficient_shape_stock(block, this.#item_map, this.#item_amount_map))
+        {
+            throw new No_Suitable_Item_Exception(
+                ALLOCATOR_MESSAGE.INSUFFICIENT_SHAPE_STOCK,
+                [String(slot_count)]
+            )
+        }
+        logger.debug(`assigning items to ${slot_count} slot(s)`)
+        return this.#assign_items_for_ordered_slots(
+            block,
+            Number(container_supported_weight),
+            item_position,
+            picking_continuity_seed
+        )
+    }
+
+    /**
+     * Assigns specific items to slots using the LP plan (relational co-location path).
+     * @param {object} block
+     * @param {string[]} slot_item_ids - Item ids per slot (same order as ordered slots).
+     * @param {number} container_supported_weight
+     * @param {object} item_position
+     * @returns {object[]}
+     */
+    assign_items_from_plan(block, slot_item_ids, container_supported_weight, item_position)
+    {
+        const slot_list = order_slots_by_y(block.get_slot_list())
+        const allocated_item_list = []
+
+        for (let index = 0; index < slot_list.length; index++)
+        {
+            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()]
+                )
+            }
+
+            this.#item_amount_map.discount_single_item(allocated_item)
+            allocated_item_list.push(allocated_item)
+        }
+
+        logger.debug(`assigned ${allocated_item_list.length} item(s) from LP plan`)
+        return allocated_item_list
+    }
+
+    #update_item_position(item_position, slot)
+    {
+        return {
+            x: item_position.x + slot.get_x(),
+            y: item_position.y + slot.get_y(),
+            z: item_position.z + slot.get_z()
+        }
+    }
+
+    #assign_items_for_ordered_slots(block, initial_weight, starting_item_position, picking_continuity_seed)
+    {
+        const slot_list = order_slots_by_y(block.get_slot_list())
+        const allocated_item_list = new Array(slot_list.length)
+        const provisional_amount_map = this.#item_amount_map.copy()
+        let current_weight = initial_weight
+        let previous_chosen_item_id = picking_continuity_seed ?? undefined
+        let qty_of_slots = slot_list.length
+
+        for (let index = 0; index < slot_list.length; index++)
+        {
+            const slot = slot_list[index]
+            const current_item_position = this.#update_item_position(starting_item_position, slot)
+            const result = process_one_slot({
+                empty_space: this.#empty_space,
+                slot,
+                container_supported_weight: current_weight,
+                container: this.#container,
+                block,
+                item_map: this.#item_map,
+                item_amount_map: provisional_amount_map,
+                previous_chosen_item_id,
+                qty_of_slots,
+                item_position: current_item_position
+            })
+            allocated_item_list[index] = result.allocated_item
+            current_weight = result.next_weight
+            previous_chosen_item_id = result.allocated_item.get_id()
+            qty_of_slots--
+        }
+
+        for (const allocated_item of allocated_item_list)
+        {
+            this.#item_amount_map.discount_single_item(allocated_item)
+        }
+
+        return allocated_item_list
+    }
+}
+
+module.exports = Item_Consumption_Heuristic

package/src/Allocation_Optimization/item_consumption_heuristic/Stack_Slot_Calculator.js

@@ -0,0 +1,87 @@
+const Empty_Slot_Error = require('./exceptions/Empty_Slot_Exception')
+const Item_Bigger_Than_Limit = require('./exceptions/Item_Taller_Than_Limit_Exception')
+
+/**
+ * @param {number} height_limit - Maximum stack height.
+ * @param {object} item - With get_height().
+ * @returns {number} Number of vertical slots that fit.
+ * @throws {Item_Bigger_Than_Limit} When item height exceeds height_limit.
+ */
+function calculate_total_stack_slots(height_limit, item)
+{
+    const total_slots = Math.floor(height_limit / item.get_height())
+    if (total_slots === 0)
+    {
+        throw new Item_Bigger_Than_Limit(height_limit, item)
+    }
+    return total_slots
+}
+
+/**
+ * @param {object[]} slots - Slots with vertical_index and items.
+ * @param {number} target_y - Target y position.
+ * @param {number} item_height - Height per slot.
+ * @returns {object} Slot closest to target_y.
+ * @throws {Empty_Slot_Error} When slots is empty.
+ */
+function find_closest_slot_to_position(slots, target_y, item_height)
+{
+    const first_slot = slots[0]
+    if (!first_slot)
+    {
+        throw new Empty_Slot_Error(target_y)
+    }
+
+    let closest_slot = first_slot
+    let smallest_difference = Infinity
+
+    for (const slot of slots)
+    {
+        const slot_y = slot.vertical_index * item_height
+        const distance = Math.abs(slot_y - target_y)
+        if (distance < smallest_difference)
+        {
+            smallest_difference = distance
+            closest_slot = slot
+        }
+    }
+
+    return closest_slot
+}
+
+/**
+ * Non-empty stacking slots ordered by vertical distance to target_y (ties keep input order).
+ * @param {object[]} slots - Slots with vertical_index and items.
+ * @param {number} target_y - Target y position.
+ * @param {number} item_height - Height per slot.
+ * @returns {object[]} Same slot objects as input, sorted by proximity.
+ * @throws {Empty_Slot_Error} When slots is empty.
+ */
+function sort_stacking_slots_by_proximity(slots, target_y, item_height)
+{
+    const first_slot = slots[0]
+    if (!first_slot)
+    {
+        throw new Empty_Slot_Error(target_y)
+    }
+    const with_meta = slots.map((slot, index) => ({
+        slot,
+        distance: Math.abs(slot.vertical_index * item_height - target_y),
+        index
+    }))
+    with_meta.sort((a, b) =>
+    {
+        if (a.distance !== b.distance)
+        {
+            return a.distance - b.distance
+        }
+        return a.index - b.index
+    })
+    return with_meta.map((entry) => entry.slot)
+}
+
+module.exports = {
+    calculate_total_stack_slots,
+    find_closest_slot_to_position,
+    sort_stacking_slots_by_proximity
+}

package/src/Allocation_Optimization/item_consumption_heuristic/Weight_Slot_Distribution.js

@@ -0,0 +1,72 @@
+/**
+ * Distributes items into stacking slots by normalized weight (heavier toward bottom).
+ * @param {object[]} items - Items with get_weight().
+ * @param {number} total_slots - Number of vertical slots.
+ * @returns {object[]} Slots with vertical_index and items (non-empty only).
+ */
+function distribute_items_by_weight_range(items, total_slots)
+{
+    const normalized_weights = normalize_weights(items)
+    const slots = initialize_slots(total_slots)
+
+    for (let index = 0; index < items.length; index++)
+    {
+        const relative_weight = normalized_weights[index]
+        const slot_index = map_weight_to_slot_index(relative_weight, total_slots)
+        slots[slot_index].items.push(items[index])
+    }
+
+    return slots.filter(slot_has_items)
+}
+
+function slot_has_items(slot)
+{
+    return slot.items.length > 0
+}
+
+/**
+ * @param {object[]} item_list - Items with get_weight().
+ * @returns {number[]} Weights normalized to [0, 1] per item.
+ */
+function normalize_weights(item_list)
+{
+    const weights = item_list.map(get_item_weight)
+    const min = Math.min(...weights)
+    const max = Math.max(...weights)
+    const delta = max - min || 1e-6
+    const result = new Array(item_list.length)
+    for (let index = 0; index < item_list.length; index++)
+    {
+        result[index] = normalized_weight(item_list[index], min, delta)
+    }
+    return result
+}
+
+function get_item_weight(item)
+{
+    return item.get_weight()
+}
+
+function normalized_weight(item, min, delta)
+{
+    return (item.get_weight() - min) / delta
+}
+
+function initialize_slots(count)
+{
+    const slots = new Array(count)
+    for (let index = 0; index < count; index++)
+    {
+        slots[index] = { vertical_index: index, items: [] }
+    }
+    return slots
+}
+
+function map_weight_to_slot_index(relative_weight, total_slots)
+{
+    const raw_index = Math.floor(relative_weight * total_slots)
+    const clamped_index = Math.max(0, Math.min(total_slots - 1, raw_index))
+    return total_slots - 1 - clamped_index
+}
+
+module.exports = { distribute_items_by_weight_range }

package/src/Allocation_Optimization/item_consumption_heuristic/exceptions/Empty_Slot_Exception.js

@@ -0,0 +1,17 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class Empty_Slot_Exception extends Error
+{
+    /**
+     * @param {number} target_y
+     */
+    constructor(target_y)
+    {
+        const message_key = ALLOCATOR_MESSAGE.EMPTY_SLOT
+        super(message_key)
+        this.message_entry = build_message_entry(message_key, [String(target_y)])
+    }
+}
+
+module.exports = Empty_Slot_Exception

package/src/Allocation_Optimization/item_consumption_heuristic/exceptions/Item_Taller_Than_Limit_Exception.js

@@ -0,0 +1,21 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class Item_Taller_Than_Limit_Exception extends Error
+{
+    /**
+     * @param {number} height_limit
+     * @param {object} item
+     */
+    constructor(height_limit, item)
+    {
+        const message_key = ALLOCATOR_MESSAGE.ITEM_TALLER_THAN_LIMIT
+        super(message_key)
+        this.message_entry = build_message_entry(
+            message_key,
+            [String(item.get_height()), String(height_limit)]
+        )
+    }
+}
+
+module.exports = Item_Taller_Than_Limit_Exception

package/src/Allocation_Optimization/item_consumption_heuristic/exceptions/No_Available_Items_Exception.js

@@ -0,0 +1,14 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class No_Available_Items_Exception extends Error
+{
+    constructor()
+    {
+        const message_key = ALLOCATOR_MESSAGE.NO_AVAILABLE_ITEMS
+        super(message_key)
+        this.message_entry = build_message_entry(message_key)
+    }
+}
+
+module.exports = No_Available_Items_Exception