function enumerateEdgeMethods(piece, edgeIdx, allPieces, extraHypPieces = []) {
  let methods = [];
  let opp = piece.owner === 1 ? 2 : 1;
  let { availTypes } = getMoveInventory(opp, extraHypPieces);

  for (let tt of availTypes) {
    for (let flip of [false, true]) {
      for (let j = 0; j < 4; j++) {
        let res = attachByEdge(
          SHAPE_MAP[tt],
          flip,
          j,
          piece.vertices[edgeIdx],
          piece.vertices[(edgeIdx + 1) % 4],
          !!piece.isFlipped
        );

        if (!res) continue;

        let ghost = {
          id: -100000 - nextMethodId - methods.length,
          vertices: res.vertices,
          type: SHAPE_MAP[tt],
          owner: opp,
          svgId: tt,
          isFlipped: flip,
          myEdge: j,
          edgeOnOpp: edgeIdx,
          targetEdge: edgeIdx,
          targetId: piece.id,
          parentId: piece.id,
          level: (piece.level || 0) + 1
        };

        if (isValidGhost(ghost, allPieces)) {
          methods.push(ghost);
        }
      }
    }
  }

  return methods;
}

function getMoveInventory(player, extraHypPieces = []) {
  const myTiles = [0, 1, 2].map(x => 'tile' + (player === 1 ? x : x + 3));
  const extra = extraHypPieces || [];
  const counts = {};

  myTiles.forEach(tile => {
    const staged = tempPieces.filter(p => p && p.svgId === tile).length;
    const usedInHypothesis = extra.filter(
      p => p && p.owner === player && p.svgId === tile
    ).length;

    counts[tile] = Math.max(0, (piecesCount[tile] || 0) + staged - usedInHypothesis);
  });

  return {
    myTiles,
    counts,
    availTypes: myTiles.filter(tile => counts[tile] > 0)
  };
}

function ghostPlacementKey(g) {
  let key = [
    g.owner,
    g.svgId,
    g.targetId,
    g.targetEdge !== undefined ? g.targetEdge : g.edgeOnOpp,
    g.myEdge,
    g.isFlipped ? 1 : 0
  ];

  for (let v of g.vertices) {
    key.push(v[0], v[1], v[2], v[3]);
  }

  return key.join(',');
}

function pairPlacementKey(g1, g2) {
  let a = ghostPlacementKey(g1);
  let b = ghostPlacementKey(g2);
  return a < b ? a + '||' + b : b + '||' + a;
}

function canUseGhostPair(g1, g2, counts) {
  if (!g1 || !g2) return false;
  return g1.svgId !== g2.svgId || counts[g1.svgId] >= 2;
}

function getAllSingleMovesForBoard(player, options = {}) {
  const existingPieces = options.existingPieces || pieces;
  const extraHypPieces = options.extraHypPieces || [];
  const results = [];
  const seen = new Set();

  for (let opp of existingPieces) {
    if (opp.owner === player) continue;

    for (let edgeIdx = 0; edgeIdx < 4; edgeIdx++) {
      let edgeMoves = enumerateEdgeMethods(opp, edgeIdx, existingPieces, extraHypPieces);

      for (let g of edgeMoves) {
        let key = ghostPlacementKey(g);
        if (seen.has(key)) continue;
        seen.add(key);
        results.push(g);
      }
    }
  }

  return results;
}

/*
  規則 5 的權威集合：
  - 兩子必須貼在「同一個對方棋子」
  - 必須是「兩條不同邊」
  - 不包含頂鑫例外的跨目標下法
*/
function getAllSameTargetMoves(player, options = {}) {
  const existingPieces = options.existingPieces || pieces;
  const extraHypPieces = options.extraHypPieces || [];
  const { counts } = getMoveInventory(player, extraHypPieces);
  const maxMoves = Number.isFinite(options.maxMoves) ? options.maxMoves : Infinity;

  let validPairs = [];

  for (let opp of existingPieces) {
    if (opp.owner === player) continue;

    let targetGhosts = [];
    let seenGhosts = new Set();

    for (let edgeIdx = 0; edgeIdx < 4; edgeIdx++) {
      let edgeMoves = enumerateEdgeMethods(opp, edgeIdx, existingPieces, extraHypPieces);

      for (let g of edgeMoves) {
        let sig = ghostPlacementKey(g);
        if (seenGhosts.has(sig)) continue;
        seenGhosts.add(sig);

        for (let old of targetGhosts) {
          if (old.targetEdge === g.targetEdge) continue;
          if (!canUseGhostPair(old, g, counts)) continue;
          if (!twoGhostsCompatible(old, g)) continue;

          validPairs.push([old, g, opp.id]);

          if (validPairs.length >= maxMoves) {
            return validPairs;
          }
        }

        targetGhosts.push(g);
      }
    }
  }

  return validPairs;
}

