if (requiredType === CORE_FINO || requiredType === CORE_MINO) {
  const orientationCount = requiredType === CORE_MINO ? 1 : 4;

  // 同一個局面中的 occupied／ownNeighbors 不會改變，
  // 不應對每個候選重新計算。
  const ownNeighbors = neighborMask(oldOwn);

  for (let orientation = 0; orientation < orientationCount; orientation += 1) {
    for (let anchor = 0; anchor < 100; anchor += 1) {
      const mask = PLACEMENT_MASKS[requiredType][orientation][anchor];

      if (
        !mask ||
        (mask & occupied) !== 0n ||
        (mask & ownNeighbors) !== 0n
      ) {
        continue;
      }

// 移動一個 Mino，再放置 Vino。
const oldMinoBits = getTypeBits(position, player, CORE_MINO);

for (let from = 0; from < 100; from += 1) {
  if (!(oldMinoBits & CELL_BITS[from])) {
    continue;
  }

  for (let direction = 0; direction < 4; direction += 1) {
    const to = normalMinoDestination(occupied, from, direction);

    if (to < 0) {
      continue;
    }

    const movedMinoBits = (oldMinoBits & (FULL_BOARD_MASK ^ CELL_BITS[from])) | CELL_BITS[to];

    setTypeBits(position, player, CORE_MINO, movedMinoBits);

    const movedOwn = getOwnerBits(position, player);

    for (let orientation = 0; orientation < 4; orientation += 1) {
      for (let anchor = 0; anchor < 100; anchor += 1) {
        const mask = PLACEMENT_MASKS[CORE_VINO][orientation][anchor];

        if (!isLegalPlacementMask(position, player, CORE_VINO, mask)) {
          continue;
        }

        count = appendGeneratedAction(
          actions,
          scores,
          count,
          encodeMoveVino(from, to, anchor, orientation),
          actionHeuristic(position, player, oldOwn, movedOwn | mask) + 3
        );
      }
    }

    setTypeBits(position, player, CORE_MINO, oldMinoBits);
  }
}

// 移動一個 Mino，再放置 Vino。
// 不修改 position；直接計算移動後的 occupied／own bitboard。
const oldMinoBits = getTypeBits(position, player, CORE_MINO);

for (let from = 0; from < 100; from += 1) {
  const fromBit = CELL_BITS[from];

  if ((oldMinoBits & fromBit) === 0n) {
    continue;
  }

  const clearFromMask = FULL_BOARD_MASK ^ fromBit;

  for (let direction = 0; direction < 4; direction += 1) {
    const to = normalMinoDestination(occupied, from, direction);

    if (to < 0) {
      continue;
    }

    const toBit = CELL_BITS[to];

    const movedOccupied = (occupied & clearFromMask) | toBit;
    const movedOwn = (oldOwn & clearFromMask) | toBit;

    for (let orientation = 0; orientation < 4; orientation += 1) {
      for (let anchor = 0; anchor < 100; anchor += 1) {
        const mask = PLACEMENT_MASKS[CORE_VINO][orientation][anchor];

        if (!mask || (mask & movedOccupied) !== 0n) {
          continue;
        }

        count = appendGeneratedAction(
          actions,
          scores,
          count,
          encodeMoveVino(from, to, anchor, orientation),
          actionHeuristic(position, player, oldOwn, movedOwn | mask) + 3
        );
      }
    }
  }
}

progressiveWideningLimit(node, actionCount) {
  const visits = this.pool.visits[node];

  const allowed = Math.floor(
    PROGRESSIVE_WIDENING_BASE +
      PROGRESSIVE_WIDENING_SCALE *
        Math.pow(visits + 1, PROGRESSIVE_WIDENING_EXPONENT)
  );

  return Math.min(actionCount, Math.max(1, allowed));
}

/*
 * 每個棋盤格隸屬於哪些 QUICK_SQUARE_MASKS。
 * action 只改變少數格子，因此只有包含變動格子的正方形
 * 才可能改變完成／未完成狀態。
 */
const QUICK_SQUARES_BY_CELL = Array.from(
  { length: 100 },
  () => []
);

for (
  let squareIndex = 0;
  squareIndex < QUICK_SQUARE_MASKS.length;
  squareIndex += 1
) {
  const squareMask = QUICK_SQUARE_MASKS[squareIndex];

  for (let cell = 0; cell < 100; cell += 1) {
    if ((squareMask & CELL_BITS[cell]) !== 0n) {
      QUICK_SQUARES_BY_CELL[cell].push(squareIndex);
    }
  }
}

/*
 * 一個 square 可能同時包含多個變動格子。
 * 使用 stamp 去重，避免同一個 square 重算多次。
 */
const QUICK_SQUARE_VISIT_STAMPS = new Uint32Array(
  QUICK_SQUARE_MASKS.length
);

let quickSquareVisitStamp = 0;

function nextQuickSquareVisitStamp() {
  quickSquareVisitStamp = (quickSquareVisitStamp + 1) >>> 0;

  if (quickSquareVisitStamp === 0) {
    QUICK_SQUARE_VISIT_STAMPS.fill(0);
    quickSquareVisitStamp = 1;
  }

  return quickSquareVisitStamp;
}

function actionHeuristic(_position, player, oldOwn, newOwn) {
  const changed = oldOwn ^ newOwn;

  if (changed === 0n) {
    return player === 1 ? 0.001 : 0.002;
  }

  let squareDelta = 0;
  let centerDelta = 0;
  let cellDelta = 0;

  const stamp = nextQuickSquareVisitStamp();

  for (let cell = 0; cell < 100; cell += 1) {
    const cellBit = CELL_BITS[cell];

    if ((changed & cellBit) === 0n) {
      continue;
    }

    const ownedAfter = (newOwn & cellBit) !== 0n;

    if (ownedAfter) {
      centerDelta += CENTER_WEIGHTS[cell];
      cellDelta += 1;
    } else {
      centerDelta -= CENTER_WEIGHTS[cell];
      cellDelta -= 1;
    }

    const squareIndexes = QUICK_SQUARES_BY_CELL[cell];

    for (
      let listIndex = 0;
      listIndex < squareIndexes.length;
      listIndex += 1
    ) {
      const squareIndex = squareIndexes[listIndex];

      if (QUICK_SQUARE_VISIT_STAMPS[squareIndex] === stamp) {
        continue;
      }

      QUICK_SQUARE_VISIT_STAMPS[squareIndex] = stamp;

      const squareMask = QUICK_SQUARE_MASKS[squareIndex];

      const completedBefore =
        (oldOwn & squareMask) === squareMask;

      const completedAfter =
        (newOwn & squareMask) === squareMask;

      if (completedBefore === completedAfter) {
        continue;
      }

      const squareValue = QUICK_SQUARE_VALUES[squareIndex];

      squareDelta += completedAfter
        ? squareValue
        : -squareValue;
    }
  }

  return (
    squareDelta * 24 +
    centerDelta * 0.36 +
    cellDelta * 4 +
    (player === 1 ? 0.001 : 0.002)
  );
}

function appendGeneratedAction(
  actions,
  scores,
  count,
  action,
  score,
  limit
) {
  /*
   * 完整生成模式：
   * MCTS tree、Alpha-Beta 仍然先全部寫入，最後一次排序。
   */
  if (limit === MAX_ACTIONS) {
    if (count >= MAX_ACTIONS) {
      throw new Error(
        `AI action buffer overflow: ${MAX_ACTIONS}`
      );
    }

    actions[count] = action;
    scores[count] = score;

    return count + 1;
  }

  /*
   * bounded top-K 模式：
   * 陣列始終依 score 由大到小排列，最多只保留 limit 個。
   */
  if (limit <= 0) {
    return 0;
  }

  if (count < limit) {
    let insertAt = count;

    while (
      insertAt > 0 &&
      score > scores[insertAt - 1]
    ) {
      actions[insertAt] = actions[insertAt - 1];
      scores[insertAt] = scores[insertAt - 1];
      insertAt -= 1;
    }

    actions[insertAt] = action;
    scores[insertAt] = score;

    return count + 1;
  }

  /*
   * 已有 K 個候選，而且新候選不比目前第 K 名好。
   */
  if (score <= scores[limit - 1]) {
    return count;
  }

  /*
   * 插入新候選並淘汰原本第 K 名。
   */
  let insertAt = limit - 1;

  while (
    insertAt > 0 &&
    score > scores[insertAt - 1]
  ) {
    actions[insertAt] = actions[insertAt - 1];
    scores[insertAt] = scores[insertAt - 1];
    insertAt -= 1;
  }

  actions[insertAt] = action;
  scores[insertAt] = score;

  return count;
}

function finishGeneratedActions(
  actions,
  scores,
  count,
  limit
) {
  /*
   * bounded top-K 在 append 時已經維持排序，
   * 只有完整模式才需要做完整 quicksort。
   */
  if (limit === MAX_ACTIONS) {
    sortActionsDescending(actions, scores, count);
  }

  return count;
}

function generateCoreActions(
  position,
  actions,
  scores,
  maxReturned = MAX_ACTIONS
) {
  const limit = Number.isFinite(maxReturned)
    ? Math.max(
        1,
        Math.min(MAX_ACTIONS, Math.floor(maxReturned))
      )
    : MAX_ACTIONS;

const actionCount = generateCoreActions(
  this.workCore,
  this.actions,
  this.scores
);

if (actionCount <= 0) {
  break;
}

const heavyWidth = Math.min(12, actionCount);

const selectedIndex = Math.floor(
  Math.pow(Math.random(), 2.25) * heavyWidth
);

const action = this.actions[selectedIndex];

const actionCount = generateCoreActions(
  this.workCore,
  this.actions,
  this.scores,
  ROLLOUT_WIDTH
);

if (actionCount <= 0) {
  break;
}

const selectedIndex = Math.floor(
  Math.pow(Math.random(), 2.25) * actionCount
);

const action = this.actions[selectedIndex];

function popcountBigInt(bits) {
  let count = 0;
  let value = bits;

  while (value) {
    value &= value - 1n;
    count += 1;
  }

  return count;
}

function popcountBigInt(bits) {
  const chunkMask = 0xffffn;

  return (
    POPCOUNT_16[Number(bits & chunkMask)] +
    POPCOUNT_16[Number((bits >> 16n) & chunkMask)] +
    POPCOUNT_16[Number((bits >> 32n) & chunkMask)] +
    POPCOUNT_16[Number((bits >> 48n) & chunkMask)] +
    POPCOUNT_16[Number((bits >> 64n) & chunkMask)] +
    POPCOUNT_16[Number((bits >> 80n) & chunkMask)] +
    POPCOUNT_16[Number((bits >> 96n) & chunkMask)]
  );
}