@jetta/blocks-allocator 0.2.1-2 → 0.2.1-4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.2.1-2",
+    "version": "0.2.1-4",
     "description": "Blocks wall allocation library",
     "main": "src/index.js",
     "exports": {
@@ -41,7 +41,7 @@
     "license": "ISC",
     "dependencies": {
         "@jetta/axle-load-calculator": "^0.4.1",
-        "@jetta/empty-spaces-manager": "^0.1.1-0",
+        "@jetta/empty-spaces-manager": "^0.1.2-1",
         "@jetta/item-amount-controller": "0.1.0-0",
         "@jetta/logger": "^2.0.1",
         "@jetta/lp-framework": "2.1.0-6",

package/src/allocation_flow/leftover_catalog_retry.js

@@ -0,0 +1,67 @@
+const leftover_unitary_blocks = require('../space_and_block_chooser/leftover_unitary_blocks')
+
+/**
+ * Records a stall, unless this is the one-shot retry that admits hidden unitaries.
+ * @param {object} context
+ * @param {object[]} effective_item_list
+ * @param {Record<string, number>} amounts_before
+ * @param {object} empty_space
+ * @param {string} fingerprint
+ * @param {object[]} block_list
+ * @returns {boolean} True when any effective item amount decreased.
+ */
+function update_skip_state_after_attempt(
+    context,
+    effective_item_list,
+    amounts_before,
+    empty_space,
+    fingerprint,
+    block_list
+)
+{
+    if (amount_decreased(effective_item_list, amounts_before))
+    {
+        context.space_skip_state.clear_stalls()
+        context.recovery_state.count = 0
+        return true
+    }
+    if (defer_stall_for_hidden_unitaries(context, block_list))
+    {
+        return false
+    }
+    context.space_skip_state.record_stall(empty_space, fingerprint)
+    return false
+}
+
+/**
+ * @param {object[]} effective_item_list
+ * @param {Record<string, number>} amounts_before
+ * @returns {boolean}
+ */
+function amount_decreased(effective_item_list, amounts_before)
+{
+    return effective_item_list.some(item => item.get_amount() < amounts_before[item.get_id()])
+}
+
+/**
+ * Opens the leftover catalog once when a no-progress attempt used only remembered unitaries.
+ * @param {object} context
+ * @param {object[]} block_list
+ * @returns {boolean} True when the space must be retried before it is stalled.
+ */
+function defer_stall_for_hidden_unitaries(context, block_list)
+{
+    const session = context.chooser_session?.obligate_compound_session
+    const remembered_only = leftover_unitary_blocks.blocks_are_remembered_unitaries_only(
+        block_list ?? [],
+        session
+    )
+    if (!remembered_only)
+    {
+        return false
+    }
+    session.admit_non_remembered_unitaries = true
+    return true
+}
+
+module.exports = { update_skip_state_after_attempt }

package/src/allocation_flow/run_allocation_iteration.js

@@ -9,6 +9,7 @@ const {
     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')
+const { update_skip_state_after_attempt } = require('./leftover_catalog_retry')
 
 /**
  * Runs one allocation iteration: chooser, LP attempt, skip-state update.
@@ -69,7 +70,8 @@ async function run_allocation_iteration(context, container, locked_item)
         effective_item_list,
         amounts_before,
         empty_space,
-        fingerprint
+        fingerprint,
+        block_list
     )
     update_item_continuation_lock(context, wall_output.single_slot_allocated_item_ids)
     context.picking_continuity.update_from_wall(wall_output.last_allocated_item_id)
@@ -117,29 +119,6 @@ function update_compound_probe_session(context, block_list, effective_item_list,
     }
 }
 
-/**
- * @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}
@@ -152,4 +131,4 @@ function assert_blocks_available(block_list)
     }
 }
 
-module.exports = { run_allocation_iteration }
+module.exports = { run_allocation_iteration, update_skip_state_after_attempt }

package/src/space_and_block_chooser/build_allocated_item_snapshots.js

@@ -1,19 +1,108 @@
 /**
- * Maps allocated container items to empty-space chooser snapshots.
- * @param {object} container - Container with get_allocated_items().
- * @returns {Array<{ x: number, y: number, z: number, width: number, height: number, length: number }>}
+ * @param {object} item - Allocated item.
+ * @param {string} reader_name - Accessor name.
+ * @returns {string|undefined} Non-empty text when the accessor returns one.
  */
-function build_allocated_item_snapshots(container)
+function optional_identity(item, reader_name)
 {
-    const allocated_items = container.get_allocated_items?.() ?? []
-    return allocated_items.map(item => ({
+    const reader = item[reader_name]
+    if (typeof reader !== 'function')
+    {
+        return undefined
+    }
+    const value = reader.call(item)
+    if (typeof value !== 'string' || value.length === 0)
+    {
+        return undefined
+    }
+    return value
+}
+
+/**
+ * @param {object} snapshot - Geometry snapshot.
+ * @param {object} item - Allocated item.
+ * @returns {object} Snapshot with identity fields when the item exposes them.
+ */
+function assign_identity(snapshot, item)
+{
+    const item_id = optional_identity(item, 'get_id')
+    const tie_ratio_orientation = optional_identity(item, 'get_tie_ratio_orientation')
+    if (item_id !== undefined)
+    {
+        snapshot.item_id = item_id
+    }
+    if (tie_ratio_orientation !== undefined)
+    {
+        snapshot.tie_ratio_orientation = tie_ratio_orientation
+    }
+    return assign_stacking(snapshot, item)
+}
+
+/**
+ * @param {object} item - Allocated item.
+ * @returns {object|undefined} Stacking info from the item or its source.
+ */
+function read_stacking_info(item)
+{
+    const source = typeof item.get_stacking_source_item === 'function'
+        ? item.get_stacking_source_item()
+        : item
+    if (typeof source.get_stacking_info !== 'function')
+    {
+        return undefined
+    }
+    return source.get_stacking_info()
+}
+
+/**
+ * @param {object} snapshot - Geometry snapshot.
+ * @param {object} item - Allocated item.
+ * @returns {object} Snapshot with stacking fields when present.
+ */
+function assign_stacking(snapshot, item)
+{
+    const info = read_stacking_info(item)
+    if (!info)
+    {
+        return snapshot
+    }
+    if (typeof info.stacking_family === 'string' && info.stacking_family.length > 0)
+    {
+        snapshot.stacking_family = info.stacking_family
+    }
+    if (Array.isArray(info.supported_families) && info.supported_families.length > 0)
+    {
+        snapshot.supported_families = info.supported_families
+    }
+    return snapshot
+}
+
+/**
+ * @param {object} item - Allocated item.
+ * @returns {object} Chooser snapshot.
+ */
+function snapshot_from_item(item)
+{
+    const snapshot = {
         x: item.get_x(),
         y: item.get_y(),
         z: item.get_z(),
         width: item.get_width(),
         height: item.get_height(),
         length: item.get_length()
-    }))
+    }
+    return assign_identity(snapshot, item)
+}
+
+/**
+ * Maps allocated container items to empty-space chooser snapshots.
+ * @param {object} container - Container with get_allocated_items().
+ * @returns {Array<object>} Geometry plus optional identity and stacking fields.
+ */
+function build_allocated_item_snapshots(container)
+{
+    const allocated_items = container.get_allocated_items?.() ?? []
+    return allocated_items.map(snapshot_from_item)
 }
 
 module.exports = build_allocated_item_snapshots

package/src/space_and_block_chooser/compound_first_with_leftover_fill.js

@@ -24,10 +24,10 @@ async function resolve_after_compound_probe(
 )
 {
     const compound_block_list = compound_blocks_from_list(pre_selected_block_list)
-    const leftover_block_list = leftover_unitary_blocks(
+    const leftover_block_list = leftover_unitary_blocks.from_session(
         pre_selected_block_list,
         compound_block_list,
-        filter_data.obligate_compound_session?.leftover_sku_shape_hashes
+        filter_data.obligate_compound_session
     )
     leftover_unitary_blocks.remember_leftover_sku_hashes(
         filter_data.obligate_compound_session,

package/src/space_and_block_chooser/leftover_sku_hashes.js

@@ -0,0 +1,159 @@
+const { cube_map_function } = require('../Blocks_Preparation/Cube_Map_Function')
+const round = require('../tools/Rounder')
+
+/**
+ * Stores leftover SKU shape hashes while compounds still remain.
+ * @param {{ leftover_sku_shape_hashes?: string[] }|undefined} session
+ * @param {object[]} leftover_block_list
+ * @param {object[]} compound_block_list
+ * @returns {void}
+ */
+function remember_leftover_sku_hashes(session, leftover_block_list, compound_block_list)
+{
+    if (!session || compound_block_list.length === 0 || leftover_block_list.length === 0)
+    {
+        return
+    }
+    if (session.leftover_sku_shape_hashes?.length > 0)
+    {
+        return
+    }
+    session.leftover_sku_shape_hashes = [...leftover_sku_shape_hashes(leftover_block_list)]
+}
+
+/**
+ * Width/height/length hashes for leftover 1-slot blocks, including swapped floor axes.
+ * @param {object[]} leftover_block_list
+ * @returns {Set<string>}
+ */
+function leftover_sku_shape_hashes(leftover_block_list)
+{
+    const hashes = new Set()
+    for (const block of leftover_block_list)
+    {
+        add_slot_orientation_hashes(hashes, block)
+    }
+    return hashes
+}
+
+/**
+ * @param {Set<string>} hashes
+ * @param {object} block
+ * @returns {void}
+ */
+function add_slot_orientation_hashes(hashes, block)
+{
+    if (typeof block.get_slot_list !== 'function')
+    {
+        return
+    }
+    const slot_list = block.get_slot_list()
+    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
+    {
+        return
+    }
+    hashes.add(cube_map_function(slot_list[0]))
+    hashes.add(swapped_length_width_hash(slot_list[0]))
+}
+
+/**
+ * @param {object} slot
+ * @returns {string}
+ */
+function swapped_length_width_hash(slot)
+{
+    return round(slot.get_length()) + ';' + round(slot.get_height()) + ';' + round(slot.get_width())
+}
+
+/**
+ * @param {Set<string>|string[]|undefined} remembered_sku_hashes
+ * @returns {Set<string>}
+ */
+function to_hash_set(remembered_sku_hashes)
+{
+    if (!remembered_sku_hashes)
+    {
+        return new Set()
+    }
+    if (remembered_sku_hashes instanceof Set)
+    {
+        return remembered_sku_hashes
+    }
+    return new Set(remembered_sku_hashes)
+}
+
+/**
+ * @param {object[]} compound_block_list
+ * @returns {Set<string>}
+ */
+function compound_slot_shape_hashes(compound_block_list)
+{
+    const hashes = new Set()
+    for (const block of compound_block_list)
+    {
+        add_compound_slot_hashes(hashes, block)
+    }
+    return hashes
+}
+
+/**
+ * @param {Set<string>} hashes
+ * @param {object} block
+ * @returns {void}
+ */
+function add_compound_slot_hashes(hashes, block)
+{
+    if (typeof block.get_slot_list !== 'function')
+    {
+        return
+    }
+    for (const slot of block.get_slot_list())
+    {
+        add_measured_slot_hash(hashes, slot)
+    }
+}
+
+/**
+ * @param {Set<string>} hashes
+ * @param {object} slot
+ * @returns {void}
+ */
+function add_measured_slot_hash(hashes, slot)
+{
+    if (typeof slot.get_width !== 'function')
+    {
+        return
+    }
+    hashes.add(cube_map_function(slot))
+    hashes.add(swapped_length_width_hash(slot))
+}
+
+/**
+ * @param {object} block
+ * @param {Set<string>} remembered
+ * @returns {boolean}
+ */
+function is_unitary_matching_hashes(block, remembered)
+{
+    if (typeof block.get_slot_list !== 'function')
+    {
+        return false
+    }
+    const slot_list = block.get_slot_list()
+    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
+    {
+        return false
+    }
+    return remembered.has(cube_map_function(slot_list[0]))
+        || remembered.has(swapped_length_width_hash(slot_list[0]))
+}
+
+module.exports = {
+    remember_leftover_sku_hashes,
+    leftover_sku_shape_hashes,
+    to_hash_set,
+    compound_slot_shape_hashes,
+    is_unitary_matching_hashes,
+    cube_map_function,
+    swapped_length_width_hash
+}

package/src/space_and_block_chooser/leftover_space_memory.js

@@ -56,12 +56,10 @@ function skip_probe_or_leftover_resolution(filter_data, empty_space_list, pre_se
 {
     const session = filter_data.obligate_compound_session
     const leftover_spaces = spaces_matching_remembered_leftover(empty_space_list, session)
-    const leftover_block_list = leftover_unitary_blocks(
+    const leftover_block_list = leftover_unitary_blocks.from_session(
         pre_selected_block_list,
-        pre_selected_block_list.filter(
-            block => typeof block.get_slot_list === 'function' && block.get_slot_list().length > 1
-        ),
-        session?.leftover_sku_shape_hashes
+        compound_blocks(pre_selected_block_list),
+        session
     )
     if (leftover_spaces.length > 0 && leftover_block_list.length > 0)
     {
@@ -75,6 +73,24 @@ function skip_probe_or_leftover_resolution(filter_data, empty_space_list, pre_se
     return skip_probe_resolution(empty_space_list, pre_selected_block_list)
 }
 
+/**
+ * @param {object[]} block_list
+ * @returns {object[]}
+ */
+function compound_blocks(block_list)
+{
+    return block_list.filter(is_compound_block)
+}
+
+/**
+ * @param {object} block
+ * @returns {boolean}
+ */
+function is_compound_block(block)
+{
+    return typeof block.get_slot_list === 'function' && block.get_slot_list().length > 1
+}
+
 function space_bbox(space)
 {
     if (typeof space.get_x !== 'function')

package/src/space_and_block_chooser/leftover_unitary_admission.js

@@ -0,0 +1,89 @@
+const {
+    to_hash_set,
+    is_unitary_matching_hashes
+} = require('./leftover_sku_hashes')
+
+/**
+ * 1-slot blocks whose shape is outside the remembered leftover allow-list.
+ * @param {object[]} pre_selected_block_list
+ * @param {Set<string>|string[]} [remembered_sku_hashes]
+ * @returns {object[]}
+ */
+function unitaries_outside_remembered_hashes(pre_selected_block_list, remembered_sku_hashes)
+{
+    const remembered = to_hash_set(remembered_sku_hashes)
+    return pre_selected_block_list.filter(block => is_hidden_unitary(block, remembered))
+}
+
+/**
+ * Remembered matches plus every other 1-slot block, in pre-selected order.
+ * @param {object[]} pre_selected_block_list
+ * @param {object[]} remembered_matches
+ * @param {Set<string>|string[]|undefined} remembered_sku_hashes
+ * @returns {object[]}
+ */
+function unite_with_hidden_unitaries(pre_selected_block_list, remembered_matches, remembered_sku_hashes)
+{
+    const hidden = new Set(
+        unitaries_outside_remembered_hashes(pre_selected_block_list, remembered_sku_hashes)
+    )
+    const remembered = new Set(remembered_matches)
+    return pre_selected_block_list.filter(block => remembered.has(block) || hidden.has(block))
+}
+
+/**
+ * True when every block is a remembered 1-slot and the one-shot release has not run.
+ * @param {object[]} block_list
+ * @param {{ leftover_sku_shape_hashes?: string[], admit_non_remembered_unitaries?: boolean }|undefined} session
+ * @returns {boolean}
+ */
+function blocks_are_remembered_unitaries_only(block_list, session)
+{
+    if (!session || session.admit_non_remembered_unitaries === true || block_list.length === 0)
+    {
+        return false
+    }
+    const remembered = to_hash_set(session.leftover_sku_shape_hashes)
+    if (remembered.size === 0)
+    {
+        return false
+    }
+    return block_list.every(block => is_unitary_matching_hashes(block, remembered))
+}
+
+/**
+ * @param {object} block
+ * @param {Set<string>} remembered
+ * @returns {boolean}
+ */
+function is_hidden_unitary(block, remembered)
+{
+    if (!is_single_slot_block(block))
+    {
+        return false
+    }
+    if (remembered.size === 0)
+    {
+        return true
+    }
+    return !is_unitary_matching_hashes(block, remembered)
+}
+
+/**
+ * @param {object} block
+ * @returns {boolean}
+ */
+function is_single_slot_block(block)
+{
+    if (typeof block.get_slot_list !== 'function')
+    {
+        return false
+    }
+    return block.get_slot_list().length === 1
+}
+
+module.exports = {
+    unitaries_outside_remembered_hashes,
+    unite_with_hidden_unitaries,
+    blocks_are_remembered_unitaries_only
+}

package/src/space_and_block_chooser/leftover_unitary_blocks.js

@@ -1,114 +1,90 @@
-const { cube_map_function } = require('../Blocks_Preparation/Cube_Map_Function')
-const round = require('../tools/Rounder')
+const {
+    remember_leftover_sku_hashes,
+    leftover_sku_shape_hashes,
+    to_hash_set,
+    compound_slot_shape_hashes,
+    is_unitary_matching_hashes,
+    cube_map_function,
+    swapped_length_width_hash
+} = require('./leftover_sku_hashes')
+const {
+    unite_with_hidden_unitaries,
+    unitaries_outside_remembered_hashes,
+    blocks_are_remembered_unitaries_only
+} = require('./leftover_unitary_admission')
 
 /**
  * 1-slot blocks of leftover SKUs: not used by remaining compounds, or remembered after compounds are gone.
+ * When `admit_other_unitaries` is true, other 1-slot blocks are included without changing stored hashes.
  * @param {object[]} pre_selected_block_list
  * @param {object[]} compound_block_list
  * @param {Set<string>|string[]} [remembered_sku_hashes]
+ * @param {boolean} [admit_other_unitaries]
  * @returns {object[]}
  */
-function leftover_unitary_blocks(pre_selected_block_list, compound_block_list, remembered_sku_hashes)
+function leftover_unitary_blocks(
+    pre_selected_block_list,
+    compound_block_list,
+    remembered_sku_hashes,
+    admit_other_unitaries
+)
 {
-    const remembered = to_hash_set(remembered_sku_hashes)
-    if (remembered.size > 0)
+    const remembered_matches = remembered_or_current_unitaries(
+        pre_selected_block_list,
+        compound_block_list,
+        remembered_sku_hashes
+    )
+    if (admit_other_unitaries !== true)
     {
-        return pre_selected_block_list.filter(block => is_unitary_matching_hashes(block, remembered))
+        return remembered_matches
     }
-    return pre_selected_block_list.filter(
-        block => is_leftover_unitary_block(block, compound_slot_shape_hashes(compound_block_list))
+    return unite_with_hidden_unitaries(
+        pre_selected_block_list,
+        remembered_matches,
+        remembered_sku_hashes
     )
 }
 
 /**
- * Stores leftover SKU shape hashes while compounds still remain.
- * @param {{ leftover_sku_shape_hashes?: string[] }|undefined} session
- * @param {object[]} leftover_block_list
+ * Applies the session allow-list, including hidden unitaries after the one-shot release.
+ * @param {object[]} pre_selected_block_list
  * @param {object[]} compound_block_list
+ * @param {{ leftover_sku_shape_hashes?: string[], admit_non_remembered_unitaries?: boolean }|undefined} session
+ * @returns {object[]}
  */
-function remember_leftover_sku_hashes(session, leftover_block_list, compound_block_list)
+function leftover_unitary_blocks_from_session(pre_selected_block_list, compound_block_list, session)
 {
-    if (!session || compound_block_list.length === 0 || leftover_block_list.length === 0)
-    {
-        return
-    }
-    if (session.leftover_sku_shape_hashes?.length > 0)
-    {
-        return
-    }
-    session.leftover_sku_shape_hashes = [...leftover_sku_shape_hashes(leftover_block_list)]
+    return leftover_unitary_blocks(
+        pre_selected_block_list,
+        compound_block_list,
+        session?.leftover_sku_shape_hashes,
+        session?.admit_non_remembered_unitaries === true
+    )
 }
 
 /**
- * Width/height/length hashes for leftover 1-slot blocks, including swapped floor axes.
- * @param {object[]} leftover_block_list
- * @returns {Set<string>}
+ * @param {object[]} pre_selected_block_list
+ * @param {object[]} compound_block_list
+ * @param {Set<string>|string[]|undefined} remembered_sku_hashes
+ * @returns {object[]}
  */
-function leftover_sku_shape_hashes(leftover_block_list)
-{
-    const hashes = new Set()
-    for (const block of leftover_block_list)
-    {
-        add_slot_orientation_hashes(hashes, block)
-    }
-    return hashes
-}
-
-function add_slot_orientation_hashes(hashes, block)
-{
-    if (typeof block.get_slot_list !== 'function')
-    {
-        return
-    }
-    const slot_list = block.get_slot_list()
-    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
-    {
-        return
-    }
-    hashes.add(cube_map_function(slot_list[0]))
-    hashes.add(swapped_length_width_hash(slot_list[0]))
-}
-
-function swapped_length_width_hash(slot)
-{
-    return round(slot.get_length()) + ';' + round(slot.get_height()) + ';' + round(slot.get_width())
-}
-
-function to_hash_set(remembered_sku_hashes)
+function remembered_or_current_unitaries(pre_selected_block_list, compound_block_list, remembered_sku_hashes)
 {
-    if (!remembered_sku_hashes)
-    {
-        return new Set()
-    }
-    if (remembered_sku_hashes instanceof Set)
-    {
-        return remembered_sku_hashes
-    }
-    return new Set(remembered_sku_hashes)
-}
-
-function compound_slot_shape_hashes(compound_block_list)
-{
-    const hashes = new Set()
-    for (const block of compound_block_list)
+    const remembered = to_hash_set(remembered_sku_hashes)
+    if (remembered.size > 0)
     {
-        if (typeof block.get_slot_list !== 'function')
-        {
-            continue
-        }
-        for (const slot of block.get_slot_list())
-        {
-            if (typeof slot.get_width !== 'function')
-            {
-                continue
-            }
-            hashes.add(cube_map_function(slot))
-            hashes.add(swapped_length_width_hash(slot))
-        }
+        return pre_selected_block_list.filter(block => is_unitary_matching_hashes(block, remembered))
     }
-    return hashes
+    return pre_selected_block_list.filter(
+        block => is_leftover_unitary_block(block, compound_slot_shape_hashes(compound_block_list))
+    )
 }
 
+/**
+ * @param {object} block
+ * @param {Set<string>} compound_slot_hashes
+ * @returns {boolean}
+ */
 function is_leftover_unitary_block(block, compound_slot_hashes)
 {
     if (typeof block.get_slot_list !== 'function')
@@ -128,26 +104,25 @@ function is_leftover_unitary_block(block, compound_slot_hashes)
     {
         return true
     }
-    return !compound_slot_hashes.has(cube_map_function(slot_list[0]))
-        && !compound_slot_hashes.has(swapped_length_width_hash(slot_list[0]))
+    return slot_shape_is_absent(slot_list[0], compound_slot_hashes)
 }
 
-function is_unitary_matching_hashes(block, remembered)
+/**
+ * @param {object} slot
+ * @param {Set<string>} compound_slot_hashes
+ * @returns {boolean}
+ */
+function slot_shape_is_absent(slot, compound_slot_hashes)
 {
-    if (typeof block.get_slot_list !== 'function')
-    {
-        return false
-    }
-    const slot_list = block.get_slot_list()
-    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
-    {
-        return false
-    }
-    return remembered.has(cube_map_function(slot_list[0]))
-        || remembered.has(swapped_length_width_hash(slot_list[0]))
+    const matches_cube = compound_slot_hashes.has(cube_map_function(slot))
+    const matches_swap = compound_slot_hashes.has(swapped_length_width_hash(slot))
+    return !matches_cube && !matches_swap
 }
 
 leftover_unitary_blocks.remember_leftover_sku_hashes = remember_leftover_sku_hashes
 leftover_unitary_blocks.leftover_sku_shape_hashes = leftover_sku_shape_hashes
+leftover_unitary_blocks.from_session = leftover_unitary_blocks_from_session
+leftover_unitary_blocks.unitaries_outside_remembered_hashes = unitaries_outside_remembered_hashes
+leftover_unitary_blocks.blocks_are_remembered_unitaries_only = blocks_are_remembered_unitaries_only
 
 module.exports = leftover_unitary_blocks

package/src/space_and_block_chooser/leftover_unitary_empty_spaces.js

@@ -119,10 +119,10 @@ function resolve_compound_first_or_leftover(
         empty_space_list,
         pre_selected_block_list,
         leftover_empty_spaces,
-        leftover_unitary_blocks(
+        leftover_unitary_blocks.from_session(
             pre_selected_block_list,
             compound_block_list,
-            filter_data.obligate_compound_session?.leftover_sku_shape_hashes
+            filter_data.obligate_compound_session
         )
     )
 }