/* 只找第一組；給硬性規則過濾與 Minimax 使用，避免建立整個陣列。 */
function findAnySameTargetMove(player, options = {}) {
  let moves = getAllSameTargetMoves(player, {
    ...options,
    maxMoves: 1
  });

  return moves.length > 0 ? moves[0] : null;
}

function findAnySingleMove(player, options = {}) {
  const existingPieces = options.existingPieces || pieces;
  const extraHypPieces = options.extraHypPieces || [];

  for (let opp of existingPieces) {
    if (opp.owner === player) continue;

    for (let edgeIdx = 0; edgeIdx < 4; edgeIdx++) {
      let edgeMoves = enumerateEdgeMethods(opp, edgeIdx, existingPieces, extraHypPieces);
      if (edgeMoves.length > 0) return edgeMoves[0];
    }
  }

  return null;
}

function getRequiredPieceCount(player, extraHypPieces = []) {
  const { counts } = getMoveInventory(player, extraHypPieces);
  const remaining = Object.values(counts).reduce((sum, n) => sum + n, 0);

  if (remaining <= 0) return 0;

  // 開局第一手是特殊單子。
  if (pieces.length === 0 && (!extraHypPieces || extraHypPieces.length === 0)) {
    return 1;
  }

  // 最後一子是特殊單子。
  return remaining === 1 ? 1 : 2;
}

/*
  仲裁與「上一回合兩邊保證」專用。
  若本方尚有兩子，絕不接受跨目標頂鑫例外來替代規則 5 的保證。
*/
function getAllRequiredTurnMoves(player, options = {}) {
  const extraHypPieces = options.extraHypPieces || [];
  const required = getRequiredPieceCount(player, extraHypPieces);

  if (required === 1) {
    return getAllSingleMovesForBoard(player, options).map(g => [g]);
  }

  if (required === 2) {
    return getAllSameTargetMoves(player, options);
  }

  return [];
}

function hasRequiredTurnGuarantee(player, options = {}) {
  const extraHypPieces = options.extraHypPieces || [];
  const required = getRequiredPieceCount(player, extraHypPieces);

  if (required === 0) return true;

  if (required === 1) {
    return !!findAnySingleMove(player, options);
  }

  return !!findAnySameTargetMove(player, options);
}

function getAllValidMoves(player, options = {}) {
  const existingPieces = options.existingPieces || pieces;
  const extraHypPieces = options.extraHypPieces || [];
  const maxPairs = Number.isFinite(options.maxPairs) ? options.maxPairs : Infinity;

  let validPairs = [];
  let { counts, availTypes } = getMoveInventory(player, extraHypPieces);
  let oppPieces = existingPieces.filter(p => p.owner !== player);

  let validGhosts = [];
  let seenGhosts = new Set();

  for (let opp of oppPieces) {
    for (let t of availTypes) {
      for (let flip of [false, true]) {
        for (let i = 0; i < 4; i++) {
          for (let j = 0; j < 4; j++) {
            let res = attachByEdge(
              SHAPE_MAP[t],
              flip,
              j,
              opp.vertices[i],
              opp.vertices[(i + 1) % 4],
              !!opp.isFlipped
            );

            if (!res) continue;

            let gp = {
              vertices: res.vertices,
              type: SHAPE_MAP[t],
              owner: player,
              svgId: t,
              isFlipped: flip,
              edgeOnOpp: i,
              targetId: opp.id,
              myEdge: j,
              targetEdge: i,
              parentId: opp.id,
              level: (opp.level !== undefined ? opp.level : 0) + 1
            };

            if (!isValidGhost(gp, existingPieces)) continue;

            let sig = ghostPlacementKey(gp);
            if (seenGhosts.has(sig)) continue;

            seenGhosts.add(sig);
            validGhosts.push(gp);
          }
        }
      }
    }
  }

  /*
    原本程式在每一個跨目標配對中，
    都反覆對同一顆 g1 / g2 呼叫 simulateScoreGain。
    改為每顆單子最多算一次。
  */
  let singleScoreCache = new Map();

  function ghostScoresForPlayer(g) {
    let key = ghostPlacementKey(g);

    if (!singleScoreCache.has(key)) {
      singleScoreCache.set(key, simulateScoreGain([g])[player] > 0);
    }

    return singleScoreCache.get(key);
  }

  for (let i = 0; i < validGhosts.length; i++) {
    for (let j = i + 1; j < validGhosts.length; j++) {
      let g1 = validGhosts[i];
      let g2 = validGhosts[j];

      if (!canUseGhostPair(g1, g2, counts)) continue;
      if (!twoGhostsCompatible(g1, g2)) continue;

      if (g1.targetId === g2.targetId) {
        if (g1.edgeOnOpp !== g2.edgeOnOpp) {
          validPairs.push([g1, g2, g1.targetId]);

          if (validPairs.length >= maxPairs) {
            return validPairs;
          }
        }

        continue;
      }

      /*
        保留原本 AI 的頂鑫例外判斷語義：
        - 任一單子能為本方得分；
        - 或兩個新子彼此形成頂鑫。
      */
      let g1Scores = ghostScoresForPlayer(g1);
      let g2Scores = ghostScoresForPlayer(g2);

      if (g1Scores || g2Scores || formsTriGolden(g1, g2)) {
        validPairs.push([g1, g2, g1.targetId]);

        if (validPairs.length >= maxPairs) {
          return validPairs;
        }
      }
    }
  }

  return validPairs;
}

