// =============================================================================
// SearchState 增量連接樹／樹距離
// =============================================================================

function buildSearchTopology(boardPieces) {
  const pieceById = new Map();
  const parentById = new Map();
  const depthById = new Map();

  for (const piece of boardPieces) {
    pieceById.set(piece.id, piece);
    parentById.set(
      piece.id,
      piece.parentId !== undefined && piece.parentId !== null
        ? piece.parentId
        : null
    );
  }

  function resolveDepth(id, visiting = new Set()) {
    if (depthById.has(id)) return depthById.get(id);
    if (visiting.has(id)) return 0;

    visiting.add(id);

    const parentId = parentById.get(id);
    let depth = 0;

    if (parentId !== null && parentId !== undefined && pieceById.has(parentId)) {
      depth = resolveDepth(parentId, visiting) + 1;
    }

    visiting.delete(id);
    depthById.set(id, depth);
    return depth;
  }

  for (const piece of boardPieces) {
    resolveDepth(piece.id);
  }

  return {
    pieceById,
    parentById,
    depthById
  };
}

function ensureSearchTopology(state) {
  if (!state._topology) {
    state._topology = buildSearchTopology(state.boardPieces);
  }

  return state._topology;
}

function extendSearchTopology(parentTopology, placedPieces) {
  const topology = {
    pieceById: new Map(parentTopology.pieceById),
    parentById: new Map(parentTopology.parentById),
    depthById: new Map(parentTopology.depthById)
  };

  for (const piece of placedPieces) {
    const parentId =
      piece.parentId !== undefined && piece.parentId !== null
        ? piece.parentId
        : null;

    topology.pieceById.set(piece.id, piece);
    topology.parentById.set(piece.id, parentId);

    const depth =
      parentId !== null && topology.depthById.has(parentId)
        ? topology.depthById.get(parentId) + 1
        : 0;

    topology.depthById.set(piece.id, depth);
  }

  return topology;
}

/*
 * 使用已保存的 parentById/pieceById 計算路徑。
 *
 * 回傳路徑方向與原 getTreeDistance 一致：
 * 鑫棋 B -> 共同祖先 -> 頂棋 A。
 */
function getIndexedTreeDistance(A, B, topology) {
  if (!A || !B) return null;
  if (!topology.pieceById.has(A.id) || !topology.pieceById.has(B.id)) {
    return null;
  }

  const ancestorsOfA = new Map();
  const pathA = [];

  let currentId = A.id;
  let guard = 0;

  while (
    currentId !== null &&
    currentId !== undefined &&
    guard++ <= topology.pieceById.size + 1
  ) {
    ancestorsOfA.set(currentId, pathA.length);
    pathA.push(currentId);
    currentId = topology.parentById.get(currentId);
  }

  const pathB = [];
  currentId = B.id;
  guard = 0;

  let lcaId = null;

  while (
    currentId !== null &&
    currentId !== undefined &&
    guard++ <= topology.pieceById.size + 1
  ) {
    pathB.push(currentId);

    if (ancestorsOfA.has(currentId)) {
      lcaId = currentId;
      break;
    }

    currentId = topology.parentById.get(currentId);
  }

  if (lcaId === null) return null;

  const aToLcaIndex = ancestorsOfA.get(lcaId);

  // B -> ... -> LCA
  const finalIds = pathB.slice();

  // LCA 的下一顆 -> ... -> A
  for (let i = aToLcaIndex - 1; i >= 0; i--) {
    finalIds.push(pathA[i]);
  }

  const finalPath = finalIds
    .map(id => topology.pieceById.get(id))
    .filter(Boolean);

  /*
   * 路徑上排除頂棋、鑫棋自身後的中間棋子數。
   * 父子直接相接時 finalPath.length === 2，因此得分為 0。
   */
  const dist = Math.max(0, finalPath.length - 2);

  return {
    dist,
    path: finalPath
  };
}

/*
 * 增量計分。
 *
 * 正確性依據：
 * 每一次 applySearchTurnToState 都會把本回合所有新形成的頂鑫 key
 * 加入 scoredVictims。因此下一回合開始前，所有舊棋－舊棋結構都已經
 * 被封存，不需要再次掃描。
 *
 * 新的未封存頂鑫只能涉及本回合新增棋子：
 * 1. 新頂棋 -> 舊鑫棋
 * 2. 舊頂棋 -> 新鑫棋
 * 3. 新頂棋 -> 新鑫棋
 */
function adjudicateSearchTurn(state, placedPieces) {
  const normalizedPlacedPieces = placedPieces.map(piece => {
    preparePieceSAT(piece);
    return piece;
  });

  const allPieces = state.boardPieces.concat(normalizedPlacedPieces);
  const newIds = new Set(normalizedPlacedPieces.map(piece => piece.id));
  const dingMap = new Map();

  const topology = extendSearchTopology(
    ensureSearchTopology(state),
    normalizedPlacedPieces
  );

  /*
   * 只檢查至少一端是新棋子的有向棋子對。
   * 由原本 O((n+k)^2) 降為 O(k*n+k^2)，k 通常為 1 或 2。
   */
  for (const dinger of allPieces) {
    for (const victim of allPieces) {
      if (dinger.id === victim.id) continue;

      const involvesNew =
        newIds.has(dinger.id) || newIds.has(victim.id);

      if (!involvesNew) continue;

      if (
        checkSATCollision(getSAT(dinger), getSAT(victim)) === 'separated'
      ) {
        continue;
      }

      const dingVertices = [];

      for (const vertex of dinger.vertices) {
        let touchesEdge = false;

        for (let edgeIndex = 0; edgeIndex < 4; edgeIndex++) {
          if (
            pointOnOpenSegment(
              vertex,
              victim.vertices[edgeIndex],
              victim.vertices[(edgeIndex + 1) % 4]
            )
          ) {
            touchesEdge = true;
            break;
          }
        }

        if (touchesEdge) {
          dingVertices.push(vertex);
        }
      }

      if (dingVertices.length === 0) continue;

      const treeResult = getIndexedTreeDistance(
        dinger,
        victim,
        topology
      );

      if (!treeResult || treeResult.dist < 0) continue;

      for (const vertex of dingVertices) {
        const key = victim.id + '_' + vertex.join('_');

        if (state.scoredVictims.has(key)) continue;

        if (!dingMap.has(key)) {
          dingMap.set(key, []);
        }

        dingMap.get(key).push({
          dinger,
          victim,
          dist: treeResult.dist,
          path: treeResult.path
        });
      }
    }
  }

  const gain = { 1: 0, 2: 0 };
  const newScoredKeys = [];
  const records = [];
  const rings = [];

  for (const [key, candidates] of dingMap) {
    let best = null;

    for (const candidate of candidates) {
      if (!best || candidate.dist < best.dist) {
        best = candidate;
      }
    }

    if (!best) continue;

    let scorer = 0;

    if (state.scoringMode === 0) {
      scorer = best.dinger.owner;
    } else if (state.scoringMode === 1) {
      scorer = best.victim.owner;
    } else if (
      state.scoringMode === 2 &&
      best.dinger.owner === best.victim.owner
    ) {
      scorer = best.dinger.owner;
    }

    if (best.dist > 0 && scorer > 0) {
      gain[scorer] += best.dist;

      rings.push({
        path: best.path,
        scorer
      });
    }

    /*
     * 保持原規則：
     * 距離為 0 也要封存這個鑫棋端點。
     */
    newScoredKeys.push(key);

    records.push({
      key,
      dinger: best.dinger,
      victim: best.victim,
      dist: best.dist,
      score: best.dist,
      scorer,
      path: best.path,
      involvesNew: true
    });
  }

  return {
    gain,
    newScoredKeys,
    records,
    rings,
    topology,
    hasScoringStructure: records.some(record => record.score > 0)
  };
}

// =============================================================================
// 統一增量活法／共活／單接／雙接／合法回合引擎
// =============================================================================

function createPlayerSearchCatalog() {
  return {
    // placementSignature -> ghost
    singles: new Map(),

    // placementSignature -> 單子計分資訊
    singleMeta: new Map(),

    // turnSignature -> pair record
    // null 表示尚未建立。
    legalPairs: null,

    // turnSignature -> analyseSearchMove 結果
    analysisByMove: new Map(),

    turnSet: null
  };
}

function createStateViewForPlayer(state, player) {
  if (state.mover === player) return state;

  return {
    ...state,
    mover: player
  };
}

