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

package/src/allocation_flow/run_allocation_iteration.js

@@ -0,0 +1,155 @@
+const chooser_empty_space_and_blocks = require('../space_and_block_chooser/Space_And_Blocks_Chooser')
+const There_Is_No_Block_Options_To_Allocate_Exception = require('../exceptions/There_Is_No_Block_Options_To_Allocate_Exception')
+const { apply_weight_ahead_lock_release } = require('../Allocation_Optimization/density_groups/Lock_Weight_Ahead_Release')
+const { build_effective_item_fingerprint } = require('./effective_item_fingerprint')
+const { apply_density_group_item_filter } = require('./density_group_item_filter')
+const { should_skip_compound_probe_after_failure } = require('./compound_probe_fallback')
+const {
+    apply_item_continuation_lock_gate,
+    update_item_continuation_lock
+} = require('./item_continuation_lock_gate')
+const { empty_space_stacks_on_tie_ratio_supporter } = require('../Allocation_Optimization/tie_ratio/tie_ratio_orientation_below_empty_space')
+
+/**
+ * Runs one allocation iteration: chooser, LP attempt, skip-state update.
+ * @param {object} context
+ * @param {object} container
+ * @param {object|null} locked_item
+ * @returns {Promise<boolean>} False when no effective items remain.
+ */
+async function run_allocation_iteration(context, container, locked_item)
+{
+    locked_item = apply_item_continuation_lock_gate(context, locked_item)
+    context.density_scheduler?.prepare_for_iteration(container, context.item_list, locked_item)
+    locked_item = apply_weight_ahead_lock_release(
+        container,
+        context.density_scheduler,
+        context.item_lock,
+        context.item_list,
+        locked_item
+    )
+    let effective_item_list = context.item_lock.get_effective_item_list(context.item_list, locked_item)
+    effective_item_list = apply_density_group_item_filter(
+        context.density_scheduler,
+        context.item_list,
+        effective_item_list,
+        locked_item
+    )
+    if (effective_item_list.length === 0)
+    {
+        return false
+    }
+
+    const fingerprint = build_effective_item_fingerprint(effective_item_list)
+    const spaces_to_avoid = context.space_skip_state.begin_iteration(fingerprint)
+    const amounts_before = context.space_skip_state.snapshot_effective_amounts(effective_item_list)
+
+    const { empty_space, block_list, no_fillable_space_set }
+        = await chooser_empty_space_and_blocks(
+            container,
+            context.block_list,
+            effective_item_list,
+            spaces_to_avoid,
+            context.chooser_session
+        )
+
+    context.preferential_block_identifier.mark_preferential_blocks(block_list)
+
+    const wall_output = await context.allocation_attempt.try_to_allocate(
+        block_list,
+        empty_space,
+        {},
+        container,
+        effective_item_list,
+        context.picking_continuity.get_seed_item_id()
+    )
+    update_compound_probe_session(context, block_list, effective_item_list, amounts_before)
+    const progressed = update_skip_state_after_attempt(
+        context,
+        effective_item_list,
+        amounts_before,
+        empty_space,
+        fingerprint
+    )
+    update_item_continuation_lock(context, wall_output.single_slot_allocated_item_ids)
+    context.picking_continuity.update_from_wall(wall_output.last_allocated_item_id)
+    if (wall_output.placed_tie_ratio_block)
+    {
+        const stacks_on_tie_ratio = empty_space_stacks_on_tie_ratio_supporter({
+            container,
+            empty_space
+        })
+        if (!stacks_on_tie_ratio)
+        {
+            context.chooser_session.tie_ratio_intercalation_state.advance_after_tie_ratio_wall()
+        }
+    }
+    if (progressed)
+    {
+        context.density_scheduler?.on_successful_wall()
+    }
+    context.space_skip_state.merge_no_fillable(no_fillable_space_set)
+    assert_blocks_available(block_list)
+    return true
+}
+
+/**
+ * @param {object} context
+ * @param {object[]} block_list
+ * @param {object[]} effective_item_list
+ * @param {Record<string, number>} amounts_before
+ * @returns {void}
+ */
+function update_compound_probe_session(context, block_list, effective_item_list, amounts_before)
+{
+    const session = context.chooser_session.obligate_compound_session
+    const progressed = effective_item_list.some(
+        item => item.get_amount() < amounts_before[item.get_id()]
+    )
+    if (progressed)
+    {
+        session.skip_compound_probe = false
+        return
+    }
+    if (should_skip_compound_probe_after_failure(block_list))
+    {
+        session.skip_compound_probe = true
+    }
+}
+
+/**
+ * @param {object} context
+ * @param {object[]} effective_item_list
+ * @param {Record<string, number>} amounts_before
+ * @param {object} empty_space
+ * @param {string} fingerprint
+ * @returns {boolean} True when any effective item amount decreased.
+ */
+function update_skip_state_after_attempt(context, effective_item_list, amounts_before, empty_space, fingerprint)
+{
+    const progressed = effective_item_list.some(
+        item => item.get_amount() < amounts_before[item.get_id()]
+    )
+    if (progressed)
+    {
+        context.space_skip_state.clear_stalls()
+        context.recovery_state.count = 0
+        return true
+    }
+    context.space_skip_state.record_stall(empty_space, fingerprint)
+    return false
+}
+
+/**
+ * @param {object[]} block_list
+ * @returns {void}
+ */
+function assert_blocks_available(block_list)
+{
+    if (block_list.length === 0)
+    {
+        throw new There_Is_No_Block_Options_To_Allocate_Exception()
+    }
+}
+
+module.exports = { run_allocation_iteration }