function getRegistrySameTargetMoves(player) {
  if (!liveTrackingReady) return [];

  const { counts } = getMoveInventory(player);
  const moves = [];
  const seen = new Set();

  for (let [id, m] of methodRegistry) {
    if (m.forPlayer !== player) continue;

    for (let [otherId] of m.coLive) {
      if (id >= otherId) continue;

      let other = methodRegistry.get(otherId);
      if (!other || other.forPlayer !== player) continue;
      if (m.ownerEdgePieceId !== other.ownerEdgePieceId) continue;
      if (m.edgeIdx === other.edgeIdx) continue;
      if (!canUseGhostPair(m.ghost, other.ghost, counts)) continue;
      if (!twoGhostsCompatible(m.ghost, other.ghost)) continue;

      let key = pairPlacementKey(m.ghost, other.ghost);
      if (seen.has(key)) continue;

      seen.add(key);
      moves.push([m.ghost, other.ghost, m.ownerEdgePieceId]);
    }
  }

  return moves;
}

/*
  根節點保留：
  1. 所有規則 5 的正常兩子同目標走法；
  2. 可為 AI 自己得分的單接跨目標例外；
  3. 可為 AI 自己得分的互頂跨目標例外。

  不再把所有單子做 G² 暴力配對。
*/
function getRegistryAIMovePool(player, baselineMoves) {
  const { counts } = getMoveInventory(player);
  const result = [];
  const seen = new Set();

  function addMove(g1, g2, targetId) {
    if (!g1 || !g2) return;
    if (!canUseGhostPair(g1, g2, counts)) return;
    if (!twoGhostsCompatible(g1, g2)) return;

    let key = pairPlacementKey(g1, g2);
    if (seen.has(key)) return;

    seen.add(key);
    result.push([g1, g2, targetId]);
  }

  baselineMoves.forEach(m => addMove(m[0], m[1], m[2]));

  let methods = [];
  methodRegistry.forEach(m => {
    if (m.forPlayer === player) methods.push(m);
  });

  /*
    頂鑫例外一：
    第一子本身能為 AI 得分，第二子可落到其他目標。
  */
  let ownScoringSingles = methods.filter(m => m.isSingleJie && m.jieScore > 0);

  for (let first of ownScoringSingles) {
    for (let second of methods) {
      if (first.id === second.id) continue;
      if (first.ghost.targetId === second.ghost.targetId) continue;

      addMove(first.ghost, second.ghost, first.ghost.targetId);
    }
  }

  /*
    頂鑫例外二：
    兩顆候選子互頂，且這個互頂可為 AI 得分。
  */
  getMutualDingPairs(player).forEach(pair => {
    if (pair.a.ghost.targetId === pair.b.ghost.targetId) return;

    addMove(pair.a.ghost, pair.b.ghost, pair.a.ghost.targetId);
  });

  return result;
}

let startTime = performance.now();
let searchCount = 0;
lastAIYieldTime = 0;