function setsEqual(a, b) {
  if (a === b) return true;
  if (!a || !b || a.size !== b.size) return false;

  for (const value of a) {
    if (!b.has(value)) return false;
  }

  return true;
}

function singleMetaEqual(a, b) {
  if (!a || !b) return false;

  return (
    a.hasScoringStructure === b.hasScoringStructure &&
    a.gain1 === b.gain1 &&
    a.gain2 === b.gain2 &&
    setsEqual(a.scoreKeys, b.scoreKeys)
  );
}

function singleMetaTouchesScoredKeys(meta, scoredKeys) {
  if (!meta || !meta.scoreKeys || scoredKeys.size === 0) {
    return false;
  }

  for (const key of meta.scoreKeys) {
    if (scoredKeys.has(key)) return true;
  }

  return false;
}

function calculateSinglePlacementMeta(state, ghost) {
  const adjudication = adjudicateSearchTurn(state, [ghost]);

  return {
    hasScoringStructure: adjudication.hasScoringStructure,
    gain1: adjudication.gain[1],
    gain2: adjudication.gain[2],
    scoreKeys: new Set(adjudication.newScoredKeys)
  };
}

/*
 * 只在指定 targetPieces 的邊上生成活法。
 *
 * 全盤初建時 targetPieces 是全部對方棋。
 * 子節點增量更新時 targetPieces 只包含本回合新增的對方棋。
 */
function enumerateSinglePlacementsOnTargets(
  state,
  player,
  targetPieces,
  existingSignatures = null
) {
  const result = [];
  const seen = existingSignatures || new Set();

  const tileIds = getPlayerTileIds(player).filter(
    tileId => (state.counts[tileId] || 0) > 0
  );

  for (const target of targetPieces) {
    if (target.owner === player) continue;

    for (const tileId of tileIds) {
      for (const flip of [false, true]) {
        for (let targetEdge = 0; targetEdge < 4; targetEdge++) {
          for (let myEdge = 0; myEdge < 4; myEdge++) {
            const attached = attachByEdge(
              SHAPE_MAP[tileId],
              flip,
              myEdge,
              target.vertices[targetEdge],
              target.vertices[(targetEdge + 1) % 4],
              !!target.isFlipped
            );

            if (!attached) continue;

            const ghost = {
              id: allocateHypothesisPieceId(),
              vertices: attached.vertices,
              type: SHAPE_MAP[tileId],
              owner: player,
              svgId: tileId,
              isFlipped: flip,
              edgeOnOpp: targetEdge,
              targetId: target.id,
              myEdge,
              targetEdge,
              parentId: target.id,
              level:
                (target.level !== undefined ? target.level : 0) + 1
            };

            preparePieceSAT(ghost);

            const validation = validatePlacementGeometry(
              ghost,
              state.boardPieces,
              player
            );

            if (!validation.ok) continue;

            const signature = piecePlacementSignature(ghost);

            if (seen.has(signature)) continue;

            seen.add(signature);
            result.push(ghost);
          }
        }
      }
    }
  }

  return result;
}

function buildFullPlayerSingleCatalog(state, player) {
  const view = createStateViewForPlayer(state, player);
  const catalog = createPlayerSearchCatalog();

  if (view.boardPieces.length === 0) {
    return catalog;
  }

  const targets = view.boardPieces.filter(
    piece => piece.owner !== player
  );

  const singles = enumerateSinglePlacementsOnTargets(
    view,
    player,
    targets
  );

  for (const ghost of singles) {
    const signature = piecePlacementSignature(ghost);

    catalog.singles.set(signature, ghost);
    catalog.singleMeta.set(
      signature,
      calculateSinglePlacementMeta(view, ghost)
    );
  }

  return catalog;
}

function makeLegalPairRecord(
  state,
  catalog,
  first,
  second
) {
  if (!pairFitsInventory(state, first, second)) {
    return null;
  }

  if (!twoGhostsCompatible(first, second)) {
    return null;
  }

  const firstTargetEdge =
    first.targetEdge !== undefined
      ? first.targetEdge
      : first.edgeOnOpp;

  const secondTargetEdge =
    second.targetEdge !== undefined
      ? second.targetEdge
      : second.edgeOnOpp;

  const sameTarget = first.targetId === second.targetId;
  const mutual = formsTriGolden(first, second);

  if (sameTarget) {
    if (firstTargetEdge === secondTargetEdge) {
      return null;
    }

    return {
      move: [first, second],
      aSig: piecePlacementSignature(first),
      bSig: piecePlacementSignature(second),
      sameTarget: true,
      mutual
    };
  }

  const firstSignature = piecePlacementSignature(first);
  const secondSignature = piecePlacementSignature(second);

  const firstMeta = catalog.singleMeta.get(firstSignature);
  const secondMeta = catalog.singleMeta.get(secondSignature);

  /*
   * 跨目標例外至少要有：
   * 1. 第一子單接；
   * 2. 第二子單接；
   * 3. 兩子互頂。
   */
  if (
    !(firstMeta && firstMeta.hasScoringStructure) &&
    !(secondMeta && secondMeta.hasScoringStructure) &&
    !mutual
  ) {
    return null;
  }

  /*
   * 最終仍以正式計分語義判定：
   * 必須是尚未封存且距離大於 0 的頂鑫結構。
   */
  const adjudication = adjudicateSearchTurn(state, [
    first,
    second
  ]);

  if (!adjudication.hasScoringStructure) {
    return null;
  }

  return {
    move: [first, second],
    aSig: firstSignature,
    bSig: secondSignature,
    sameTarget: false,
    mutual
  };
}

function buildFullLegalPairCatalog(state, catalog) {
  const singles = Array.from(catalog.singles.values());
  const pairs = new Map();

  for (let i = 0; i < singles.length; i++) {
    for (let j = i + 1; j < singles.length; j++) {
      const record = makeLegalPairRecord(
        state,
        catalog,
        singles[i],
        singles[j]
      );

      if (!record) continue;

      pairs.set(turnSignature(record.move), record);
    }
  }

  return pairs;
}

/*
 * 父節點活法在加入新棋後只可能：
 * 1. 因幾何衝突而失效；
 * 2. 因棋種耗盡而失效；
 * 3. 因接觸新棋而新增／改變單接計分；
 * 4. 因 scoredVictims 新增而失去原有單接。
 *
 * 不會有「舊目標上原本非法的幾何落點因加入棋子而變合法」的情況。
 */
function derivePlayerSingleCatalog(
  parentCatalog,
  childState,
  player,
  newPieces,
  newScoredKeys
) {
  const view = createStateViewForPlayer(childState, player);
  const catalog = createPlayerSearchCatalog();

  const changedSignatures = new Set();
  const addedSignatures = new Set();
  const scoredKeySet = new Set(newScoredKeys || []);

  for (const [signature, ghost] of parentCatalog.singles) {
    if ((view.counts[ghost.svgId] || 0) <= 0) {
      continue;
    }

    let survives = true;

    for (const newPiece of newPieces) {
      if (ghostConflictsWithPiece(ghost, newPiece)) {
        survives = false;
        break;
      }
    }

    if (!survives) continue;

    catalog.singles.set(signature, ghost);

    const oldMeta = parentCatalog.singleMeta.get(signature);

    const geometricallyAffected = newPieces.some(
      newPiece =>
        checkSATCollision(getSAT(ghost), getSAT(newPiece)) !==
        'separated'
    );

    const scoreSealAffected = singleMetaTouchesScoredKeys(
      oldMeta,
      scoredKeySet
    );

    if (
      !oldMeta ||
      geometricallyAffected ||
      scoreSealAffected
    ) {
      const newMeta = calculateSinglePlacementMeta(view, ghost);

      catalog.singleMeta.set(signature, newMeta);

      if (!singleMetaEqual(oldMeta, newMeta)) {
        changedSignatures.add(signature);
      }
    } else {
      catalog.singleMeta.set(signature, oldMeta);
    }
  }

  /*
   * 新落下的對方棋子才會為 player 新增可貼合目標。
   */
  const newTargets = newPieces.filter(
    piece => piece.owner !== player
  );

  if (newTargets.length > 0) {
    const seen = new Set(catalog.singles.keys());

    const addedGhosts = enumerateSinglePlacementsOnTargets(
      view,
      player,
      newTargets,
      seen
    );

    for (const ghost of addedGhosts) {
      const signature = piecePlacementSignature(ghost);

      catalog.singles.set(signature, ghost);
      catalog.singleMeta.set(
        signature,
        calculateSinglePlacementMeta(view, ghost)
      );

      addedSignatures.add(signature);
      changedSignatures.add(signature);
    }
  }

  return {
    catalog,
    changedSignatures,
    addedSignatures
  };
}