package/src/allocation_flow/space_skip_state.js

@@ -0,0 +1,91 @@
+/**
+ * Tracks permanent and fingerprint-scoped space skips for the allocation chooser.
+ */
+class Space_Skip_State
+{
+    #permanent_no_fillable = new Set()
+    #stalls_by_fingerprint = new Map()
+    #iteration_view = new Set()
+
+    /**
+     * Rebuilds the iteration skip view from permanent skips and stalls for the fingerprint.
+     * @param {string} fingerprint - Effective item fingerprint for the current iteration.
+     * @returns {Set<object>} Mutable set passed to the space chooser.
+     */
+    begin_iteration(fingerprint)
+    {
+        this.#iteration_view.clear()
+        this.#permanent_no_fillable.forEach(space => this.#iteration_view.add(space))
+        const stalled_spaces = this.#stalls_by_fingerprint.get(fingerprint)
+        if (stalled_spaces)
+        {
+            stalled_spaces.forEach(space => this.#iteration_view.add(space))
+        }
+        return this.#iteration_view
+    }
+
+    /**
+     * Persists spaces where filters eliminated all blocks.
+     * @param {Iterable<object>} spaces - Spaces reported by the chooser as permanently unfillable.
+     * @returns {void}
+     */
+    merge_no_fillable(spaces)
+    {
+        for (const space of spaces)
+        {
+            this.#permanent_no_fillable.add(space)
+        }
+    }
+
+    /**
+     * Records a transient stall for a space under the current fingerprint.
+     * @param {object} space - Empty space that made no allocation progress.
+     * @param {string} fingerprint - Effective item fingerprint for the failed attempt.
+     * @returns {void}
+     */
+    record_stall(space, fingerprint)
+    {
+        let stalled_spaces = this.#stalls_by_fingerprint.get(fingerprint)
+        if (!stalled_spaces)
+        {
+            stalled_spaces = new Set()
+            this.#stalls_by_fingerprint.set(fingerprint, stalled_spaces)
+        }
+        stalled_spaces.add(space)
+    }
+
+    /**
+     * Clears all fingerprint-scoped stalls after a successful allocation.
+     * @returns {void}
+     */
+    clear_stalls()
+    {
+        this.#stalls_by_fingerprint.clear()
+    }
+
+    /**
+     * Clears permanently skipped spaces so chooser can retry them after NoSpaceLeft recovery.
+     * @returns {void}
+     */
+    clear_permanent_no_fillable()
+    {
+        this.#permanent_no_fillable.clear()
+    }
+
+    /**
+     * Snapshots effective item amounts before an allocation attempt.
+     * @param {object[]} effective_item_list - Items exposed to the current iteration.
+     * @returns {Record<string, number>} Map of item id to amount.
+     */
+    snapshot_effective_amounts(effective_item_list)
+    {
+        const amounts = {}
+        for (const item of effective_item_list)
+        {
+            amounts[item.get_id()] = item.get_amount()
+        }
+        return amounts
+    }
+}
+
+module.exports = Space_Skip_State

package/src/allocation_flow/try_no_space_left_recovery.js

@@ -0,0 +1,50 @@
+const {NoSpaceLeftException} = require('@jetta/empty-spaces-manager')
+const { remaining_items_fit_container } = require('./container_remaining_capacity')
+const {
+    apply_no_space_left_recovery,
+    compute_max_no_space_left_recoveries,
+    is_compound_fallback_engaged
+} = require('./no_space_left_recovery')
+
+/**
+ * @param {object} params
+ * @param {Error} params.error
+ * @param {object} params.container
+ * @param {object|null} params.locked_item
+ * @param {object[]} params.item_list
+ * @param {object} params.space_skip_state
+ * @param {object} params.chooser_session
+ * @param {object|null} params.density_scheduler
+ * @param {{ count: number }} params.recovery_state
+ * @returns {{ recovered: boolean, item_list: object[] }}
+ */
+function try_no_space_left_recovery(params)
+{
+    if (!(params.error instanceof NoSpaceLeftException))
+    {
+        return { recovered: false, item_list: params.item_list }
+    }
+    const capacity = remaining_items_fit_container(params.item_list, params.container)
+    if (!capacity.has_capacity)
+    {
+        return { recovered: false, item_list: capacity.item_list }
+    }
+    const max_recoveries = compute_max_no_space_left_recoveries(
+        params.density_scheduler?.get_group_count(),
+        is_compound_fallback_engaged(params.chooser_session)
+    )
+    if (params.recovery_state.count >= max_recoveries)
+    {
+        return { recovered: false, item_list: capacity.item_list }
+    }
+    params.recovery_state.count += 1
+    apply_no_space_left_recovery({
+        space_skip_state: params.space_skip_state,
+        chooser_session: params.chooser_session,
+        density_scheduler: params.density_scheduler,
+        locked_item: params.locked_item
+    })
+    return { recovered: true, item_list: capacity.item_list }
+}
+
+module.exports = { try_no_space_left_recovery }

package/src/exceptions/Invalid_Parameter_Exception.js

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

package/src/exceptions/Relational_Allocation_Incomplete_Exception.js

@@ -0,0 +1,24 @@
+const RELATION_ERROR_CODES = require('../relational/Relational_Error_Codes')
+const { build_message_entry } = require('../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../messages/Allocator_Message')
+
+class Relational_Allocation_Incomplete_Exception extends Error
+{
+    /**
+     * @param {object} [details={}]
+     */
+    constructor(details = {})
+    {
+        const group_id = String(details.relational_group_id ?? '')
+        const message_key = ALLOCATOR_MESSAGE.RELATION_ALLOCATION_INCOMPLETE
+        super(message_key)
+        this.name = 'Relational_Allocation_Incomplete_Exception'
+        this.message_entry = build_message_entry(message_key, [group_id])
+        this.code = RELATION_ERROR_CODES.ALLOCATION_INCOMPLETE
+        this.relational_group_id = details.relational_group_id
+        this.allocated_counts = details.allocated_counts
+        this.expected_counts = details.expected_counts
+    }
+}
+
+module.exports = Relational_Allocation_Incomplete_Exception

package/src/exceptions/Relational_Colocation_Violation_Exception.js

@@ -0,0 +1,23 @@
+const RELATION_ERROR_CODES = require('../relational/Relational_Error_Codes')
+const { build_message_entry } = require('../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../messages/Allocator_Message')
+
+class Relational_Colocation_Violation_Exception extends Error
+{
+    /**
+     * @param {object} [details={}]
+     */
+    constructor(details = {})
+    {
+        const group_id = String(details.relational_group_id ?? '')
+        const message_key = ALLOCATOR_MESSAGE.RELATION_COLOCATION_VIOLATION
+        super(message_key)
+        this.name = 'Relational_Colocation_Violation_Exception'
+        this.message_entry = build_message_entry(message_key, [group_id])
+        this.code = RELATION_ERROR_CODES.COLOCATION_VIOLATION
+        this.relational_group_id = details.relational_group_id
+        this.container_sequences = details.container_sequences
+    }
+}
+
+module.exports = Relational_Colocation_Violation_Exception

package/src/exceptions/Relational_Config_Mismatch_Exception.js

@@ -0,0 +1,17 @@
+const RELATION_ERROR_CODES = require('../relational/Relational_Error_Codes')
+const { build_message_entry } = require('../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../messages/Allocator_Message')
+
+class Relational_Config_Mismatch_Exception extends Error
+{
+    constructor()
+    {
+        const message_key = ALLOCATOR_MESSAGE.RELATION_CONFIG_MISMATCH
+        super(message_key)
+        this.name = 'Relational_Config_Mismatch_Exception'
+        this.message_entry = build_message_entry(message_key)
+        this.code = RELATION_ERROR_CODES.CONFIG_MISMATCH
+    }
+}
+
+module.exports = Relational_Config_Mismatch_Exception

package/src/exceptions/There_Is_No_Block_Options_To_Allocate_Exception.js

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

package/src/index.js

@@ -0,0 +1,6 @@
+const run_core_allocation = require('./run_core_allocation')
+const { resolve_trace_id } = require('./tracing/Allocation_Tracer')
+
+run_core_allocation.resolve_trace_id = resolve_trace_id
+
+module.exports = run_core_allocation

package/src/input_preparation/Block_Formatter.js

@@ -0,0 +1,179 @@
+const { Block } = require('../models/Block')
+const Slot = require('../models/Slot')
+const {
+    align_flush_stacked_slots_stable,
+    are_slot_lists_xyz_equal
+} = require('./block_formatter/align_flush_stacked_slots')
+const { run_shell_snap_convergence } = require('./block_formatter/shell_snap_convergence')
+const {
+    has_parallelepiped_shell: shell_is_closed,
+    are_all_slots_inside_bounds: slots_are_inside_bounds
+} = require('./block_formatter/parallelepiped_shell')
+const { slot_list_has_overlapped_slots } = require('./block_formatter/overlapped_slots')
+const Cargo_Profile = require('../models/Cargo_Profile')
+
+const TOUCH_TOLERANCE = 0.005
+const ALIGN_FLUSH_MAX_ROUNDS = 3
+const SHELL_SNAP_CONVERGENCE_MAX = 8
+
+module.exports = function format_block_list(block_list)
+{
+    if (!Cargo_Profile.enable_block_formatter())
+    {
+        return block_list
+    }
+    const formatted_block_list = []
+    for (const block of block_list)
+    {
+        formatted_block_list.push(format_block(block))
+    }
+    return formatted_block_list
+}
+
+function format_block(block)
+{
+    const slot_list = block.get_slot_list()
+    if (!is_eligible_block(slot_list))
+    {
+        return block
+    }
+    const convergence = run_shell_snap_convergence({
+        slot_list,
+        max_iterations: SHELL_SNAP_CONVERGENCE_MAX,
+        touch_tolerance: TOUCH_TOLERANCE,
+        align_flush_max_rounds: ALIGN_FLUSH_MAX_ROUNDS,
+        get_bounds,
+        anchor_slots_to_bounds,
+        align_flush_stacked_slots_stable,
+        normalize_slot_list,
+        are_all_slots_inside_bounds: (s, b) => slots_are_inside_bounds(s, b, TOUCH_TOLERANCE),
+        has_parallelepiped_shell: (s, b) => shell_is_closed(s, b, TOUCH_TOLERANCE),
+        are_slot_lists_xyz_equal
+    })
+    const normalized_slot_list = convergence.normalized_slot_list
+    const normalized_bounds = convergence.normalized_bounds
+    const slot_list_inside_bounds = slots_are_inside_bounds(normalized_slot_list, normalized_bounds, TOUCH_TOLERANCE)
+    const shell_ok = shell_is_closed(normalized_slot_list, normalized_bounds, TOUCH_TOLERANCE)
+    const geometry_changed = convergence.anchor_align_changed
+    if (!slot_list_inside_bounds || (!shell_ok && !geometry_changed))
+    {
+        return block
+    }
+    if (slot_list_has_overlapped_slots(normalized_slot_list))
+    {
+        return block
+    }
+    const block_data = block.get_json()
+    return new Block({
+        ...block_data,
+        width: normalized_bounds.max_x - normalized_bounds.min_x,
+        height: normalized_bounds.max_y - normalized_bounds.min_y,
+        length: normalized_bounds.max_z - normalized_bounds.min_z
+    }, normalized_slot_list)
+}
+
+function is_eligible_block(slot_list)
+{
+    return slot_list.length > 2 || has_same_slot_measures(slot_list)
+}
+
+function has_same_slot_measures(slot_list)
+{
+    if (slot_list.length === 0)
+    {
+        return false
+    }
+    const first_slot = slot_list[0]
+    const reference = `${first_slot.get_width()};${first_slot.get_height()};${first_slot.get_length()}`
+    for (const slot of slot_list)
+    {
+        const current = `${slot.get_width()};${slot.get_height()};${slot.get_length()}`
+        if (current !== reference)
+        {
+            return false
+        }
+    }
+    return true
+}
+
+function get_bounds(slot_list)
+{
+    const first_slot = slot_list[0]
+    const first_end = first_slot.get_end_point()
+    const bounds = { min_x: first_slot.get_x(), min_y: first_slot.get_y(), min_z: first_slot.get_z(), max_x: first_end.x, max_y: first_end.y, max_z: first_end.z }
+    for (const slot of slot_list)
+    {
+        const slot_end = slot.get_end_point()
+        bounds.min_x = Math.min(bounds.min_x, slot.get_x())
+        bounds.min_y = Math.min(bounds.min_y, slot.get_y())
+        bounds.min_z = Math.min(bounds.min_z, slot.get_z())
+        bounds.max_x = Math.max(bounds.max_x, slot_end.x)
+        bounds.max_y = Math.max(bounds.max_y, slot_end.y)
+        bounds.max_z = Math.max(bounds.max_z, slot_end.z)
+    }
+    return bounds
+}
+
+function anchor_slots_to_bounds(slot_list, bounds)
+{
+    const anchored_slot_list = []
+    for (const slot of slot_list)
+    {
+        const anchored_x = calculate_anchored_axis(slot.get_x(), slot.get_width(), bounds.min_x, bounds.max_x)
+        const anchored_y = calculate_anchored_axis(slot.get_y(), slot.get_height(), bounds.min_y, bounds.max_y)
+        const anchored_z = calculate_anchored_axis(slot.get_z(), slot.get_length(), bounds.min_z, bounds.max_z)
+        anchored_slot_list.push(
+            new Slot(
+                anchored_x,
+                anchored_y,
+                anchored_z,
+                slot.get_width(),
+                slot.get_height(),
+                slot.get_length()
+            )
+        )
+    }
+    return anchored_slot_list
+}
+
+function calculate_anchored_axis(start, size, min, max)
+{
+    const end = start + size
+    const is_anchor_min_candidate = Math.abs(start - min) <= TOUCH_TOLERANCE
+    const is_anchor_max_candidate = Math.abs(end - max) <= TOUCH_TOLERANCE
+    if (is_anchor_min_candidate && is_anchor_max_candidate)
+    {
+        return min
+    }
+    if (is_anchor_min_candidate)
+    {
+        return min
+    }
+    if (is_anchor_max_candidate)
+    {
+        return clamp_to_bounds(max - size, size, min, max)
+    }
+    return clamp_to_bounds(start, size, min, max)
+}
+
+function clamp_to_bounds(start, size, min, max)
+{
+    const max_start = max - size
+    if (max_start < min)
+    {
+        return min
+    }
+    return Math.min(Math.max(start, min), max_start)
+}
+
+function normalize_slot_list(slot_list, bounds)
+{
+    return slot_list.map(slot => new Slot(
+        slot.get_x() - bounds.min_x,
+        slot.get_y() - bounds.min_y,
+        slot.get_z() - bounds.min_z,
+        slot.get_width(),
+        slot.get_height(),
+        slot.get_length()
+    ))
+}

package/src/input_preparation/Input_Creator.js

@@ -0,0 +1,76 @@
+const Config = require('../models/Cargo_Profile')
+
+module.exports = function create_blocksmith_input(transport, item_list)
+{
+    const item_data_list = create_input_item_list(item_list)
+
+    return {
+        container: create_container_data(transport),
+        config: Config.get_cargo_profile_as_js_object(),
+        item_list: item_data_list
+    }
+
+}
+
+function create_container_data(transport)
+{
+    const tallest_container = transport.containers.reduce((acc, cur) => cur.altura > acc.altura ? acc = cur : cur = cur, '')
+    return {
+        width: tallest_container.largura,
+        height: tallest_container.altura,
+        length: tallest_container.comprimento,
+    }
+}
+
+
+function create_input_item_list(item_list)
+{
+    return item_list.map(item => create_input_item_data(item))
+}
+
+function create_input_item_data(item)
+{
+    return {
+        'id': item.get_json()._id,
+        'length': item.get_json().length || item.get_json().comprimento,
+        'width': item.get_json().width || item.get_json().largura,
+        'height': item.get_json().height || item.get_json().altura,
+        'weight': item.get_json().weight || item.get_json().peso,
+        'supported_weight': item.get_json().supported_weight || item.get_json().pesoMaxSuportado,
+        'maximum_stacking': item.get_json().maximum_stacking || item.get_json().empilhamentoMaximo,
+        'stacking_rule': get_stacking_unit(item.get_json().stackingUnit),
+        'amount': item.get_json().amount || item.get_json().qtd,
+        'type': item.get_json().type || item.get_json().tipo,
+        'priority': item.get_json().priority || item.get_json().prioridade,
+        'rotation_list': rotation_list(item.get_json().rotacao !== undefined ? item.get_json().rotacao : item.get_json().rotation_list)
+    }
+}
+
+function get_stacking_unit(value)
+{
+    if (value.toLowerCase() === 'supportedweight')
+    {
+        return 'SUPPORTED_WEIGHT'
+    }
+    if (value.toLowerCase() === 'maximumStacking')
+    {
+        return 'MAXIMUM_STACKING'
+    }
+    return 'BOTH'
+}
+
+function rotation_list(rotation_map)
+{
+    const rotation_list = []
+
+    for (const key in rotation_map)
+    {
+        if (rotation_map[key])
+        {
+            const rotation = key.replace('pos', 'position')
+            rotation_list.push(rotation)
+        }
+    }
+
+    return rotation_list
+}