fix: allow exporting DIY-only operator settings

docs/design/match.md

@@ -113,6 +113,9 @@ Official rule (bwiki 盟约, 更新公告 5114): before a match the player canno
 **UI:** a 干员调配 screen reachable from the lobby, room and briefing (INFO_CHECK): the roster is one list, a row per operator with aligned columns under a head row — portrait / name / bonds (opens the detail), the skills and the elite's modules to tap (不装备 first; the quick choices of PR #301 by @farridge, laid out as one list instead of its three columns of cards, the owner's call of 2026-10-08), the 潜能 / 练度 selects (`screens/loadout.js RosterRow`, `screens/cultivation.js`); the detail beside it (below 1000 px wide it slides over the list, a quick choice keeps the list) opens with the 潜能与练度 section (潜能 1–6, the four official 练度 tiers with their effect texts); the detail then shows the operator's 特质 — the in-match `GarrisonBlock` / RichText of the form its 普通 / 精锐 skill toggle shows, triggers such as 「<进入休整期时>」 kept (0.2.2, PR #301 by @farridge); filter by tier/bond/class, per chess choose skill (icon, name, SP info, desc at Lv4 and Lv7) and elite module (official type icon from the local-client art when extracted (§13), else a lettered tile; name/type, stat bonus, trait/talent changes), 恢复默认, persisted; a 局内数值 section between the skills and the modules (普通 / 精锐 toggle, 精锐 first) draws the detail card's own stats block, 特性 and 天赋 for the chosen skill / module (§22.16); the chosen skill/module shown on shop cards and in the detail panel (a teammate's unit — 前往查看 in prep, 联防 / 最终攻势 fields, an observed battle — shows **its owner's** skill/module from its UnitInfo `skillIndex` / `moduleId`, `gameLogic.js unitLoadout`) — which also shows the stats, 特性, talents and attack range the unit fights with (`shared/loadoutRecord.js` `loadoutRecord` / `attackRangeGrid`, the same composition the sim's `getChess(id, loadout)` uses; the deploy wheel's range preview too) — the range it is deployed with: a selected passive range skill (引星棘刺 S3 3-9) and the 特性's permanent 攻击距离 (信仰搅拌机 SPT-Y +1) included, over all 1284 loadouts equal to the battle's range at deployment; in battle and prep the card draws the live `range` (§21.16). In battle the renderer plays the equipped skill's own Spine clip and ON_SKILL_START sound (`UnitInfo.skillIndex`; `data/assets.json` lists icons, clips and sounds for every skill index).
 
 **导出 / 导入 a loadout:** 导出 hands the current loadout out as a versioned envelope `{ kind: 'stronghold.loadout', v, exportedAt, count, entries, ops }` (`ops`: the 潜能 / 练度 settings, 0.2.2 — an import without them leaves the current settings alone) — copied through `ui/clipboard.js copyText` or downloaded as a file. 导入 accepts that envelope, the stored `{ v, entries }` form and a bare `{ [chessId]: { skill, module } }` map (serialised text too), and refuses another tool's `kind`, junk, an empty result and a **newer** `v` (`parseImport` — a newer payload is never mis-read). Both go through `loadoutSync.applyLoadoutEntries` → `sanitizeEntries`, so a preset from another build never sends the server an entry it would refuse, an import that keeps nothing changes nothing, and the result is reported as N imported / M not (`ui/loadoutModel.js`, `screens/loadout.js`).