/*
  先顯示狀態，再等待上一手的增量死活統計完成。
  這樣 UI 有機會先重繪，不會看起來像卡死。
*/
await aiYield(t('ai-thinking-lifestatus'));
await lifeTrackingUpdatePromise;

if (!liveTrackingReady) {
  await aiYield(t('ai-thinking-lifestatus'));
  computeAllLifeStatus();
}

if (cancelAi) {
  aiThinking = false;
  return;
}

/*
  這裡只能檢查規則 5 的「兩邊保證」。
  絕對不能用 getAllValidMoves()，
  因為該函式包含頂鑫例外跨目標走法。
*/
await aiYield(t('ai-thinking-guarantee'));

let sameTargetMoves = getRegistrySameTargetMoves(aiPlayer);

/*
  Registry 理論上已完成；這個精確 fallback 是保險，
  用於 import / undo / 非同步更新剛好被中止的情況。
*/
if (sameTargetMoves.length === 0) {
  sameTargetMoves = getAllSameTargetMoves(aiPlayer);
}

if (sameTargetMoves.length === 0) {
  aiThinking = false;
  aiTriggerArbitrationSuccess();
  return;
}

/*
  正常兩子同目標走法一定保留；
  再補入對 AI 有實際價值的頂鑫例外走法。
*/
let validMoves = getRegistryAIMovePool(aiPlayer, sameTargetMoves);

if (validMoves.length === 0) {
  validMoves = sameTargetMoves;
}

await aiYield(
  t('ai-thinking-candidates', {
    phase:
      currentLang === 'zh'
        ? `增量候選完成：正常 ${sameTargetMoves.length} 種，總候選 ${validMoves.length} 種`
        : `incremental pool ready: baseline ${sameTargetMoves.length}, total ${validMoves.length}`
  })
);

let bestMove = validMoves[0];
let expectedValue = 0;

let oppPlayerNum = currentPlayer === 1 ? 2 : 1;
let sameGhostPlacement = (g1, g2) =>

function wouldOpponentRetainCoLive(g1, g2, oppPlayer, extraHypPieces = []) {
  let hyp = extraHypPieces.concat([g1, g2]);
  let { counts } = getMoveInventory(oppPlayer, hyp);

  for (let [, m] of methodRegistry) {
    if (m.forPlayer !== oppPlayer || m.coLive.size === 0) continue;
    if (!survivesHypotheticalPieces(m.ghost, hyp)) continue;

    for (let [otherId] of m.coLive) {
      let other = methodRegistry.get(otherId);

      if (!other) continue;
      if (!canUseGhostPair(m.ghost, other.ghost, counts)) continue;
      if (!survivesHypotheticalPieces(other.ghost, hyp)) continue;

      return true;
    }
  }

  return false;
}

function pieceHasFreshCoLive(piece, allPieces, extraHypPieces = []) {
  let opp = piece.owner === 1 ? 2 : 1;
  let { counts } = getMoveInventory(opp, extraHypPieces);
  let seen = new Set();
  let ghosts = [];

  for (let edgeIdx = 0; edgeIdx < 4; edgeIdx++) {
    let edgeMoves = enumerateEdgeMethods(piece, edgeIdx, allPieces, extraHypPieces);

    for (let g of edgeMoves) {
      let sig = ghostPlacementKey(g);
      if (seen.has(sig)) continue;
      seen.add(sig);

      for (let old of ghosts) {
        if (old.targetEdge === g.targetEdge) continue;
        if (!canUseGhostPair(old, g, counts)) continue;
        if (twoGhostsCompatible(old, g)) return true;
      }

      ghosts.push(g);
    }
  }

  return false;
}

function opponentGuaranteeCacheKey(g1, g2, oppPlayer, extraHypPieces) {
  let pair = [ghostPlacementKey(g1), ghostPlacementKey(g2)].sort().join('||');
  let extra = (extraHypPieces || [])
    .map(ghostPlacementKey)
    .sort()
    .join('||');

  return oppPlayer + '::' + pair + '::' + extra;
}