function deriveLegalPairCatalog(
  parentCatalog,
  childCatalog,
  childState,
  changedSignatures
) {
  /*
   * 父節點還沒建立 pair catalog 時，不能增量繼承；
   * 呼叫端之後會按需要完整建立一次。
   */
  if (parentCatalog.legalPairs === null) {
    return null;
  }

  const result = new Map();

  /*
   * 第一部分：保留未失效的舊合法配對。
   */
  for (const [pairSignature, oldRecord] of parentCatalog.legalPairs) {
    const first = childCatalog.singles.get(oldRecord.aSig);
    const second = childCatalog.singles.get(oldRecord.bSig);

    if (!first || !second) continue;
    if (!pairFitsInventory(childState, first, second)) continue;

    const affected =
      changedSignatures.has(oldRecord.aSig) ||
      changedSignatures.has(oldRecord.bSig);

    if (affected) {
      const newRecord = makeLegalPairRecord(
        childState,
        childCatalog,
        first,
        second
      );

      if (newRecord) {
        result.set(turnSignature(newRecord.move), newRecord);
      }
    } else {
      result.set(pairSignature, {
        ...oldRecord,
        move: [first, second]
      });
    }
  }

  /*
   * 第二部分：
   * 只把「新增或單接狀態改變的活法」與目前全部活法配對。
   *
   * 這同時補上兩類新合法回合：
   * 1. 新棋四條邊產生的新活法；
   * 2. 舊活法因接觸新棋而首次取得跨目標計分例外。
   */
  const allEntries = Array.from(childCatalog.singles.entries());
  const checked = new Set();

  for (const changedSignature of changedSignatures) {
    const first = childCatalog.singles.get(changedSignature);
    if (!first) continue;

    for (const [otherSignature, second] of allEntries) {
      if (changedSignature === otherSignature) continue;

      const orderedKey =
        changedSignature < otherSignature
          ? changedSignature + '||' + otherSignature
          : otherSignature + '||' + changedSignature;

      if (checked.has(orderedKey)) continue;
      checked.add(orderedKey);

      const record = makeLegalPairRecord(
        childState,
        childCatalog,
        first,
        second
      );

      const pairSignature = turnSignature([first, second]);

      if (record) {
        result.set(pairSignature, record);
      } else {
        result.delete(pairSignature);
      }
    }
  }

  return result;
}

function buildRootSearchIndex(state) {
  return {
    players: {
      1: buildFullPlayerSingleCatalog(state, 1),
      2: buildFullPlayerSingleCatalog(state, 2)
    }
  };
}

function deriveSearchIndex(parentState, childState, delta) {
  const parentIndex = ensureSearchIndex(parentState);
  const result = {
    players: {}
  };

  for (const player of [1, 2]) {
    const parentCatalog = parentIndex.players[player];

    const derived = derivePlayerSingleCatalog(
      parentCatalog,
      childState,
      player,
      delta.placedPieces,
      delta.newScoredKeys
    );

    derived.catalog.legalPairs = deriveLegalPairCatalog(
      parentCatalog,
      derived.catalog,
      createStateViewForPlayer(childState, player),
      derived.changedSignatures
    );

    result.players[player] = derived.catalog;
  }

  return result;
}

function ensureSearchIndex(state) {
  if (state._searchIndex) {
    return state._searchIndex;
  }

  if (state._searchDelta && state._searchDelta.parentState) {
    state._searchIndex = deriveSearchIndex(
      state._searchDelta.parentState,
      state,
      state._searchDelta
    );
  } else {
    state._searchIndex = buildRootSearchIndex(state);
  }

  return state._searchIndex;
}

function ensurePlayerPairCatalog(state, player) {
  const index = ensureSearchIndex(state);
  const catalog = index.players[player];

  if (catalog.legalPairs === null) {
    const view = createStateViewForPlayer(state, player);

    catalog.legalPairs = buildFullLegalPairCatalog(
      view,
      catalog
    );

    catalog.turnSet = null;
  }

  return catalog;
}

/*
 * 統一回合集合。
 *
 * singlePlacements：全部活法
 * coLiveTurns：全部共活
 * singleJieTurns：至少有一子形成單接的合法回合
 * doubleJieTurns：兩子互頂的合法回合
 * legalTurns：包含共活及跨目標頂鑫例外的全部正常合法回合
 * arbitrationTurns：仲裁防禦回合；目前等同 coLiveTurns
 */
function generateIncrementalTurnSet(state) {
  const required = getRequiredPiecesForState(state);

  if (state.boardPieces.length === 0) {
    return {
      singlePlacements: [],
      legalTurns: [],
      coLiveTurns: [],
      arbitrationTurns: [],
      singleJieTurns: [],
      doubleJieTurns: []
    };
  }

  const index = ensureSearchIndex(state);
  const catalog = index.players[state.mover];

  if (catalog.turnSet) {
    return catalog.turnSet;
  }

  const singles = Array.from(catalog.singles.values());

  if (required === 1) {
    const singleTurns = singles.map(ghost => [ghost]);

    catalog.turnSet = {
      singlePlacements: singles,
      legalTurns: singleTurns,
      coLiveTurns: singleTurns,
      arbitrationTurns: singleTurns,
      singleJieTurns: singleTurns.filter(move => {
        const meta = catalog.singleMeta.get(
          piecePlacementSignature(move[0])
        );

        return !!(meta && meta.hasScoringStructure);
      }),
      doubleJieTurns: []
    };

    return catalog.turnSet;
  }

  /*
   * 根節點同時建立雙方 pair catalog。
   * 之後每個子節點即可從父節點的雙方 catalog 增量派生，
   * 避免第一層每個不同子分支都為對手重新做平方級配對。
   */
  if (!state._searchDelta) {
    ensurePlayerPairCatalog(state, 1);
    ensurePlayerPairCatalog(state, 2);
  } else {
    ensurePlayerPairCatalog(state, state.mover);
  }

  const activeCatalog =
    ensureSearchIndex(state).players[state.mover];

  const records = Array.from(activeCatalog.legalPairs.values());
  const legalTurns = records.map(record => record.move);

  const coLiveTurns = records
    .filter(record => record.sameTarget)
    .map(record => record.move);

  const singleJieTurns = records
    .filter(record => {
      const firstMeta = activeCatalog.singleMeta.get(
        record.aSig
      );

      const secondMeta = activeCatalog.singleMeta.get(
        record.bSig
      );

      return (
        (firstMeta && firstMeta.hasScoringStructure) ||
        (secondMeta && secondMeta.hasScoringStructure)
      );
    })
    .map(record => record.move);

  const doubleJieTurns = records
    .filter(record => record.mutual)
    .map(record => record.move);

  activeCatalog.turnSet = {
    singlePlacements: singles,
    legalTurns,
    coLiveTurns,
    arbitrationTurns: coLiveTurns,
    singleJieTurns,
    doubleJieTurns
  };

  return activeCatalog.turnSet;
}

/*
 * 舊函式名稱保留成相容包裝。
 * UI、仲裁、MCTS、minimax 不需要改變呼叫介面。
 */
function generateLegalSinglePlacements(
  state,
  player = state.mover
) {
  const index = ensureSearchIndex(state);

  return Array.from(index.players[player].singles.values());
}

function pairFitsInventory(state, first, second) {
  if (first.svgId !== second.svgId) {
    return (
      (state.counts[first.svgId] || 0) >= 1 &&
      (state.counts[second.svgId] || 0) >= 1
    );
  }

  return (state.counts[first.svgId] || 0) >= 2;
}

function generateLegalTurns(state) {
  return generateIncrementalTurnSet(state).legalTurns;
}

function generateArbitrationDefenceTurns(state) {
  return generateIncrementalTurnSet(state).arbitrationTurns;
}

function hasArbitrationDefence(state) {
  if (isSearchGameComplete(state)) {
    return true;
  }

  /*
   * 這裡不再另外生成共活。
   * 它和正常合法回合來自同一份增量回合集合。
   */
  return (
    generateIncrementalTurnSet(state).arbitrationTurns.length > 0
  );
}

/*
 * 不在 apply 時立即生成子節點活法，避免 MCTS／minimax
 * 僅為排序而套用所有候選時，替每個尚未真正展開的子節點做多餘工作。
 *
 * 子節點第一次呼叫 generateIncrementalTurnSet 時，
 * 才從父節點索引按這兩顆新棋做增量派生。
 */