+Export remains available for non-default `ops` alone, including operators outside the normal roster. The roster's
+adjusted count and reset scope stay limited to its own operators; the DIY export still carries picks only.
+
 **干员持有 (0.2.0 补位):** the overlay's second tab marks operators as not owned (the 55 NORMAL chess; per-browser `sp.pref.ownership` = `{ v, notOwned }`, synced as `room.ownership { notOwned }` by the same sync engine as the loadout, `ui/loadoutSync.js installPrefSync`; 导出 / 导入 as `{ kind: 'stronghold.ownership', v, exportedAt, count, notOwned }`). A not-owned chess fights as its official stand-in with the backup skill / module — the loadout never applies to it ("对于补位干员其技能不可更改") — and is shown as the stand-in wherever the player's copy appears (shop / reward cards, hand and 临时整备区, board, detail card, result lineup, a teammate's scouting and bond popups: portrait, name, model, with a small 「替补」 mark; the owner's recall of the official mode, 2026-10-06), while its bonds, 特质, tier, price and merge stay the chess's; the 0.2.0 补位 design subsections have the rules and sources.
 **自选编队 (0.2.0):** the overlay's third tab fills the four DIY slots (5阶 ×2, 6阶 ×2) with an owned 6★ outside the chess pool (any of its three skills, any module of its elite form but a 集成战略 one) or a prototype (its locked skill / module); only operators with a kit are offered (`welcome.diyKitted`). Per-browser `sp.pref.diy` = `{ v, picks }`, synced as `room.diy { picks }` by the same sync engine; 导出 / 导入 as `{ kind: 'stronghold.diy', v, exportedAt, count, picks }` (`ui/diyModel.js`, `screens/diy.js`). In the match a slotted piece is the operator for its player (name, art, class, bonds from its factions, no 特质, the pick's skill and module; the slot's tier, price and merge), sold only in that player's shop from the slot's 调度中心 level with its own stock; the shop / reward / detail cards and the own pieces carry a 「自选」 badge (`ui/gameLogic/diy.js`); the 0.2.0 自选编队 design subsection has the rules and sources.
 

docs/history/0.2.4.md

@@ -74,6 +74,9 @@ are unchanged. No unannounced future-season behavior is inferred.
 
 ### 29.6 UI and recovery
 
+- Loadout export stays available when only a DIY-only operator's potential/cultivation differs from the defaults.
+  It uses the existing `stronghold.loadout.ops`; the roster's adjusted count/reset scope and `stronghold.diy` format
+  remain unchanged. Real-server browser regressions cover settings-only, normal/mixed round trips and reset boundaries.
 - DIY selection reuses the roster's `LoadoutStats` component, showing the chosen ordinary/elite stats, attack range,
   trait, talents, potential and cultivation. Skill descriptions/SP labels follow the same preview level. The list
   uses aligned roster-style rows; list and details scroll independently, leaving Confirm reachable.

public/js/screens/loadout.js

