feedback7 R22-LOADOUT: the browser stores, syncs and shows each operator's 潜能 / 练度 (cards at the player's settings); golden: unchanged

- ui/loadoutModel.js: `ops` beside the entries (sp.pref.loadout { v, entries, ops }; an older stored loadout has none =
  潜能 6, 精英2 Lv.60): parseStoredOps, opsOf / setOps / resetOps (defaults never stored), sanitizeOps (only what the
  server keeps: the roster and the 自选 owned pool); 导出 carries `ops`, 导入 replaces the settings when the payload has
  them (an older export leaves them alone; settings alone import); the 已调整 count and 仅看已调整 count them.
- ui/loadoutSync.js: the store's `ops` (setOpsMap persists both); the loadout sync watches entries and ops and sends
  room.loadout { entries, ops } (the ops sanitised against chess.json + backups.json; nothing set: no download);
  openLoadout loads effects.json (the 练度 multipliers).
- Cards: gameLogic chessLoadout(chess, loadout, getChess, { ops | cultivation, effects }) composes the record at the
  operator's potential and multiplies its stats by the 练度 tier (the player's m.private.ops — shop / hand / board cards
  and the detail panel; a teammate's unit its UnitInfo potential / cultivate: unitCultivation; a teammate's bond-popup
  card the defaults, never the viewer's settings; a stand-in neither); a 自选 card is composed at its pick's potential
  (ownDiyPick from m.private.ops, unitPick from UnitInfo).
- Tests: test/ui/potential-ui.test.js (new, 7): storage, helpers, 导出 / 导入, the 已调整 count, the sync (sanitised ops,
  settings-only edits, no download when none), the cards (刺玫 413 / 17 at 潜能1, ×1.05 at 精英1, a teammate's unit, a
  stand-in), 自选 cards at 潜能1 (凯尔希 392 / 20) and the 练度 on top; test/ui/loadout.test.js expects the envelope's
  `ops` and room.loadout's `ops: {}`.

public/js/ui/gameLogic/diy.js

@@ -8,6 +8,8 @@
 // player's units say it themselves (UnitInfo `diy`: the sim's, Match.prepFieldMeta's for scouting, m.result lineups). The
 // composed record is shared/diy.js diyRecordOf over chess.json + backups.json — the one the server and the sim use.
 // `data` below = `{ chess, backups }` (the client's data.get('chess') / data.get('backups'), localized copies).
+// 0.2.2: a pick may carry `potential` (the owner's 潜能 of the operator — m.private.ops for the player's own, UnitInfo
+// `potential` for another player's unit): the record is composed at it (an owned pick; a prototype has none).
 
 import { diyRecordOf } from '../../../../shared/diy.js';
 import { isObj } from './shared.js';
@@ -26,7 +28,10 @@ export function ownDiyPick(priv, chess) {
   if (!isObj(chess) || !chess.isDiy) return null;
   const slot = typeof chess.diyFor === 'string' ? chess.diyFor : chess.baseId || chess.chessId;
   const p = diyPicks(priv)[slot];
-  return isObj(p) && typeof p.charId === 'string' ? p : null;
+  if (!isObj(p) || typeof p.charId !== 'string') return null;
+  // 0.2.2: at the player's 潜能 of that operator (m.private.ops; none set = 6)
+  const pot = isObj(priv?.ops) && isObj(priv.ops[p.charId]) ? priv.ops[p.charId].potential : null;
+  return Number.isInteger(pot) && pot >= 1 && pot < 6 ? { ...p, potential: pot } : p;
 }
 
 /** Per backups object: `chessId|charId|skill|module` → composed record (or null). */
@@ -44,10 +49,11 @@ export function diyRecordFor(chess, pick, data) {
   if (!isObj(pick) || !isObj(data?.backups)) return null;
   let m = CACHE.get(data.backups);
   if (!m) { m = new Map(); CACHE.set(data.backups, m); }
-  const key = `${chess.chessId}|${pick.charId}|${pick.skillIndex ?? ''}|${pick.uniEquipId ?? ''}`;
+  const pot = Number.isInteger(pick.potential) ? pick.potential : null;
+  const key = `${chess.chessId}|${pick.charId}|${pick.skillIndex ?? ''}|${pick.uniEquipId ?? ''}|${pot ?? ''}`;
   if (m.has(key)) return m.get(key);
   let rec;
-  try { rec = diyRecordOf(chess, pick, data); } catch { rec = null; }
+  try { rec = diyRecordOf(chess, pick, data, { potential: pot }); } catch { rec = null; }
   m.set(key, rec);
   return rec;
 }
@@ -65,10 +71,16 @@ export function ownDiyRecord(chess, priv, data) {
  */
 export function cardDiy(chess, { priv = null, unit = null, data = null } = {}) {
   if (!isObj(chess) || !chess.isDiy) return null;
-  if (unit) return isObj(unit.diy) ? diyRecordFor(chess, unit.diy, data) : null;
+  if (unit) return isObj(unit.diy) ? diyRecordFor(chess, unitPick(unit), data) : null;
   return ownDiyRecord(chess, priv, data);
 }
 
+/** A unit's 自选 pick with its potential (UnitInfo `diy` + `potential`, 0.2.2), or null. */
+export function unitPick(unit) {
+  if (!isObj(unit) || !isObj(unit.diy)) return null;
+  return Number.isInteger(unit.potential) ? { ...unit.diy, potential: unit.potential } : unit.diy;
+}
+
 /**
  * id → the player's 自选 record of a filled DIY slot (both forms), else the chess record: the lookup the player's own
  * pieces and cards resolve against (names, art, position, the loadout / range of a 自选 piece — shared/protocol.js