/*
  true = 此手會讓對手在規則 5 下可仲裁獲勝。
  注意：頂鑫跨目標例外不能作為「兩邊保證」的替代。
*/
function probeOpponentGuaranteeAfterMove(g1, g2, oppPlayer, realBoardPieces, extraHypPieces = []) {
  let key = opponentGuaranteeCacheKey(g1, g2, oppPlayer, extraHypPieces);
  let cached = opponentGuaranteeCache.get(key);

  if (cached) {
    return { ...cached, cached: true };
  }

  let allHyp = extraHypPieces.concat([g1, g2]);
  let required = getRequiredPieceCount(oppPlayer, allHyp);
  let result;

  // 棋局已結束，無下一回合需要保證。
  if (required === 0) {
    result = { trap: false, source: 'terminal' };
    opponentGuaranteeCache.set(key, result);
    return result;
  }

  // 後手最後一子只需驗證是否有一個合法單子。
  if (required === 1) {
    let hasSingle = withHypotheticalPieces(allHyp, () =>
      hasRequiredTurnGuarantee(oppPlayer, { extraHypPieces: allHyp })
    );

    result = {
      trap: !hasSingle,
      source: 'exact'
    };

    opponentGuaranteeCache.set(key, result);
    return result;
  }

  /*
    快速路徑 1：
    現有 registry 裡已有一組對方共活，且落下 g1/g2 後仍存活。
  */
  if (wouldOpponentRetainCoLive(g1, g2, oppPlayer, extraHypPieces)) {
    result = { trap: false, source: 'existing' };
    opponentGuaranteeCache.set(key, result);
    return result;
  }

  /*
    快速路徑 2：
    新下的 g1 或 g2 本身可為對手提供全新的兩邊共活。
  */
  let afterPieces = realBoardPieces.concat(allHyp);

  if (
    pieceHasFreshCoLive(g1, afterPieces, allHyp) ||
    pieceHasFreshCoLive(g2, afterPieces, allHyp)
  ) {
    result = { trap: false, source: 'fresh' };
    opponentGuaranteeCache.set(key, result);
    return result;
  }

  /*
    最終精確 fallback：
    只檢查規則 5 的同目標、不同邊兩子組合；
    不再錯誤呼叫包含頂鑫例外的 getAllValidMoves()。
  */
  let hasGuaranteedTurn = withHypotheticalPieces(allHyp, () =>
    hasRequiredTurnGuarantee(oppPlayer, { extraHypPieces: allHyp })
  );

  result = {
    trap: !hasGuaranteedTurn,
    source: 'exact'
  };

  opponentGuaranteeCache.set(key, result);
  return result;
}

function moveLeavesOpponentArbitrationTrap(g1, g2, oppPlayer, realBoardPieces, extraHypPieces = []) {
  return probeOpponentGuaranteeAfterMove(
    g1,
    g2,
    oppPlayer,
    realBoardPieces,
    extraHypPieces
  ).trap;
}

function filterMovesKeepingOpponentAlive(moves, oppPlayer, realBoardPieces, extraHypPieces = []) {
  if (!moves || moves.length === 0) return [];

  let kept = [];

  for (let mv of moves) {
    let probe = probeOpponentGuaranteeAfterMove(
      mv[0],
      mv[1],
      oppPlayer,
      realBoardPieces,
      extraHypPieces
    );

    if (!probe.trap) kept.push(mv);
  }

  // 所有走法都會讓對方仲裁勝時，維持原流程：仍須選一手落子。
  return kept.length > 0 ? kept : moves;
}

/*
  根節點專用非同步版本：
  每隔約 80ms 讓出主執行緒，讓訊息框與取消 AI 按鈕真正可見、可回應。
*/
async function filterMovesKeepingOpponentAliveWithProgress(
  moves,
  oppPlayer,
  realBoardPieces,
  extraHypPieces = []
) {
  if (!moves || moves.length === 0) return [];

  let kept = [];
  let stats = {
    existing: 0,
    fresh: 0,
    exact: 0
  };

  await aiYield(
    t('ai-thinking-colive-filter', {
      done: 0,
      total: moves.length,
      kept: 0,
      fast: 0,
      fresh: 0,
      exact: 0
    })
  );

  for (let i = 0; i < moves.length; i++) {
    if (cancelAi) return moves;

    let mv = moves[i];

    let probe = probeOpponentGuaranteeAfterMove(
      mv[0],
      mv[1],
      oppPlayer,
      realBoardPieces,
      extraHypPieces
    );

    if (!probe.trap) kept.push(mv);

    if (probe.source === 'existing') stats.existing++;
    else if (probe.source === 'fresh') stats.fresh++;
    else if (probe.source === 'exact') stats.exact++;

    await aiMaybeYield(
      t('ai-thinking-colive-filter', {
        done: i + 1,
        total: moves.length,
        kept: kept.length,
        fast: stats.existing,
        fresh: stats.fresh,
        exact: stats.exact
      }),
      80
    );
  }

  return kept.length > 0 ? kept : moves;
}