next._searchIndex = null;

next._searchDelta = state._searchIndex
  ? {
      parentState: state,
      placedPieces: placedPieces.slice(),
      newScoredKeys: adjudication.newScoredKeys.slice()
    }
  : null;

next.lastTurnPieces = placedPieces.slice();
next.turnNumber++;
next.mover = next.mover === 1 ? 2 : 1;

next._searchIndex = null;

next._searchDelta = state._searchIndex
  ? {
      parentState: state,
      placedPieces: placedPieces.slice(),
      newScoredKeys: adjudication.newScoredKeys.slice()
    }
  : null;

return {
  state: next,
  placedPieces,
  adjudication
};

function analyseSearchMove(state, move) {
  /*
   * 確保合法回合、單接、雙接及共活都來自同一份增量集合。
   */
  generateIncrementalTurnSet(state);

  const index = ensureSearchIndex(state);
  const catalog = index.players[state.mover];
  const signature = turnSignature(move);

  const cached = catalog.analysisByMove.get(signature);
  if (cached) return cached;

  const mover = state.mover;
  const opponent = mover === 1 ? 2 : 1;

  const applied = applySearchTurnToState(state, move, {
    validate: false
  });

  const moverGain =
    applied.adjudication.gain[mover] -
    applied.adjudication.gain[opponent];

  let singleJieCount = 0;

  for (const piece of move) {
    const pieceSignature = piecePlacementSignature(piece);
    const meta = catalog.singleMeta.get(pieceSignature);

    if (meta && meta.hasScoringStructure) {
      singleJieCount++;
    }
  }

  const isDoubleJie =
    move.length === 2 &&
    formsTriGolden(move[0], move[1]) &&
    applied.adjudication.hasScoringStructure;

  const result = {
    childState: applied.state,
    adjudication: applied.adjudication,
    moverGain,
    singleJieCount,
    isDoubleJie,
    isTactical: singleJieCount > 0 || isDoubleJie
  };

  catalog.analysisByMove.set(signature, result);
  return result;
}

const child = analyseSearchMove(
  rootState,
  move
).childState;

const value = alphaBetaState(
  child,
  depth - 1,
  -Infinity,
  Infinity
);

/*
 * 一次增量生成同時取得：
 * - 全部活法
 * - 全部共活
 * - 全部單接
 * - 全部雙接
 * - 全部正常合法回合
 *
 * 不再分別呼叫兩套生成器。
 */
const rootTurnSet = generateIncrementalTurnSet(rootState);

const arbitrationDefences =
  rootTurnSet.arbitrationTurns;

if (
  !isSearchGameComplete(rootState) &&
  arbitrationDefences.length === 0
) {
  aiThinking = false;
  aiTriggerArbitrationSuccess();
  return;
}