@@ -675,7 +675,7 @@ function LoadoutScreen({ st }) {
         ${inMatch && hasDeadline(infoDeadline) ? html`<${Countdown} deadline=${infoDeadline} size="sm" gauge=${false} label=${t('调配截止')} class="lo-deadline" />` : null}
         ${syncText ? html`<span class=${cx('lo-sync', syncCls)} role="status">${t(syncText)}</span>` : null}
         <span class="lo-count">${t('已调整')} <b class="num">${nChanged}</b><span class="num t-dim">/${roster.length}</span></span>
-        <${Button} variant="ghost" size="sm" data-testid="loadout-export" disabled=${!nChanged} onClick=${openExport} title=${t('导出当前调配（可复制或下载）')}>${t('导出')}<//>
+        <${Button} variant="ghost" size="sm" data-testid="loadout-export" disabled=${!nChanged && !Object.keys(st.ops || {}).length} onClick=${openExport} title=${t('导出当前调配（可复制或下载）')}>${t('导出')}<//>
         <${Button} variant="ghost" size="sm" data-testid="loadout-import" disabled=${!ready} onClick=${openImport} title=${t('导入调配（粘贴或选择文件）')}>${t('导入')}<//>
         <${Button} variant="secondary" size="sm" icon="refresh" disabled=${!nChanged} onClick=${resetAll}>${t('全部恢复默认')}<//>
       </div>`}

test/ui/loadout-ops-export.e2e.test.js

@@ -0,0 +1,168 @@
+// The existing stronghold.loadout export carries every operator's potential/cultivation, including DIY-only ones.
+// Real server + headless Chrome, normal UI input only; no storage/store/network mutation. No art is required.
+// SP_E2E=1 node --test test/ui/loadout-ops-export.e2e.test.js
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { Client, hasChrome, startRealServer } from '../e2e/client.mjs';
+
+const KALTS = 'char_003_kalts';
+const INSIDE = 'chess_char_1_01_a';
+const SLOT = 'chess_char_6_diy1_a';
+const slot = `.diy-slot[data-slot="${SLOT}"]`;
+const picker = '[data-testid="diy-picker"]';
+const io = '[data-testid="loadout-io-text"]';
+
+describe('loadout export includes DIY-only cultivation (real server, headless Chrome)', {
+  skip: !(process.env.SP_E2E === '1' && hasChrome()) && 'set SP_E2E=1 (and have Chrome)',
+}, () => {
+  let srv, P;
+  before(async () => { srv = await startRealServer(); P = (await import('puppeteer-core')).default; });
+  after(async () => { await srv?.stop(); });
+
+  async function open(label) {
+    const c = new Client(P, srv.base, label, { prefix: 'loadout-ops-export', w: 1280, h: 800 });
+    try {
+      await c.open();
+      await c.enter('调配回归');
+      await c.click('.lobby-screen [data-testid="loadout-open"]');
+      await c.page.waitForSelector('.lo-card');
+      return c;
+    } catch (e) { await c.close(); throw e; }
+  }
+  const tab = (c, name) => c.click(`.lo-tab[data-tab="${name}"]`);
+  const disabled = (c, id) => c.page.$eval(`[data-testid="${id}"]`, e => e.disabled);
+  const saved = (c) => c.page.evaluate(() => {
+    const p = JSON.parse(localStorage.getItem('sp.pref.loadout') || '{}');
+    return { entries: p.entries || {}, ops: p.ops || {} };
+  });
+  async function chooseKalts(c) {
+    await tab(c, 'diy');
+    await c.click(`${slot} :is(.diy-slot__fill, [data-testid="diy-change"])`);
+    await c.page.waitForSelector(picker);
+    await c.click(`${picker} input[type="search"]`);
+    await c.page.keyboard.type('凯尔希');
+    await c.click(`${picker} .diy-opt[data-char="${KALTS}"]`);
+    await c.click('[data-testid="diy-confirm"]');
+    await c.page.waitForSelector(picker, { hidden: true });
+  }
+  async function setKalts(c, patch) {
+    await tab(c, 'diy');
+    for (const [key, value] of Object.entries(patch)) await c.page.select(`${slot} select[data-cult="${key}"]`, String(value));
+  }
+  async function changeNormal(c) {
+    await tab(c, 'loadout');
+    await c.click(`.lo-card[data-chess="${INSIDE}"] .lo-q--skill[data-skill="0"]`);
+    await c.page.select(`.lo-card[data-chess="${INSIDE}"] select[data-cult="potential"]`, '2');
+  }
+  async function exportText(c, id = 'loadout-export') {
+    assert.equal(await disabled(c, id), false, `${id} must allow the saved settings to be exported`);
+    await c.click(`[data-testid="${id}"]`);
+    await c.page.waitForSelector(io);
+    const text = await c.page.$eval(io, e => e.value);
+    await c.page.keyboard.press('Escape');
+    await c.page.waitForSelector(io, { hidden: true });
+    return text;
+  }
+  async function importText(c, text, id = 'loadout-import') {
+    await c.click(`[data-testid="${id}"]`);
+    await c.page.waitForSelector(io);
+    await c.click(io);
+    await c.page.keyboard.type(text);
+    await c.click('[data-testid="loadout-io-apply"]');
+    await c.page.waitForSelector(io, { hidden: true });
+  }
+
+  for (const [name, normal, patch] of [
+    ['DIY potential only', false, { potential: 1 }],
+    ['DIY cultivation only', false, { cultivate: 0 }],
+    ['DIY potential and cultivation', false, { potential: 1, cultivate: 0 }],
+    ['normal only', true, null],
+    ['normal and DIY', true, { potential: 1, cultivate: 0 }],
+  ]) {
+    test(`${name}: export then import in a fresh browser preserves entries and ops`, { timeout: 90000 }, async () => {
+      let c, target, diyText;
+      try {
+        c = await open(name);
+        if (patch) {
+          await chooseKalts(c);
+          await setKalts(c, patch);
+          await c.shot(`${name.replaceAll(' ', '-')}-settings`);
+          diyText = await exportText(c, 'diy-export');
+          const diy = JSON.parse(diyText);
+          assert.equal(diy.kind, 'stronghold.diy');
+          assert.equal('ops' in diy, false, 'the DIY roster format stays unchanged');
+          assert.equal(diy.picks[SLOT].charId, KALTS);
+        }
+        if (normal) await changeNormal(c);
+        await tab(c, 'loadout');
+        const expected = await saved(c);
+        if (patch) assert.deepEqual(expected.ops[KALTS], patch);
+        if (!normal) {
+          assert.deepEqual(expected.entries, {});
+          assert.match(await c.page.$eval('.lo-top__right', e => e.textContent), /已调整\s*0/);
+          assert.equal(await c.page.$eval('.lo-top__right button:last-child', e => e.disabled), true,
+            'normal reset still covers only its roster');
+        }
+        console.log(JSON.stringify({ scenario: name, saved: expected, exportDisabled: await disabled(c, 'loadout-export') }));
+        await c.shot(`${name.replaceAll(' ', '-')}-before-export`);
+        const text = await exportText(c);
+        const payload = JSON.parse(text);
+        assert.equal(payload.kind, 'stronghold.loadout');
+        assert.equal(payload.v, 1);
+        assert.equal(payload.count, normal ? 1 : 0, 'count retains its existing entry semantics');
+        assert.deepEqual({ entries: payload.entries, ops: payload.ops }, expected);
+        await c.shot(`${name.replaceAll(' ', '-')}-exported`);
+        target = await open(`${name} import`);
+        if (diyText) {
+          await tab(target, 'diy');
+          await importText(target, diyText, 'diy-import');
+          await tab(target, 'loadout');
+        }
+        await importText(target, text);
+        assert.deepEqual(await saved(target), expected, 'a fresh browser keeps the complete exported loadout');
+        await target.page.reload({ waitUntil: 'domcontentloaded' });
+        await target.page.waitForSelector('.lobby-screen');
+        assert.deepEqual(await saved(target), expected, 'the imported loadout persists across reload');
+        if (patch) {
+          assert.deepEqual(await target.page.evaluate(() => JSON.parse(localStorage.getItem('sp.pref.diy')).picks), JSON.parse(diyText).picks);
+          await target.click('.lobby-screen [data-testid="loadout-open"]');
+          await tab(target, 'diy');
+          await target.page.waitForSelector(`${slot} select[data-cult]`);
+          assert.deepEqual(await target.page.$$eval(`${slot} select[data-cult]`, els => Object.fromEntries(els.map(e => [e.dataset.cult, Number(e.value)]))),
+            { potential: patch.potential ?? 6, cultivate: patch.cultivate ?? 3 }, 'the restored pick displays its restored settings');
+          await target.shot(`${name.replaceAll(' ', '-')}-imported`);
+        }
+        assert.deepEqual([...c.problems, ...target.problems].filter(p => p.startsWith('pageerror:')), []);
+        console.log(JSON.stringify({ scenario: name, payload, imported: await saved(target), resourceProblems: c.problems.length + target.problems.length }));
+      } finally { await target?.close(); await c?.close(); }
+    });
+  }
+
+  test('defaults, clearing a pick and normal reset preserve the existing scopes', { timeout: 90000 }, async () => {
+    let c;
+    try {
+      c = await open('reset');
+      assert.equal(await disabled(c, 'loadout-export'), true);
+      await chooseKalts(c);
+      await tab(c, 'loadout');
+      assert.equal(await disabled(c, 'loadout-export'), true, 'a roster choice alone is not loadout settings');
+      await setKalts(c, { potential: 1, cultivate: 0 });
+      await changeNormal(c);
+      await c.click('.lo-top__right button', '全部恢复默认');
+      await c.click('.modal button', '恢复默认');
+      await c.page.waitForSelector('.modal', { hidden: true });
+      assert.deepEqual(await saved(c), { entries: {}, ops: { [KALTS]: { potential: 1, cultivate: 0 } } });
+      assert.equal(await disabled(c, 'loadout-export'), false, 'normal reset retains exportable DIY settings');
+      await tab(c, 'diy');
+      await c.click(`${slot} [data-testid="diy-clear"]`);
+      await tab(c, 'loadout');
+      assert.equal(await disabled(c, 'loadout-export'), false, 'clearing a pick retains its per-operator settings');
+      await chooseKalts(c);
+      await setKalts(c, { potential: 6, cultivate: 3 });
+      await tab(c, 'loadout');
+      assert.deepEqual(await saved(c), { entries: {}, ops: {} });
+      assert.equal(await disabled(c, 'loadout-export'), true, 'back to defaults: nothing to export');
+      assert.deepEqual(c.problems.filter(p => p.startsWith('pageerror:')), []);
+    } finally { await c?.close(); }
+  });
+});