function applyArbMove(index) {
  let move = arbValidMoves[index];
  if (!move || move.length === 0) return;

  tempPieces.forEach(tp => {
    piecesCount[tp.svgId]++;
  });

  let previewPieces = move.map((g, idx) => {
    let copy = JSON.parse(JSON.stringify(g));
    copy.id = 'p_arb_' + (idx + 1);
    return copy;
  });

  previewPieces.forEach(g => {
    piecesCount[g.svgId]--;
  });

  tempPieces = previewPieces;

  renderBoard();
  updateUI();
}

function isValidGhost(gp, existingPieces) {
  let edgeOverlapCount = 0;
  let perfectMatchCount = 0;
  let attachedVertices = [false, false, false, false];
  let gpSat = getSAT(gp);
  let nearbyPieces = [];

  for (let exist of existingPieces) {
    let col = checkSATCollision(gpSat, getSAT(exist));

    if (col === 'separated') continue;
    if (col === 'overlap') return false;

    nearbyPieces.push(exist);

    for (let ei = 0; ei < 4; ei++) {
      for (let ej = 0; ej < 4; ej++) {
        let gpS = gp.vertices[ei];
        let gpE = gp.vertices[(ei + 1) % 4];
        let exS = exist.vertices[ej];
        let exE = exist.vertices[(ej + 1) % 4];

        if (!segmentsOverlapAsEdges(gpS, gpE, exS, exE)) continue;

        edgeOverlapCount++;
        if (edgeOverlapCount > 1) return false;

        if (segmentsPerfectlyMatch(gpS, gpE, exS, exE)) {
          perfectMatchCount++;
          if (perfectMatchCount > 1) return false;

          attachedVertices[ei] = true;
          attachedVertices[(ei + 1) % 4] = true;
        }
      }
    }
  }

  if (edgeOverlapCount !== 1 || perfectMatchCount !== 1) {
    return false;
  }

  /*
    只檢查 SAT 接觸到的棋子；
    已被 SAT 判定 separated 的棋子不可能與 gp 的端點重合。
  */
  for (let vi = 0; vi < 4; vi++) {
    if (attachedVertices[vi]) continue;

    for (let exist of nearbyPieces) {
      for (let vj = 0; vj < 4; vj++) {
        if (pointsEqual(gp.vertices[vi], exist.vertices[vj])) {
          return false;
        }
      }
    }
  }

  return true;
}

function getTreeDistance(A, B, allP, pieceById = null) {
  const byId = pieceById || new Map(allP.map(p => [p.id, p]));

  let pathA = [A.id];
  let currA = A;

  while (currA.parentId !== undefined && currA.parentId !== null) {
    currA = byId.get(currA.parentId);
    if (!currA) break;
    pathA.push(currA.id);
  }

  let pathB = [B.id];
  let currB = B;

  while (currB.parentId !== undefined && currB.parentId !== null) {
    currB = byId.get(currB.parentId);
    if (!currB) break;
    pathB.push(currB.id);
  }

  let lca = null;
  let i = pathA.length - 1;
  let j = pathB.length - 1;

  while (i >= 0 && j >= 0 && pathA[i] === pathB[j]) {
    lca = pathA[i];
    i--;
    j--;
  }

  if (lca === null) return null;

  let dist = i + 1 + (j + 1) - 1;

  let finalPath = [];

  for (let k = 0; k <= j + 1; k++) {
    let p = byId.get(pathB[k]);
    if (p) finalPath.push(p);
  }

  for (let k = i; k >= 0; k--) {
    let p = byId.get(pathA[k]);
    if (p) finalPath.push(p);
  }

  return {
    dist,
    path: finalPath
  };
}

scoringAffectedMethodIds.forEach(id => {
  let m = methodRegistry.get(id);
  if (!m) return;

  let gain = simulateScoreGain([m.ghost]);

  if (gain[1] > 0 || gain[2] > 0) {
    m.isSingleJie = true;
    m.jieScore = gain[m.forPlayer];
    m.jieScoreOpp = gain[m.forPlayer === 1 ? 2 : 1];
  } else {
    m.isSingleJie = false;
    m.jieScore = 0;
    m.jieScoreOpp = 0;
  }
});