let rootMoves = rootTurnSet.legalTurns.slice();

      /*
       * 正式盤面的 SearchState。
       *
       * incremental：
       *   已完成的持久增量索引。
       *
       * incrementalPromise：
       *   人類對人類時也會在背景依序完成的增量更新。
       *
       * 每個 SearchState 只代表一個不可變局面。
       * undo/redo 直接恢復相應 SearchState，不清空後重算。
       */
      let committedSearchState = null;
      let committedStateVersion = 0;

      function yieldIncrementalBackground() {
        return new Promise(resolve => setTimeout(resolve, 0));
      }

      function cloneSearchState(state) {
        return {
          boardPieces: state.boardPieces.slice(),
          counts: { ...state.counts },
          scores: { ...state.scores },
          scoredVictims: new Set(state.scoredVictims),
          mover: state.mover,
          turnNumber: state.turnNumber,
          scoringMode: state.scoringMode,
          startingPlayer: state.startingPlayer,
          gameNumber: state.gameNumber,
          lastTurnPieces: state.lastTurnPieces.slice(),
          nextHypId: state.nextHypId,

          version: state.version,
          incremental: state.incremental,
          incrementalPromise: state.incrementalPromise
        };
      }

      function createRawSearchStateFromGlobals(mover = currentPlayer) {
        let nextHypId = -1;

        for (const piece of pieces) {
          if (typeof piece.id === 'number' && piece.id < 0) {
            nextHypId = Math.min(nextHypId, piece.id - 1);
          }
        }

        /*
         * 正式狀態的 counts 必須是落子前庫存。
         * tempPieces 已經從 piecesCount 扣除，所以加回去。
         */
        const counts = { ...piecesCount };

        for (const piece of tempPieces) {
          counts[piece.svgId] = (counts[piece.svgId] || 0) + 1;
        }

        return {
          boardPieces: pieces.slice(),
          counts,
          scores: { ...scores },
          scoredVictims: new Set(scoredVictims),
          mover,
          turnNumber,
          scoringMode: SCORING_MODE,
          startingPlayer,
          gameNumber,
          lastTurnPieces: lastTurnPieces.slice(),
          nextHypId,

          version: ++committedStateVersion,
          incremental: null,
          incrementalPromise: null
        };
      }

      function initializeCommittedSearchStateFromGlobals() {
        const state = createRawSearchStateFromGlobals(currentPlayer);

        /*
         * 正常新局是空盤，所以這裡幾乎沒有成本。
         * 對舊棋譜或沒有 SearchState 快照的歷史資料，才會完整建立一次。
         */
        state.incremental = buildIncrementalIndexFromBoard(state);
        state.incrementalPromise = Promise.resolve(state.incremental);

        committedSearchState = state;
        return state;
      }

      function createSearchStateFromGlobals(mover = currentPlayer) {
        if (!committedSearchState) {
          initializeCommittedSearchStateFromGlobals();
        }

        if (mover === committedSearchState.mover) {
          return committedSearchState;
        }

        /*
         * 只改行動方，盤面、庫存和增量索引可以共用。
         */
        return {
          ...committedSearchState,
          mover
        };
      }

      function createSearchStateForBoard(mover, boardPieces, extraHypPieces = []) {
        const counts = { ...piecesCount };

        for (const piece of tempPieces) {
          counts[piece.svgId] = (counts[piece.svgId] || 0) + 1;
        }

        for (const piece of extraHypPieces) {
          if (counts[piece.svgId] !== undefined) {
            counts[piece.svgId]--;
          }
        }

        let nextHypId = -1;

        for (const piece of boardPieces) {
          if (typeof piece.id === 'number' && piece.id < 0) {
            nextHypId = Math.min(nextHypId, piece.id - 1);
          }
        }

        const state = {
          boardPieces: boardPieces.slice(),
          counts,
          scores: { ...scores },
          scoredVictims: new Set(scoredVictims),
          mover,
          turnNumber,
          scoringMode: SCORING_MODE,
          startingPlayer,
          gameNumber,
          lastTurnPieces: lastTurnPieces.slice(),
          nextHypId,

          version: ++committedStateVersion,
          incremental: null,
          incrementalPromise: null
        };

        /*
         * 這是相容舊介面的備援入口。
         * 正常 MCTS/minimax 不再走這條路。
         */
        state.incremental = buildIncrementalIndexFromBoard(state);
        state.incrementalPromise = Promise.resolve(state.incremental);

        return state;
      }

      async function ensureStateIncremental(state) {
        if (state.incremental) {
          return state.incremental;
        }

        if (state.incrementalPromise) {
          const index = await state.incrementalPromise;

          if (!state.incremental) {
            state.incremental = index;
          }

          return state.incremental;
        }

        state.incremental = buildIncrementalIndexFromBoard(state);
        state.incrementalPromise = Promise.resolve(state.incremental);

        return state.incremental;
      }

      function ensureStateIncrementalSync(state) {
        if (!state.incremental) {
          /*
           * 只有同步呼叫者在背景工作尚未完成時才走此保險路徑。
           * AI、仲裁入口都會先 await ensureStateIncremental()。
           */
          state.incremental = buildIncrementalIndexFromBoard(state);
          state.incrementalPromise = Promise.resolve(state.incremental);
        }

        return state.incremental;
      }

      // =============================================================================
      // 持久 SearchState 增量索引
      // =============================================================================

      function pairMethodKey(a, b) {
        return a < b ? a + '||' + b : b + '||' + a;
      }

      function methodTargetEdge(method) {
        return method.ghost.targetEdge !== undefined
          ? method.ghost.targetEdge
          : method.ghost.edgeOnOpp;
      }

      function createEmptyIncrementalIndex(state) {
        return {
          idMap: new Map(state.boardPieces.map(piece => [piece.id, piece])),

          /*
           * methods：
           * 所有目前仍存活的單子活法。
           * key 為 piecePlacementSignature。
           */
          methods: new Map(),

          byPlayer: {
            1: new Set(),
            2: new Set()
          },

          byTarget: new Map(),
          byEdge: new Map(),

          /*
           * 所有共活，不只是「是否存在」。
           * value = { a: methodKey, b: methodKey }
           */
          coLivePairs: {
            1: new Map(),
            2: new Map()
          },

          /*
           * 所有雙接／互頂。
           */
          mutualPairs: {
            1: new Map(),
            2: new Map()
          },

          /*
           * 單獨落下就會產生可計分頂鑫的活法。
           */
          singleScoring: {
            1: new Set(),
            2: new Set()
          }
        };
      }

      function cloneSetMap(source) {
        const result = new Map();

        for (const [key, value] of source) {
          result.set(key, new Set(value));
        }

        return result;
      }

      function cloneIncrementalIndex(source) {
        return {
          idMap: new Map(source.idMap),
          methods: new Map(source.methods),

          byPlayer: {
            1: new Set(source.byPlayer[1]),
            2: new Set(source.byPlayer[2])
          },

          byTarget: cloneSetMap(source.byTarget),
          byEdge: cloneSetMap(source.byEdge),

          coLivePairs: {
            1: new Map(source.coLivePairs[1]),
            2: new Map(source.coLivePairs[2])
          },

          mutualPairs: {
            1: new Map(source.mutualPairs[1]),
            2: new Map(source.mutualPairs[2])
          },

          singleScoring: {
            1: new Set(source.singleScoring[1]),
            2: new Set(source.singleScoring[2])
          }
        };
      }

      function addMethodToSetMap(map, key, methodKey) {
        if (!map.has(key)) {
          map.set(key, new Set());
        }

        map.get(key).add(methodKey);
      }

      function registerIndexedMethod(index, method) {
        if (index.methods.has(method.key)) {
          return false;
        }

        index.methods.set(method.key, method);
        index.byPlayer[method.forPlayer].add(method.key);

        addMethodToSetMap(index.byTarget, method.ghost.targetId, method.key);
        addMethodToSetMap(
          index.byEdge,
          edgeKey(method.ghost.targetId, methodTargetEdge(method)),
          method.key
        );

        if (method.hasScoringStructure) {
          index.singleScoring[method.forPlayer].add(method.key);
        }

        return true;
      }

      function deleteIndexedMethod(index, methodKey) {
        const method = index.methods.get(methodKey);
        if (!method) return;

        index.methods.delete(methodKey);
        index.byPlayer[method.forPlayer].delete(methodKey);
        index.singleScoring[method.forPlayer].delete(methodKey);

        const targetSet = index.byTarget.get(method.ghost.targetId);
        if (targetSet) {
          targetSet.delete(methodKey);
          if (targetSet.size === 0) index.byTarget.delete(method.ghost.targetId);
        }

        const edgeSet = index.byEdge.get(
          edgeKey(method.ghost.targetId, methodTargetEdge(method))
        );

        if (edgeSet) {
          edgeSet.delete(methodKey);
          if (edgeSet.size === 0) {
            index.byEdge.delete(
              edgeKey(method.ghost.targetId, methodTargetEdge(method))
            );
          }
        }
      }

      function removePairsContainingMethods(pairMap, removedKeys) {
        for (const [key, pair] of pairMap) {
          if (removedKeys.has(pair.a) || removedKeys.has(pair.b)) {
            pairMap.delete(key);
          }
        }
      }

      function ghostConflictsWithPiece(ghost, piece) {
        const collision = checkSATCollision(getSAT(ghost), getSAT(piece));

        if (collision === 'separated') return false;
        if (collision === 'overlap') return true;

        for (let edgeA = 0; edgeA < 4; edgeA++) {
          for (let edgeB = 0; edgeB < 4; edgeB++) {
            if (
              segmentsOverlapAsEdges(
                ghost.vertices[edgeA],
                ghost.vertices[(edgeA + 1) % 4],
                piece.vertices[edgeB],
                piece.vertices[(edgeB + 1) % 4]
              )
            ) {
              return true;
            }
          }
        }

        for (const vertexA of ghost.vertices) {
          for (const vertexB of piece.vertices) {
            if (pointsEqual(vertexA, vertexB)) {
              return true;
            }
          }
        }

        return false;
      }

      /*
       * 兩個活法作為同一回合的兩子時是否相容。
       */
      function twoGhostsCompatible(g1, g2) {
        const collision = checkSATCollision(getSAT(g1), getSAT(g2));

        if (collision === 'separated') return true;
        if (collision === 'overlap') return false;

        for (let edgeA = 0; edgeA < 4; edgeA++) {
          for (let edgeB = 0; edgeB < 4; edgeB++) {
            if (
              segmentsOverlapAsEdges(
                g1.vertices[edgeA],
                g1.vertices[(edgeA + 1) % 4],
                g2.vertices[edgeB],
                g2.vertices[(edgeB + 1) % 4]
              )
            ) {
              return false;
            }
          }
        }

        const attached1 = [g1.myEdge, (g1.myEdge + 1) % 4];
        const attached2 = [g2.myEdge, (g2.myEdge + 1) % 4];

        for (let i = 0; i < 4; i++) {
          for (let j = 0; j < 4; j++) {
            if (!pointsEqual(g1.vertices[i], g2.vertices[j])) continue;

            /*
             * 同一目標棋子的相鄰邊可以共用貼合端點。
             * 只要其中一方是懸空端點，便不合法。
             */
            if (!attached1.includes(i) || !attached2.includes(j)) {
              return false;
            }
          }
        }

        return true;
      }

      /*
       * 不按照庫存刪除活法。
       * 庫存只在產生回合時過濾。
       *
       * 這樣某一種類用完不會破壞持久幾何索引；
       * undo 後庫存恢復時也不必重新枚舉。
       */
      function enumerateEdgeMethodsIncremental(state, piece, edgeIndex) {
        const forPlayer = piece.owner === 1 ? 2 : 1;
        const tileIds = getPlayerTileIds(forPlayer);
        const result = [];
        const seen = new Set();

        for (const tileId of tileIds) {
          for (const flipped of [false, true]) {
            for (let myEdge = 0; myEdge < 4; myEdge++) {
              const attached = attachByEdge(
                SHAPE_MAP[tileId],
                flipped,
                myEdge,
                piece.vertices[edgeIndex],
                piece.vertices[(edgeIndex + 1) % 4],
                !!piece.isFlipped
              );

              if (!attached) continue;

              const ghost = {
                id: allocateHypothesisPieceId(),
                vertices: attached.vertices,
                type: SHAPE_MAP[tileId],
                owner: forPlayer,
                svgId: tileId,
                isFlipped: flipped,
                edgeOnOpp: edgeIndex,
                targetId: piece.id,
                myEdge,
                targetEdge: edgeIndex,
                parentId: piece.id,
                level: (piece.level !== undefined ? piece.level : 0) + 1
              };

              preparePieceSAT(ghost);

              if (!isValidGhost(ghost, state.boardPieces)) {
                continue;
              }

              const key = piecePlacementSignature(ghost);
              if (seen.has(key)) continue;

              seen.add(key);
              result.push(ghost);
            }
          }
        }

        return result;
      }

      /*
       * 相容舊函式名稱。
       * 正式搜索不再依賴這個包裝。
       */
      function enumerateEdgeMethods(piece, edgeIndex, allPieces) {
        const state = {
          boardPieces: allPieces,
          counts: { ...piecesCount },
          scores: { ...scores },
          scoredVictims: new Set(scoredVictims),
          mover: piece.owner === 1 ? 2 : 1,
          turnNumber,
          scoringMode: SCORING_MODE,
          startingPlayer,
          gameNumber,
          lastTurnPieces: lastTurnPieces.slice(),
          nextHypId: -1,
          incremental: null,
          incrementalPromise: null
        };

        return enumerateEdgeMethodsIncremental(state, piece, edgeIndex);
      }

      function evaluateIndexedMethod(state, oldMethod) {
        const adjudication = adjudicateSearchTurn(state, [oldMethod.ghost]);

        return {
          ...oldMethod,
          hasScoringStructure: adjudication.hasScoringStructure,
          gain: { ...adjudication.gain },
          scoreKeys: new Set(adjudication.records.map(record => record.key))
        };
      }

      function replaceIndexedMethodMetadata(index, state, methodKey) {
        const oldMethod = index.methods.get(methodKey);
        if (!oldMethod) return;

        const updated = evaluateIndexedMethod(state, oldMethod);
        index.methods.set(methodKey, updated);

        if (updated.hasScoringStructure) {
          index.singleScoring[updated.forPlayer].add(methodKey);
        } else {
          index.singleScoring[updated.forPlayer].delete(methodKey);
        }
      }

      function registerMethodRelations(index, methodA, methodB) {
        if (!methodA || !methodB) return;
        if (methodA.key === methodB.key) return;
        if (methodA.forPlayer !== methodB.forPlayer) return;
        if (!twoGhostsCompatible(methodA.ghost, methodB.ghost)) return;

        const player = methodA.forPlayer;
        const pairKey = pairMethodKey(methodA.key, methodB.key);

        /*
         * 共活：同一目標、不同目標邊。
         */
        if (
          methodA.ghost.targetId === methodB.ghost.targetId &&
          methodTargetEdge(methodA) !== methodTargetEdge(methodB)
        ) {
          index.coLivePairs[player].set(pairKey, {
            a: methodA.key,
            b: methodB.key
          });
        }

        /*
         * 雙接／互頂。
         */
        if (formsTriGolden(methodA.ghost, methodB.ghost)) {
          index.mutualPairs[player].set(pairKey, {
            a: methodA.key,
            b: methodB.key
          });
        }
      }

      function addMethodsForNewPiece(index, state, piece) {
        const addedKeys = [];

        for (let edgeIndex = 0; edgeIndex < 4; edgeIndex++) {
          const ghosts = enumerateEdgeMethodsIncremental(
            state,
            piece,
            edgeIndex
          );

          for (const ghost of ghosts) {
            const key = piecePlacementSignature(ghost);

            const method = {
              key,
              forPlayer: ghost.owner,
              ownerEdgePieceId: piece.id,
              edgeIndex,
              ghost,
              hasScoringStructure: false,
              gain: { 1: 0, 2: 0 },
              scoreKeys: new Set()
            };

            if (registerIndexedMethod(index, method)) {
              addedKeys.push(key);
            }
          }
        }

        return addedKeys;
      }

      /*
       * 從父索引推導子索引：
       *
       * 1. 只刪除被新棋干涉的舊活法。
       * 2. 只枚舉新棋四條邊帶來的新活法。
       * 3. 只重算可能受新棋或新 scored key 影響的單接資料。
       * 4. 舊共活／雙接直接保存。
       * 5. 只建立「新方法與既有方法」的新關係。
       */
      function deriveIncrementalIndex(
        parentIndex,
        childState,
        placedPieces,
        newScoredKeys
      ) {
        const index = cloneIncrementalIndex(parentIndex);

        for (const piece of placedPieces) {
          preparePieceSAT(piece);
          index.idMap.set(piece.id, piece);
        }

        const removedKeys = new Set();
        const reevaluateKeys = new Set();
        const scoredKeySet = new Set(newScoredKeys || []);

        for (const [methodKey, method] of index.methods) {
          let removed = false;
          let touchesNewPiece = false;

          for (const piece of placedPieces) {
            const collision = checkSATCollision(
              getSAT(method.ghost),
              getSAT(piece)
            );

            if (collision !== 'separated') {
              touchesNewPiece = true;
            }

            if (ghostConflictsWithPiece(method.ghost, piece)) {
              removed = true;
              break;
            }
          }

          if (removed) {
            removedKeys.add(methodKey);
            continue;
          }

          if (touchesNewPiece) {
            reevaluateKeys.add(methodKey);
            continue;
          }

          for (const key of method.scoreKeys) {
            if (scoredKeySet.has(key)) {
              reevaluateKeys.add(methodKey);
              break;
            }
          }
        }

        for (const methodKey of removedKeys) {
          deleteIndexedMethod(index, methodKey);
        }

        for (const player of [1, 2]) {
          removePairsContainingMethods(
            index.coLivePairs[player],
            removedKeys
          );

          removePairsContainingMethods(
            index.mutualPairs[player],
            removedKeys
          );
        }

        const addedKeys = [];

        for (const piece of placedPieces) {
          addedKeys.push(
            ...addMethodsForNewPiece(index, childState, piece)
          );
        }

        for (const methodKey of addedKeys) {
          reevaluateKeys.add(methodKey);
        }

        for (const methodKey of reevaluateKeys) {
          replaceIndexedMethodMetadata(index, childState, methodKey);
        }

        /*
         * 舊方法彼此之間的幾何關係不會因為加棋而增加。
         * 因此只需為新方法建立關係。
         */
        const relatedPairsSeen = new Set();

        for (const addedKey of addedKeys) {
          const addedMethod = index.methods.get(addedKey);
          if (!addedMethod) continue;

          for (const otherKey of index.byPlayer[addedMethod.forPlayer]) {
            if (otherKey === addedKey) continue;

            const relationKey = pairMethodKey(addedKey, otherKey);
            if (relatedPairsSeen.has(relationKey)) continue;

            relatedPairsSeen.add(relationKey);

            registerMethodRelations(
              index,
              addedMethod,
              index.methods.get(otherKey)
            );
          }
        }

        return index;
      }

      /*
       * 僅用於：
       * - 新局初始化；
       * - 舊歷史資料沒有 SearchState 快照；
       * - 非正常入口建立任意 boardPieces。
       *
       * 正常每回合、MCTS、minimax 都不呼叫此函式。
       */
      function buildIncrementalIndexFromBoard(state) {
        const index = createEmptyIncrementalIndex(state);
        const allAddedKeys = [];

        for (const piece of state.boardPieces) {
          allAddedKeys.push(...addMethodsForNewPiece(index, state, piece));
        }

        for (const methodKey of allAddedKeys) {
          replaceIndexedMethodMetadata(index, state, methodKey);
        }

        for (const player of [1, 2]) {
          /*
           * 共活只在同一 targetId 內組合。
           */
          for (const methodKeys of index.byTarget.values()) {
            const list = Array.from(methodKeys)
              .map(key => index.methods.get(key))
              .filter(method => method && method.forPlayer === player);

            for (let i = 0; i < list.length; i++) {
              for (let j = i + 1; j < list.length; j++) {
                registerMethodRelations(index, list[i], list[j]);
              }
            }
          }

          /*
           * 雙接可能跨 target，所以完整初始化時需檢查同方方法。
           * 這只發生在備援重建，不發生在正常搜索節點。
           */
          const playerMethods = Array.from(index.byPlayer[player])
            .map(key => index.methods.get(key))
            .filter(Boolean);

          for (let i = 0; i < playerMethods.length; i++) {
            for (let j = i + 1; j < playerMethods.length; j++) {
              registerMethodRelations(
                index,
                playerMethods[i],
                playerMethods[j]
              );
            }
          }
        }

        return index;
      }

      function scheduleIncrementalIndex(
        parentState,
        childState,
        placedPieces,
        newScoredKeys
      ) {
        const parentPromise = parentState.incremental
          ? Promise.resolve(parentState.incremental)
          : parentState.incrementalPromise ||
            Promise.resolve(buildIncrementalIndexFromBoard(parentState));

        childState.incremental = null;

        /*
         * 每一次正式落子都排入背景佇列。
         * 即使雙方都是人類，也會執行。
         *
         * 如果玩家極快地連續操作，多個局面會沿 Promise 鏈依序更新，
         * 不會跳過中間局面，也不會拿錯父索引。
         */
        childState.incrementalPromise = parentPromise
          .then(async parentIndex => {
            await yieldIncrementalBackground();

            return deriveIncrementalIndex(
              parentIndex,
              childState,
              placedPieces,
              newScoredKeys
            );
          })
          .then(index => {
            /*
             * 如果某個同步入口已經先建立完成索引，保留已建立的版本。
             */
            if (!childState.incremental) {
              childState.incremental = index;
            }

            return childState.incremental;
          });

        return childState.incrementalPromise;
      }

      /*
       * 兼容舊呼叫。
       * 現在不再清除正式增量資料。
       */
      function resetLifeTracking() {
        // 不做任何事。
        // resetGame() 會建立新的 committedSearchState。
      }

      function scheduleLifeTrackingUpdate() {
        return committedSearchState
          ? committedSearchState.incrementalPromise
          : Promise.resolve();
      }

      function ensureLifeStatsReady() {
        if (!committedSearchState) {
          initializeCommittedSearchStateFromGlobals();
        }

        return committedSearchState.incremental;
      }

      /*
       * 增量計分。
       *
       * 舊局面中的舊棋子接觸，在前面的回合已經處理過。
       * 新回合只可能新增：
       *
       * 1. 新棋頂舊棋；
       * 2. 舊棋頂新棋；
       * 3. 兩顆新棋互頂。
       *
       * 所以由原本 O(全盤棋子²)，改為 O(新增棋子 × 全盤棋子)。
       */
      function adjudicateSearchTurn(state, placedPieces) {
        const oldPieces = state.boardPieces;
        const allPieces = oldPieces.concat(placedPieces);
        const newIds = new Set(placedPieces.map(piece => piece.id));

        const idMap = state.incremental
          ? new Map(state.incremental.idMap)
          : new Map(oldPieces.map(piece => [piece.id, piece]));

        for (const piece of placedPieces) {
          preparePieceSAT(piece);
          idMap.set(piece.id, piece);
        }

        const dingMap = new Map();
        const checkedOrderedPairs = new Set();

        function inspectOrderedPair(dinger, victim) {
          if (!dinger || !victim || dinger.id === victim.id) return;

          const orderedKey = String(dinger.id) + '>' + String(victim.id);
          if (checkedOrderedPairs.has(orderedKey)) return;
          checkedOrderedPairs.add(orderedKey);

          if (
            checkSATCollision(getSAT(dinger), getSAT(victim)) ===
            'separated'
          ) {
            return;
          }

          const touchingVertices = [];

          for (const vertex of dinger.vertices) {
            for (let edgeIndex = 0; edgeIndex < 4; edgeIndex++) {
              if (
                pointOnOpenSegment(
                  vertex,
                  victim.vertices[edgeIndex],
                  victim.vertices[(edgeIndex + 1) % 4]
                )
              ) {
                touchingVertices.push(vertex);
                break;
              }
            }
          }

          if (touchingVertices.length === 0) return;

          const treeResult = getTreeDistance(
            dinger,
            victim,
            allPieces,
            idMap
          );

          if (!treeResult || treeResult.dist < 0) return;

          for (const vertex of touchingVertices) {
            const key = victim.id + '_' + vertex.join('_');

            if (state.scoredVictims.has(key)) {
              continue;
            }

            if (!dingMap.has(key)) {
              dingMap.set(key, []);
            }

            dingMap.get(key).push({
              dinger,
              victim,
              dist: treeResult.dist,
              path: treeResult.path
            });
          }
        }

        /*
         * 新棋作為頂棋，對所有棋子檢查。
         * 包括新棋與另一顆新棋。
         */
        for (const dinger of placedPieces) {
          for (const victim of allPieces) {
            inspectOrderedPair(dinger, victim);
          }
        }

        /*
         * 舊棋作為頂棋，只需對新棋檢查。
         */
        for (const dinger of oldPieces) {
          for (const victim of placedPieces) {
            inspectOrderedPair(dinger, victim);
          }
        }

        const gain = { 1: 0, 2: 0 };
        const newScoredKeys = [];
        const records = [];
        const rings = [];

        for (const [key, candidates] of dingMap) {
          let best = null;

          for (const candidate of candidates) {
            if (!best || candidate.dist < best.dist) {
              best = candidate;
            }
          }

          if (!best) continue;

          let scorer = 0;

          if (state.scoringMode === 0) {
            scorer = best.dinger.owner;
          } else if (state.scoringMode === 1) {
            scorer = best.victim.owner;
          } else if (
            state.scoringMode === 2 &&
            best.dinger.owner === best.victim.owner
          ) {
            scorer = best.dinger.owner;
          }

          const involvesNew =
            newIds.has(best.dinger.id) ||
            newIds.has(best.victim.id);

          if (best.dist > 0 && scorer > 0) {
            gain[scorer] += best.dist;

            rings.push({
              path: best.path,
              scorer
            });
          }

          /*
           * 維持原遊戲流程：
           * 距離為 0 也封存該 victim vertex key。
           */
          newScoredKeys.push(key);

          records.push({
            key,
            dinger: best.dinger,
            victim: best.victim,
            dist: best.dist,
            score: best.dist,
            scorer,
            path: best.path,
            involvesNew
          });
        }

        return {
          gain,
          newScoredKeys,
          records,
          rings,

          /*
           * 維持原本跨目標例外：
           * 必須是本回合新增的可計分結構，而且距離 > 0。
           */
          hasScoringStructure: records.some(
            record => record.involvesNew && record.score > 0
          )
        };
      }

      function applySearchTurnToState(state, move, options = {}) {
        const shouldValidate = options.validate !== false;
        const backgroundIndex = options.backgroundIndex === true;

        if (shouldValidate) {
          const validation = validateTurnOnState(state, move);

          if (!validation.ok) {
            throw new Error(
              'Illegal search turn: ' + validation.reason
            );
          }
        }

        const next = cloneSearchState(state);
        const usedIds = new Set(
          next.boardPieces.map(piece => piece.id)
        );

        const placedPieces = move.map(source => {
          const piece = {
            ...source,
            vertices: source.vertices,
            satBounds: source.satBounds
          };

          if (
            piece.id === undefined ||
            piece.id === null ||
            usedIds.has(piece.id)
          ) {
            piece.id = next.nextHypId--;
          }

          usedIds.add(piece.id);
          preparePieceSAT(piece);

          return piece;
        });

        const negativeIds = placedPieces
          .map(piece => piece.id)
          .filter(id => typeof id === 'number' && id < 0);

        if (negativeIds.length > 0) {
          next.nextHypId =
            Math.min(next.nextHypId, ...negativeIds) - 1;
        }

        /*
         * 計分只計算本回合新增接觸。
         */
        const adjudication = adjudicateSearchTurn(
          state,
          placedPieces
        );

        for (const piece of placedPieces) {
          next.counts[piece.svgId]--;
        }

        next.boardPieces.push(...placedPieces);

        next.scores[1] += adjudication.gain[1];
        next.scores[2] += adjudication.gain[2];

        for (const key of adjudication.newScoredKeys) {
          next.scoredVictims.add(key);
        }

        next.lastTurnPieces = placedPieces.slice();
        next.turnNumber++;
        next.mover = next.mover === 1 ? 2 : 1;
        next.version = ++committedStateVersion;

        if (backgroundIndex) {
          /*
           * 正式人類／AI 落子：
           * 先完成遊戲流程和畫面切換，再在背景更新持久索引。
           */
          scheduleIncrementalIndex(
            state,
            next,
            placedPieces,
            adjudication.newScoredKeys
          );
        } else {
          /*
           * MCTS/minimax 子節點：
           * 必須立即得到子節點索引，但只從父索引增量推導。
           */
          const parentIndex = ensureStateIncrementalSync(state);

          next.incremental = deriveIncrementalIndex(
            parentIndex,
            next,
            placedPieces,
            adjudication.newScoredKeys
          );

          next.incrementalPromise = Promise.resolve(
            next.incremental
          );
        }

        return {
          state: next,
          placedPieces,
          adjudication
        };
      }

        /*
         * 如果這個放法已存在於目前局面的持久活法索引，
         * 就不需要再次掃描整個盤面做幾何合法性檢查。
         */
        if (
          state &&
          state.incremental &&
          state.incremental.methods.has(
            piecePlacementSignature(piece)
          )
        ) {
          return { ok: true };
        }

      function generateLegalSinglePlacements(
        state,
        player = state.mover
      ) {
        if (state.boardPieces.length === 0) {
          return [];
        }

        const index = ensureStateIncrementalSync(state);
        const result = [];

        for (const methodKey of index.byPlayer[player]) {
          const method = index.methods.get(methodKey);
          if (!method) continue;

          /*
           * 幾何活法永久保存，但目前沒有這種棋時不生成候選。
           */
          if ((state.counts[method.ghost.svgId] || 0) <= 0) {
            continue;
          }

          result.push(method.ghost);
        }

        return result;
      }

      /*
       * 從持久 coLivePairs 中取出所有共活。
       *
       * generateLegalTurns、仲裁、MCTS、minimax 共用，
       * 不再各自重新枚舉。
       */
      function generateAllCoLiveTurns(
        state,
        player = state.mover
      ) {
        const required = getRequiredPiecesForState(state);

        if (required === 1) {
          if (state.boardPieces.length === 0) return [];

          return generateLegalSinglePlacements(
            state,
            player
          ).map(ghost => [ghost]);
        }

        const index = ensureStateIncrementalSync(state);
        const moves = [];
        const seen = new Set();

        for (const pair of index.coLivePairs[player].values()) {
          const firstMethod = index.methods.get(pair.a);
          const secondMethod = index.methods.get(pair.b);

          if (!firstMethod || !secondMethod) continue;

          const first = firstMethod.ghost;
          const second = secondMethod.ghost;

          if (!pairFitsInventory(state, first, second)) {
            continue;
          }

          const signature = turnSignature([first, second]);
          if (seen.has(signature)) continue;

          seen.add(signature);
          moves.push([first, second]);
        }

        return moves;
      }

      function generateLegalTurns(state) {
        const required = getRequiredPiecesForState(state);

        if (required === 1) {
          if (state.boardPieces.length === 0) return [];

          return generateLegalSinglePlacements(
            state,
            state.mover
          ).map(ghost => [ghost]);
        }

        const index = ensureStateIncrementalSync(state);
        const player = state.mover;

        /*
         * 普通同目標回合直接使用全部共活。
         */
        const result = generateAllCoLiveTurns(state, player);
        const seen = new Set(result.map(turnSignature));

        const allMethods = Array.from(index.byPlayer[player])
          .map(key => index.methods.get(key))
          .filter(
            method =>
              method &&
              (state.counts[method.ghost.svgId] || 0) > 0
          );

        function tryAddCrossTargetPair(methodA, methodB) {
          if (!methodA || !methodB) return;
          if (methodA.key === methodB.key) return;

          const first = methodA.ghost;
          const second = methodB.ghost;

          if (first.targetId === second.targetId) return;

          if (!pairFitsInventory(state, first, second)) {
            return;
          }

          if (!twoGhostsCompatible(first, second)) {
            return;
          }

          const move = [first, second];
          const signature = turnSignature(move);

          if (seen.has(signature)) return;

          /*
           * 最後仍使用正式規則確認：
           * 跨目標必須形成尚未計分、距離 > 0 的頂鑫。
           *
           * 此處的 adjudicateSearchTurn 已經是增量計分，
           * 不會全盤棋子兩兩重算。
           */
          const validation = validateTurnOnState(state, move);
          if (!validation.ok) return;

          seen.add(signature);
          result.push(move);
        }

        /*
         * 跨目標例外來源一：
         * 任一單子本身已是單接。
         */
        for (const scoringKey of index.singleScoring[player]) {
          const scoringMethod = index.methods.get(scoringKey);
          if (!scoringMethod) continue;

          if (
            (state.counts[scoringMethod.ghost.svgId] || 0) <= 0
          ) {
            continue;
          }

          for (const otherMethod of allMethods) {
            tryAddCrossTargetPair(
              scoringMethod,
              otherMethod
            );
          }
        }

        /*
         * 跨目標例外來源二：
         * 兩個活法互相形成雙接。
         */
        for (const pair of index.mutualPairs[player].values()) {
          tryAddCrossTargetPair(
            index.methods.get(pair.a),
            index.methods.get(pair.b)
          );
        }

        return result;
      }

      function generateGhosts() {
        ghosts = [];

        if (!selectedTile || !targetOpponentPieceId) {
          return;
        }

        const state = createSearchStateFromGlobals(currentPlayer);

        /*
         * 背景索引已完成時，直接取出保存的單子活法。
         */
        if (state.incremental) {
          const methodKeys =
            state.incremental.byTarget.get(
              targetOpponentPieceId
            ) || new Set();

          const existingPieces = pieces.concat(tempPieces);

          for (const methodKey of methodKeys) {
            const method =
              state.incremental.methods.get(methodKey);

            if (!method) continue;

            const source = method.ghost;

            if (source.owner !== currentPlayer) continue;
            if (source.svgId !== selectedTile) continue;
            if (source.isFlipped !== isFlipped[selectedTile]) {
              continue;
            }

            /*
             * 第一顆暫存棋不在 committed index 中，
             * 所以第二顆仍需檢查是否和 tempPieces 相容。
             */
            if (!isValidGhost(source, existingPieces)) {
              continue;
            }

            /*
             * 必須複製，commitGhost 會改 id；
             * 不可直接修改持久索引中的 ghost。
             */
            ghosts.push({
              ...source,
              vertices: source.vertices,
              satBounds: source.satBounds
            });
          }

          return;
        }

        /*
         * 背景更新尚未完成時的 UI 備援。
         * 不會寫入搜索狀態，也不會改變遊戲流程。
         */
        const target = pieces.find(
          piece => piece.id === targetOpponentPieceId
        );

        if (!target) return;

        const selectedType = SHAPE_MAP[selectedTile];
        const selectedFlipped = isFlipped[selectedTile];
        const existingPieces = pieces.concat(tempPieces);

        for (let targetEdge = 0; targetEdge < 4; targetEdge++) {
          for (let myEdge = 0; myEdge < 4; myEdge++) {
            const attached = attachByEdge(
              selectedType,
              selectedFlipped,
              myEdge,
              target.vertices[targetEdge],
              target.vertices[(targetEdge + 1) % 4],
              !!target.isFlipped
            );

            if (!attached) continue;

            const ghost = {
              id: allocateHypothesisPieceId(),
              vertices: attached.vertices,
              type: selectedType,
              owner: currentPlayer,
              svgId: selectedTile,
              isFlipped: selectedFlipped,
              edgeOnOpp: targetEdge,
              targetId: target.id,
              myEdge,
              targetEdge,
              parentId: target.id,
              level:
                (target.level !== undefined ? target.level : 0) +
                1
            };

            preparePieceSAT(ghost);

            if (isValidGhost(ghost, existingPieces)) {
              ghosts.push(ghost);
            }
          }
        }
      }

        const applied = applySearchTurnToState(
          beforeState,
          tempPieces,
          {
            validate: false,

            /*
             * 不論人類或 AI，正式落子都在背景更新並保存增量索引。
             */
            backgroundIndex: true
          }
        );

      async function executeArbitration() {
        document.getElementById(
          'arb-confirm-dialog'
        ).style.display = 'none';

        actionCross(false);

        const arbitrationState =
          createSearchStateFromGlobals(currentPlayer);

        await ensureStateIncremental(arbitrationState);

        arbValidMoves =
          generateArbitrationDefenceTurns(
            arbitrationState
          );

        let ways = arbValidMoves.length;

        arbEnded = true;
        currentDialogMode = 'arbitration';

        saveState({
          newPieces: [],
          arbSuccess: ways === 0
        });

        // 以下原程式保持不變

          /*
           * 直接恢復當時保存的持久增量局面。
           * 不重新枚舉活法、共活、單接、雙接。
           */
          if (prevState.searchStateSnapshot) {
            committedSearchState =
              prevState.searchStateSnapshot;
          } else {
            /*
             * 只為相容修改前建立的舊 history。
             */
            committedSearchState =
              createRawSearchStateFromGlobals(
                currentPlayer
              );

            committedSearchState.incremental =
              buildIncrementalIndexFromBoard(
                committedSearchState
              );

            committedSearchState.incrementalPromise =
              Promise.resolve(
                committedSearchState.incremental
              );
          }

          if (nextState.searchStateSnapshot) {
            committedSearchState =
              nextState.searchStateSnapshot;
          } else {
            committedSearchState =
              createRawSearchStateFromGlobals(
                currentPlayer
              );

            committedSearchState.incremental =
              buildIncrementalIndexFromBoard(
                committedSearchState
              );

            committedSearchState.incrementalPromise =
              Promise.resolve(
                committedSearchState.incremental
              );
          }

        currentPlayer = startingPlayer;
        applyRotation();

        boardTransform = {
          tx: 240,
          ty: 240,
          scale: 1,
          angle: 0
        };

        initializeCommittedSearchStateFromGlobals();

      function setScoringMode(mode) {
        SCORING_MODE = mode;

        document
          .getElementById('btn-score-dinger')
          .classList.toggle('selected', mode === 0);

        document
          .getElementById('btn-score-xin')
          .classList.toggle('selected', mode === 1);

        /*
         * 正常情況下只會在開局前修改。
         * 同步到正式狀態，避免 SearchState 仍保存舊模式。
         */
        if (
          committedSearchState &&
          committedSearchState.boardPieces.length === 0
        ) {
          committedSearchState.scoringMode = mode;
        }
      }