'
+ '
'
+ '
';
document.body.appendChild(host);
host.querySelector('#__fav_fix_qr_close').addEventListener('click', function () { onClose('cancel'); });
return host;
}
function setQrStatus(host, text) {
var el = host && host.querySelector('#__fav_fix_qr_status');
if (el) el.textContent = text;
}
function closeQr(host) { if (host && host.parentNode) host.parentNode.removeChild(host); }
async function tvLogin() {
toast('正在请求登录授权…');
var ac;
try { ac = await tvAuthCode(); }
catch (e) { toast('授权请求失败：' + e.message, 'err'); return; }
if (ac.code !== 0 || !ac.data || !ac.data.auth_code || !ac.data.url) {
toast('授权响应异常：错误码 ' + ac.code + '，' + ac.message, 'err'); return;
}
var host = null, done = false;
var promise = new Promise(function (resolve) {
host = showQrModal(ac.data.url, function (reason) {
done = true; closeQr(host); resolve({ ok: false, reason: reason });
});
// Poll every 2s for up to 3 minutes.
var deadline = Date.now() + 180000;
(function tick() {
if (done) return;
if (Date.now() > deadline) {
setQrStatus(host, '登录超时，请重新尝试');
setTimeout(function () { closeQr(host); resolve({ ok: false, reason: 'timeout' }); }, 1500);
return;
}
tvPoll(ac.data.auth_code).then(function (r) {
if (done) return;
if (r.code === 0 && r.data && r.data.access_token) {
done = true;
setAuth('tv', r.data.access_token);
setQrStatus(host, '登录成功');
setTimeout(function () { closeQr(host); resolve({ ok: true }); }, 800);
return;
}
// 86039 = waiting for scan; 86090 = scanned, waiting for confirm; 86038 = expired
if (r.code === 86090) setQrStatus(host, '已扫描，请在手机上确认登录');
else if (r.code === 86038) {
setQrStatus(host, '二维码已过期，请重新尝试');
setTimeout(function () { closeQr(host); resolve({ ok: false, reason: 'expired' }); }, 1500);
return;
}
setTimeout(tick, 2000);
}).catch(function (e) {
warn('poll failed', e); setTimeout(tick, 2000);
});
})();
});
var res = await promise;
if (res.ok) toast('登录成功，凭据已保存', 'ok');
else toast('登录已取消（' + res.reason + '）', 'warn');
}
function manualLogin() {
var ak = prompt('请输入 Android 主版 access_key\n（由 appkey ' + AND_APPKEY + ' 签发，对应 mobi_app=android）');
if (!ak || !ak.trim()) return;
setAuth('android', ak.trim());
toast('凭据已保存（手动输入 / Android 模式）', 'ok');
}
// ─── Source registry + resolver ─────────────────────────────────────
//
// Each source exposes:
// name: short id used in priority maps
// enabled: () => bool — whether we can call it right now
// fetchPage({mediaId, pn}) → Promise<{list:[normItem], has_more}>
// Each list item is normalized to the Android-app shape (oid is av,
// upper={mid,name,face}, cnt_info={play,danmaku,thumb_up,coin,
// reply,collect}, etc.) so the merge layer is field-name-stable.
//
// Merge layer: each field has a priority order (which source's value
// to prefer) plus a QUALITY predicate (a value that fails the quality
// check — e.g. the global placeholder cover URL — is skipped, falling
// through to the next source).
//
// Cache: merged per-avid records are persisted in GM storage so a tab
// reload doesn't re-call any API. In-memory per-page Promise cache
// dedups concurrent requests within a session.
// ─── Source failure gate (backoff) ─────────────────────────────────
// Tracks consecutive timeout/network failures per source. After N hits
// in a row, the source is considered "down" and `gate.isOpen(name)`
// returns false for the cooldown window so callers can short-circuit.
// State is intentionally process-memory only: a page reload resets the
// gate so the user gets a fresh attempt without waiting out the cooldown.
var sourceFailureGate = (function () {
// Threshold and cooldown are read at FAILURE time, not captured here:
// this IIFE runs once at load, and a value captured now could never
// reflect a setting changed later in the same page.
var failureCounts = {}; // src → consecutive fail count
var openAt = {}; // src → Date.now() when re-enabled
return {
isOpen: function (src) {
var until = openAt[src] || 0;
if (until && Date.now() < until) return false;
// Window expired — reset and try again.
if (until && Date.now() >= until) {
failureCounts[src] = 0;
openAt[src] = 0;
}
return true;
},
onFail: function (src, reason) {
var backoffMs = cfg('sourceBackoffMin') * 60000;
failureCounts[src] = (failureCounts[src] || 0) + 1;
if (failureCounts[src] >= cfg('sourceFailThreshold') && !openAt[src]) {
openAt[src] = Date.now() + backoffMs;
console.warn('[fav-fix/' + src + '] gated for ' + (backoffMs / 60000)
+ ' min after ' + failureCounts[src] + ' consecutive failures (last: '
+ reason + '). Reload the page to retry sooner.');
}
},
onOk: function (src) {
if (failureCounts[src] || openAt[src]) {
console.info('[fav-fix/' + src + '] backoff gate reset after successful response');
}
failureCounts[src] = 0;
openAt[src] = 0;
},
// For stats() inspection.
snapshot: function () {
var out = {};
Object.keys(failureCounts).forEach(function (s) {
var until = openAt[s] || 0;
out[s] = {
consecutiveFailures: failureCounts[s],
gatedUntilMs: until,
gatedForSec: until ? Math.max(0, Math.round((until - Date.now()) / 1000)) : 0
};
});
return out;
}
};
})();
var SOURCES = {
android: {
name: 'android',
paginated: true,
enabled: function () { return !!getAuth().access_key; },
fetchPage: function (ctx) {
var auth = getAuth();
var base = {
media_id: String(ctx.mediaId),
pn: String(ctx.pn),
ps: '20',
appkey: appkeyFor(auth.mode),
access_key: auth.access_key,
ts: String(Math.floor(Date.now() / 1000)),
// Required-for-invalid-items hints (verified by bisect
// against the captured Android-app traffic — dropping
// any of these four causes the server to silently
// filter invalid items out of the page response):
mobi_app: 'android',
platform: 'android',
build: '8940300',
disable_rcmd: '0',
c_locale: 'en',
s_locale: 'en',
channel: 'bili',
statistics: '{"appId":1,"platform":3,"version":"8.94.0","abtest":""}'
};
var signed = signParams(base, appsecFor(auth.mode));
var url = 'https://api.bilibili.com/x/v3/fav/folder/resources?' + toQuery(signed);
return gmGet(url).then(function (r) {
if (r.code !== 0) throw new Error('android API code=' + r.code + ' msg=' + r.message);
var d = r.data || {};
// Already in Android-app shape — pass through.
return { list: d.list || [], has_more: !!d.has_more, total: d.total };
});
}
},
'public': {
name: 'public',
paginated: true,
enabled: function () { return true; },
fetchPage: function (ctx) {
// Try public spaceDetail (no auth, works for own public favs)
// first, then fall back to fav/resource/list?platform=web
// (uses SESSDATA cookie sent by GM_xmlhttpRequest, works for
// own private favs). Both endpoints return placeholders for
// invalid items' cover/title, but preserve pubtime / fav_time
// / tid / pages / cnt_info — the fields the Android-app
// endpoint omits.
var qs = 'media_id=' + ctx.mediaId + '&pn=' + ctx.pn + '&ps=20'
+ '&keyword=&order=mtime&type=0&tid=0';
var publicUrl = 'https://api.bilibili.com/medialist/gateway/base/spaceDetail?' + qs + '&jsonp=jsonp';
var privateUrl = 'https://api.bilibili.com/x/v3/fav/resource/list?' + qs + '&platform=web';
return gmGet(publicUrl).then(function (r1) {
if (r1.code === 0 && r1.data) return normalizePublicResp(r1.data);
log('public spaceDetail code=', r1.code, '— falling back to private/web');
return gmGet(privateUrl).then(function (r2) {
if (r2.code !== 0) throw new Error('public failed (public=' + r1.code + ' private=' + r2.code + ' msg=' + r2.message + ')');
return normalizePublicResp(r2.data);
});
});
}
},
// ─── Third-party archives ──────────────────────────────────────
// Per-AV (not paginated). The resolver calls fetchAvs(avs) ONLY
// for avs whose cover or title is still poor quality after the
// paginated sources (android + public) finish — gates expensive
// off-site calls. biliplus rate-limits with code -503 (retry-once);
// jijidown answers a cold aid with a "loading" stub first and only
// serves the real record on a follow-up poll (see its fetchAvs).
//
// (A third archive, xbeibeix, used to sit here. It was first dropped
// from SOURCES when the site moved behind Cloudflare's interactive
// Turnstile — GM_xmlhttpRequest only ever got the "Just a moment…"
// page — and kept for a while as a manual link on the missing-item
// banner, which a real browser could still clear. The site has since
// stopped being maintained, so that link is gone too: every trace of
// xbeibeix is out of this codebase. Do not re-add it.)
//
// Failure backoff (sourceFailureGate): if a source eats its full
// per-request timeout (5s) on N consecutive chunks, we mark it
// disabled for the whole cooldown window so we don't waste another 5s
// per patch cycle. State is in-memory only — a TM page reload
// resets and retries everything (typical "is it back yet" check).
biliplus: {
name: 'biliplus',
paginated: false,
enabled: function () { return cfg('enableBiliplus') && sourceFailureGate.isOpen('biliplus'); },
fetchAvs: async function (avs) {
var out = new Map();
if (!avs.length) return out;
// Always-on (not gated by debug mode): 3rd-party calls are
// rare and the user often wants to see whether they fired.
console.info('[fav-fix/biliplus] querying', avs.length, 'av(s):',
avs.slice(0, 5).join(',') + (avs.length > 5 ? ',…' : ''));
// Snapshotted for the whole sweep so the chunk boundaries and
// the progress numbers below stay consistent with each other.
var CHUNK = cfg('biliplusChunk');
// All 3rd-party archives (biliplus / jijidown) are
// best-effort fallbacks; never let a slow archive hold
// up patching the DOM. The per-request timeout is deliberately
// shorter than gmGet's default, keeping the worst case bounded.
var REQ_TIMEOUT = cfg('thirdPartyTimeoutMs');
var sawAnySuccess = false;
var sawAnyFailure = false;
for (var i = 0; i < avs.length; i += CHUNK) {
var chunk = avs.slice(i, i + CHUNK);
var url = 'https://www.biliplus.com/api/aidinfo?aid=' + chunk.join(',');
var r;
try { r = await gmGet(url, { timeout: REQ_TIMEOUT }); }
catch (e) {
console.warn('[fav-fix/biliplus] network error:', e.message);
sawAnyFailure = true;
continue;
}
if (r && r.code === -503) {
console.warn('[fav-fix/biliplus] rate-limited (code -503), retrying in 2s');
await new Promise(function (res) { setTimeout(res, 2000); });
try { r = await gmGet(url, { timeout: REQ_TIMEOUT }); }
catch (e) { sawAnyFailure = true; continue; }
}
if (!r || r.code !== 0 || !r.data) {
console.warn('[fav-fix/biliplus] chunk failed: code=',
r && r.code, 'message=', r && r.message);
sawAnyFailure = true;
continue;
}
sawAnySuccess = true;
var chunkHits = 0;
for (var av in r.data) {
var info = r.data[av];
if (!info || !info.title) continue;
out.set(String(av), {
oid: Number(av),
title: info.title,
cover: info.pic,
upper: info.author ? { name: info.author } : undefined
});
chunkHits++;
}
console.info('[fav-fix/biliplus] chunk', i / CHUNK + 1,
'returned', chunkHits, 'of', chunk.length);
}
// Feed the backoff gate: any single successful response
// resets the counter (server's back). If every chunk failed
// (timeouts, -503, or malformed responses), count it as a
// single failure event for this fetchAvs call.
if (sawAnySuccess) sourceFailureGate.onOk('biliplus');
else if (sawAnyFailure) sourceFailureGate.onFail('biliplus', 'all chunks failed');
console.info('[fav-fix/biliplus] total:', out.size, '/', avs.length);
return out;
}
},
jijidown: {
name: 'jijidown',
paginated: false,
enabled: function () { return cfg('enableJijidown') && sourceFailureGate.isOpen('jijidown'); },
fetchAvs: async function (avs) {
if (!avs.length) return new Map();
console.info('[fav-fix/jijidown] querying', avs.length, 'av(s) (sequential):',
avs.slice(0, 5).join(',') + (avs.length > 5 ? ',…' : ''));
var out = new Map();
// Per-av timeout — see the biliplus comment above.
var REQ_TIMEOUT = cfg('thirdPartyTimeoutMs');
// get_info is two-phase: the FIRST hit for an aid jijidown
// hasn't warmed returns a loading stub
// ({code:0, msg:'loading', title:'正在加载数据...'} with NO
// upid); the real record only lands a second or two later. A
// single shot therefore drops every cold aid (upid undefined →
// "no record"), which is most invalid items — the exact case
// this source exists for. Re-poll the stub a few times before
// giving up. The phase-2 budget in resolveItems still caps
// total wall time, so a folder full of cold aids can't stall
// the DOM patch.
var LOADING_POLL_MS = cfg('jijidownPollMs');
var LOADING_MAX_POLLS = cfg('jijidownMaxPolls'); // 1 initial request + this many re-polls
var sawAnyResponse = false;
for (var i = 0; i < avs.length; i++) {
var av = avs[i];
var url = 'https://www.jijidown.com/api/v1/video/get_info?id=' + av;
var r = null;
for (var attempt = 0; attempt <= LOADING_MAX_POLLS; attempt++) {
try { r = await gmGet(url, { timeout: REQ_TIMEOUT }); }
catch (e) {
console.warn('[fav-fix/jijidown] av', av, 'network error:', e.message);
r = null;
break;
}
sawAnyResponse = true;
if (r && (r.msg === 'loading' || r.title === '正在加载数据...')) {
if (attempt < LOADING_MAX_POLLS) {
await new Promise(function (res) { setTimeout(res, LOADING_POLL_MS); });
continue; // still warming up — re-poll
}
console.info('[fav-fix/jijidown] av', av, 'still loading after',
LOADING_MAX_POLLS + 1, 'polls, skip');
r = null;
}
break;
}
if (!r) continue;
if (!r.upid || r.upid <= 0) {
console.info('[fav-fix/jijidown] av', av, 'no record (upid=' + r.upid + ')');
continue;
}
if (r.title === '视频去哪了呢？' || r.title === '该视频或许已经被删除了') {
console.info('[fav-fix/jijidown] av', av, 'archive empty:', r.title);
continue;
}
if (r.title === String(av) && !r.img) continue;
out.set(String(av), {
oid: Number(av),
title: r.title,
cover: r.img,
upper: r.up && r.up.author ? { name: r.up.author, mid: r.upid } : undefined
});
}
if (sawAnyResponse) sourceFailureGate.onOk('jijidown');
else sourceFailureGate.onFail('jijidown', 'all requests errored');
console.info('[fav-fix/jijidown] total:', out.size, '/', avs.length);
return out;
}
}
};
function normalizePublicResp(d) {
// Both spaceDetail and fav/resource/list return { medias: [...], info: {...}, has_more }.
// medias[].id is the avid (vs Android's oid). Otherwise field
// names line up closely; we rename id→oid and pass the rest through.
var medias = d.medias || [];
var list = medias.map(function (m) {
var out = {};
for (var k in m) out[k] = m[k];
out.oid = m.id != null ? m.id : m.oid;
return out;
});
// folderTitle: the folder's own display name, carried by both public
// endpoints in d.info.title. The backup walker persists it into the
// meta store so the manager panel can label folders by name instead
// of a raw media_id. Resolver callers simply ignore the field.
return { list: list, has_more: !!d.has_more, total: d.info && d.info.media_count,
folderTitle: (d.info && d.info.title) || null };
}
// ─── Quality predicates ────────────────────────────────────────────
//
// Returning 0 means "skip this value, try the next source for this field".
var COVER_PLACEHOLDER_RE = /be27fd62/i;
var QUALITY = {
cover: function (url) {
if (!url) return 0;
if (COVER_PLACEHOLDER_RE.test(url)) return 0;
if (/bfs\/archive/i.test(url)) return 10;
return 5;
},
title: function (t) {
if (!t) return 0;
t = String(t).trim();
if (t === '已失效视频' || t === '该视频已被删除' || t === '已失效') return 0;
return 10;
},
upper: function (u) {
if (!u || typeof u !== 'object') return 0;
if (!u.name || u.name === '账号已注销' || u.name === '账号已注销.') return 0;
return 10;
},
cnt_info: function (c) {
if (!c || typeof c !== 'object') return 0;
// Public endpoint sometimes returns all zeros for invalid items;
// Android-app endpoint preserves the snapshot. Prefer whichever
// has more non-zero fields (handled by priority + this check).
var nonzero = 0;
for (var k in c) if (c[k] && typeof c[k] === 'number') nonzero++;
return nonzero > 0 ? 10 : 1;
},
'default': function (v) {
if (v == null) return 0;
if (typeof v === 'string' && !v.trim()) return 0;
if (Array.isArray(v) && v.length === 0) return 0;
return 10;
}
};
// Priority order: source name LEFT wins if its value passes QUALITY.
// `backup` (15a-backup.js) leads every field it supplies: it is the only
// source captured while the video was still ALIVE, so its snapshot beats
// any post-mortem one by construction. It is absent from attr / link /
// playback_desc on purpose — those describe the item's CURRENT state and
// must come from a live source.
// 3rd-party archives (biliplus / jijidown) carry only title/cover/
// upper.name — they're the last-resort fallback for items even the
// Android-app snapshot couldn't save.
var FIELD_PRIORITY = {
// Android endpoint preserves invalid-item snapshots for these.
cover: ['backup', 'android', 'public', 'biliplus', 'jijidown'],
title: ['backup', 'android', 'public', 'biliplus', 'jijidown'],
upper: ['backup', 'android', 'public', 'biliplus', 'jijidown'],
intro: ['backup', 'android', 'public'],
duration: ['backup', 'android', 'public'],
playback_desc: ['android', 'public'],
attr: ['android', 'public'],
link: ['android', 'public'],
bvid: ['backup', 'public', 'android'],
// Public endpoint has these; Android omits them for invalid items:
cnt_info: ['backup', 'public', 'android'],
pubtime: ['backup', 'public'],
ctime: ['backup', 'public', 'android'],
fav_time: ['backup', 'public'],
tid: ['backup', 'public'],
pages: ['backup', 'public'],
page: ['backup', 'public', 'android']
};
function mergeBySource(perSource) {
var out = {};
var srcs = Object.keys(SOURCES);
// Field-priority merge
for (var field in FIELD_PRIORITY) {
var order = FIELD_PRIORITY[field];
for (var i = 0; i < order.length; i++) {
var src = order[i];
var data = perSource[src];
if (!data) continue;
var v = data[field];
var q = (QUALITY[field] || QUALITY['default'])(v);
if (q > 0) { out[field] = v; out['_src_' + field] = src; break; }
}
}
// Pass-through for any field not covered by FIELD_PRIORITY (e.g.
// oid, otype, ugc, card_type, jump_link…). First source that has
// the field wins (Android > public by registry order).
for (var s = 0; s < srcs.length; s++) {
var d = perSource[srcs[s]];
if (!d) continue;
for (var k in d) {
if (out[k] !== undefined) continue;
if (FIELD_PRIORITY[k]) continue;
out[k] = d[k];
}
}
out._sources = Object.keys(perSource);
// Degenerate = neither cover nor title passed QUALITY from any source.
// Card will render visually unchanged (placeholder cover + "已失效视频"
// text) but with the red marker — easy to confuse with a permanent
// 404. Flagged so loadCache can use a short TTL: the most common
// cause is Android API's walk-to-walk drop (server returns the av
// on some walks, not others), and a fresh walk in ~10 min often
// recovers it. Without the short TTL, one bad walk locks in 30 days.
if (!out._src_cover && !out._src_title) out._degenerate = true;
return out;
}
// Shared promotion predicate: is this merged record a CONFIDENT full
// recovery — one whose cover AND title are real, settled data? Used by
// the backup walker's merged-fallback gate (15a buildBackupRecord) and by
// the recovery-time promotion pipeline (15e-promote.js), so the two can
// never drift apart on what "confident" means. The _degenerate / _pending
// / _cover_pending exclusions are implied by requiring both _src_* fields
// (mergeBySource only sets those when QUALITY passed), and the QUALITY
// re-checks are likewise redundant — stated anyway as belt-and-braces,
// because a record passing this gate may be written into the backup store
// where a bad value would be served back as gospel forever.
function promotionGate(m) {
return !!m
&& !m._degenerate && !m._pending && !m._cover_pending
&& !!m._src_cover && !!m._src_title
&& QUALITY.cover(m.cover) >= 5
&& QUALITY.title(m.title) >= 10;
}
// ─── Persistent per-avid cache ──────────────────────────────────────
//
// CACHE_VERSION exists so that adding a new source (or changing merge
// semantics) can invalidate every cached entry at once — otherwise
// items cached before the new source was added would never get the
// chance to be re-fetched from it.
//
// BUMP CACHE_VERSION when:
// - adding a new SOURCES entry
// - changing FIELD_PRIORITY / QUALITY in a way that affects merge
// - changing the merged-item shape (renaming fields etc.)
var CACHE_PREFIX = 'item:av';
var CACHE_VERSION = 7; // bumped: SOURCES.backup now offers a cover only when it holds the bytes (byteless records fall to _cover_pending instead of winning the cover slot with a dead url)
// → cfg('cacheTtlDays'), default 30.
// Short TTL for NOT-confidently-recovered merges (_degenerate / _pending).
// This is a STALENESS guard, NOT a retry timer: live retry is owned wholly
// by the background runFlapRecovery loop (08-resolver.js), which re-walks
// android on its own backoff and re-patches in place. The short TTL only
// governs what a FUTURE fresh resolve (a reload / folder-switch minutes or
// hours later) does — after it expires, that fresh resolve re-fetches and
// re-kicks the loop instead of reusing a stale "still deleted" snapshot.
// A 30-day lock-in would instead turn one bad android walk into a permanent
// failure, so these stay short.
// → cfg('cacheTtlDegenerateMin'), default 10.
function loadCache(av) {
var v = GM_getValue(CACHE_PREFIX + av, null);
if (!v) return null;
if (v._cache_version !== CACHE_VERSION) {
log('cache av', av, 'version', v._cache_version, '!=', CACHE_VERSION, '— invalidating');
return null;
}
// Short TTL for any NOT-confidently-recovered entry:
// _degenerate — some source returned only placeholders, or
// _pending — android may still flap the real snapshot back in
// (see runFlapRecovery in 08-resolver.js), or
// _cover_pending — the title was recovered but the cover is still a
// placeholder; the card is patched, yet the flap
// loop is still chasing the image. Long-TTL locking
// here is what a title-only LOCAL BACKUP record
// (which never expires) would otherwise impose on
// every future resolve of that av.
// Locking these for 30 days would turn a transient android walk-to-walk
// drop into a permanent "deleted" (observed: a war-footage folder where
// android returned 58/89 on one walk and the dropped items all fell to
// _no_source). Only a confidently-recovered merge gets the long TTL.
var ttl = (v._degenerate || v._pending || v._cover_pending)
? cfg('cacheTtlDegenerateMin') * 60000
: cfg('cacheTtlDays') * 86400000;
if (v._cached_at && (Date.now() - v._cached_at > ttl)) return null;
return v;
}
// loadCache without the staleness test. The entry is past its TTL, but it
// is still the best thing this script knows about the av — and for an av on
// the 停止重试 list that is the whole story, because no network work will be
// scheduled to learn anything better. The resolver uses it there instead of
// overwriting a title-bearing merge with a bare _pending stub (08-resolver.js
// merge block). Deliberately does NOT refresh _cached_at: the entry has to
// stay stale so the first resolve after the suppression lapses re-fetches.
function loadCacheStale(av) {
var v = GM_getValue(CACHE_PREFIX + av, null);
if (!v) return null;
if (v._cache_version !== CACHE_VERSION) return null;
return v;
}
function saveCache(av, merged) {
merged._cache_version = CACHE_VERSION;
merged._cached_at = Date.now();
try { GM_setValue(CACHE_PREFIX + av, merged); }
catch (e) { warn('saveCache failed for av', av, e); }
}
// Note for anyone extending the clearing paths below: they clear DERIVED
// data (re-fetchable merges) only. The IndexedDB backup store
// (15a-backup.js) is user-authored data with no upstream to re-fetch from
// and must NEVER be dropped here.
function clearItemCache(av) { GM_deleteValue(CACHE_PREFIX + av); }
function clearAllItemCache() {
if (typeof GM_listValues !== 'function') {
warn('GM_listValues not granted — bulk clear unavailable');
return -1;
}
var n = 0;
GM_listValues().forEach(function (k) {
if (k.indexOf(CACHE_PREFIX) === 0) { GM_deleteValue(k); n++; }
});
return n;
}
// ─── "Stop retrying" list (user decision, deliberately NOT cache) ────
//
// Why this is its own GM prefix instead of a field on the item cache:
// the item cache (07-cache.js, `item:av…`) holds DERIVED data — every entry
// is re-fetchable, carries a TTL, and the "清除所有缓存" menu command wipes
// the lot. A user's decision to stop retrying a video is none of those
// things: it has to outlive the cache, survive a cache purge, and take
// effect the instant the badge is clicked instead of when the snapshot next
// expires. So it lives under its own prefix, is held in memory as a Set/Map
// for O(1) render-time lookups, and is read LIVE everywhere — the cached
// merge shape and CACHE_VERSION are untouched by this feature.
//
// Two modes, at most one record per av:
// 'user' — the user pressed 停止重试. Never expires.
// 'auto' — runFlapRecovery genuinely gave up on this av. Expires after
// the auto TTL, so a folder that merely flapped badly for
// one afternoon is not written off permanently.
// 'user' overwrites 'auto'; 'auto' must NEVER overwrite 'user' (that would
// silently downgrade a permanent decision into one expiring in a week).
//
// Which predicate to use where:
// isRetrySuppressed — every AUTOMATIC path (does resolveItems walk pages,
// does the background loop arm itself). Honours both
// modes.
// isNoRetryUser — everything the user explicitly triggered (manual
// retry, the loop's in-flight pruning). Honours the
// 'user' mode only, because a manual retry means
// "ignore what the loop concluded and sample again".
//
// No new GM_* API is introduced: GM_getValue / GM_setValue / GM_deleteValue
// / GM_listValues are all already in the bootstrap @grant block. In
// particular GM_addValueChangeListener is NOT granted and the bootstrap
// @version is frozen at 1.0.0 (it is a contract — see AGENTS.md), so this
// list does NOT sync across tabs: a stop pressed in tab A is visible in
// tab B only after a reload. That limit is documented in README 已知限制;
// do not try to work around it here.
var NORETRY_PREFIX = 'noretry:av';
// → cfg('autoNoRetryTtlDays'), default 7. Read through autoNoRetryTtlMs()
// rather than inlined, because three call sites need the same conversion.
function autoNoRetryTtlMs() { return cfg('autoNoRetryTtlDays') * 86400000; }
var _noRetryUser = new Map(); // av → ms the user pressed stop (permanent)
var _noRetryAuto = new Map(); // av → ms the loop gave up (7-day life)
var _noRetryLoaded = false;
// Build the in-memory index from GM storage once per page load, dropping
// auto records that have aged out on the way through so the store cannot
// grow without bound. Idempotent via _noRetryLoaded: boot() calls it once,
// and every accessor below calls it too, so a future change to boot order
// can never leave the list silently empty.
function loadNoRetryIndex() {
if (_noRetryLoaded) return;
_noRetryLoaded = true;
if (typeof GM_listValues !== 'function') {
// Same degradation as clearAllItemCache: warn and carry on with an
// empty list. Losing the feature is acceptable; throwing here would
// take boot() — and with it the whole resolve path — down with it.
warn('GM_listValues not granted — 停止重试 list unavailable');
return;
}
var now = Date.now(), expired = 0;
GM_listValues().forEach(function (k) {
if (k.indexOf(NORETRY_PREFIX) !== 0) return;
var av = k.slice(NORETRY_PREFIX.length);
var v = GM_getValue(k, null);
// Unreadable / shapeless record: drop it rather than guessing a
// mode, otherwise a corrupt entry suppresses an av forever with no
// way for the UI to show or clear it.
if (!v || (v.mode !== 'user' && v.mode !== 'auto')) { GM_deleteValue(k); return; }
if (v.mode === 'user') { _noRetryUser.set(av, v.at || 0); return; }
if (now - (v.at || 0) > autoNoRetryTtlMs()) { GM_deleteValue(k); expired++; return; }
_noRetryAuto.set(av, v.at || 0);
});
log('noretry: loaded', _noRetryUser.size, 'user +', _noRetryAuto.size,
'auto record(s)' + (expired ? ' (' + expired + ' expired auto dropped)' : ''));
}
// Manual, permanent stop. The card menu and the cover badge both ask this.
function isNoRetryUser(av) {
loadNoRetryIndex();
return _noRetryUser.has(String(av));
}
// When the user stopped this av, in ms — the tooltip prints it as
// 「已于 YYYY-MM-DD 停止」. null when the av is not on the user list, or
// when the record predates the timestamp being written.
function noRetryUserAt(av) {
loadNoRetryIndex();
return _noRetryUser.get(String(av)) || null;
}
// The gate for automatic network work: a manual stop, or an auto record the
// loop wrote less than autoNoRetryTtlMs() ago. Expired auto records are
// cleared on the spot so the storage entry disappears with the suppression.
function isRetrySuppressed(av) {
loadNoRetryIndex();
av = String(av);
if (_noRetryUser.has(av)) return true;
var at = _noRetryAuto.get(av);
if (at == null) return false;
if (Date.now() - at > autoNoRetryTtlMs()) { clearNoRetry(av); return false; }
return true;
}
function setNoRetryUser(av) {
loadNoRetryIndex();
av = String(av);
var at = Date.now();
_noRetryUser.set(av, at);
_noRetryAuto.delete(av); // one record per av: user supersedes auto
try { GM_setValue(NORETRY_PREFIX + av, { at: at, mode: 'user' }); }
catch (e) { warn('setNoRetryUser failed for av', av, e); }
}
// Written by runFlapRecovery when it truly gives up (see its finally). A
// pre-existing user record outranks it and must survive untouched.
function markAutoNoRetry(av) {
loadNoRetryIndex();
av = String(av);
if (_noRetryUser.has(av)) return;
var at = Date.now();
_noRetryAuto.set(av, at);
try { GM_setValue(NORETRY_PREFIX + av, { at: at, mode: 'auto' }); }
catch (e) { warn('markAutoNoRetry failed for av', av, e); }
}
function clearNoRetry(av) {
loadNoRetryIndex();
av = String(av);
_noRetryUser.delete(av);
_noRetryAuto.delete(av);
GM_deleteValue(NORETRY_PREFIX + av);
}
// Returns what was cleared, so the menu command can report both modes.
function clearAllNoRetry() {
loadNoRetryIndex();
var counts = { user: _noRetryUser.size, auto: _noRetryAuto.size };
_noRetryUser.forEach(function (at, av) { GM_deleteValue(NORETRY_PREFIX + av); });
_noRetryAuto.forEach(function (at, av) { GM_deleteValue(NORETRY_PREFIX + av); });
_noRetryUser.clear();
_noRetryAuto.clear();
return counts;
}
function noRetryCounts() {
loadNoRetryIndex();
return { user: _noRetryUser.size, auto: _noRetryAuto.size };
}
// Flat dump for the debug surface (__biliFavFix.noRetry.list()).
function noRetryList() {
loadNoRetryIndex();
var out = [];
_noRetryUser.forEach(function (at, av) {
out.push({ av: av, mode: 'user', at: at, when: at ? new Date(at).toLocaleString() : null });
});
_noRetryAuto.forEach(function (at, av) {
out.push({ av: av, mode: 'auto', at: at, when: at ? new Date(at).toLocaleString() : null,
expiresAt: at ? new Date(at + autoNoRetryTtlMs()).toLocaleString() : null });
});
return out;
}
// ─── Resolver ───────────────────────────────────────────────────────
var pageCache = new Map(); // key=`${src}|${mediaId}|${pn}` → Promise扫码登录（TV 端授权）
'
+ '请使用 bilibili 手机客户端的扫一扫功能
'
+ '等待扫描
'
+ ''
+ ''
+ '' + esc(label) + ''
+ '' + valueHtml + srcTag(srcName) + ''
+ '
';
}
function codeTag(text) {
return ''
+ esc(text) + '';
}
// Source attribution chips. Color-coded per source so the user can
// see at a glance which API contributed which field of the snapshot.
var SOURCE_COLORS = {
backup: '#8e44ad',
android: '#5b8def',
'public': '#67c23a',
biliplus: '#e6a23c',
jijidown: '#f56c6c'
};
function srcTag(src) {
if (!src) return '';
var color = SOURCE_COLORS[src] || '#909399';
return ' ' + esc(src) + '';
}
function buildTipHtml(real) {
if (!real) return '';
// Unrecoverable stub — no source returned data. Render a slim
// tooltip that says exactly that (and lists which sources we tried)
// instead of the normal rich layout with empty fields everywhere.
if (real._no_source) {
var av = real.oid != null ? String(real.oid) : '';
var bv = av ? avToBv(av) : null;
// Prefer _attempted (new, accurate: phase 1 + phase 2 unioned).
// Fall back to _attempted_3rd (legacy: 3rd-party only) for old
// cache entries, then to _tried_sources (oldest: all possible
// sources from the registry, not necessarily queried) as a
// last-resort display.
var attemptedList = real._attempted || real._attempted_3rd || real._tried_sources || [];
var attemptedHtml = attemptedList.map(srcTag).join('');
return ''
+ '视频已删除 · 无任何数据来源保留快照
'
+ (av ? 'AV ' + codeTag('av' + av) + '
' : '')
+ (bv ? 'BV ' + codeTag(bv) + '
' : '')
+ ''
+ '已查询以下数据来源，均无记录：'
+ '
'
+ '' + attemptedHtml + '
'
+ ''
+ 'fav-fix · 视频可能已被永久删除' + '
';
}
// Pending — still being chased by the background android flap loop, or
// waiting for a future retry after it gave up. There's no good snapshot
// yet, so render a state-aware explainer (NOT the normal rich layout
// with empty fields). _flapBgRunning and the 停止重试 list are read LIVE
// here — showTip rebuilds innerHTML on every hover, and once a second
// while hovering — so the text tracks all three badge states: the loop
// is alive (重试中), it gave up (待重试), or the user switched this av
// off (已停止重试). The stopped copy is static, which makes the
// once-a-second rebuild harmless rather than something to special-case.
if (real._pending) {
var pav = real.oid != null ? String(real.oid) : (real.bvid ? bvToAv(real.bvid) : '');
var pbv = real.bvid || (pav ? avToBv(pav) : null);
// Third, highest-priority state: the user pressed 停止重试. Read
// live from the list (07a-noretry.js), same as the badge — the flap
// loop's liveness is irrelevant once the av is switched off.
var pStopped = pav ? isNoRetryUser(pav) : false;
// Fourth state, and the one the copy below has to distinguish: the
// loop gave up on this av and recorded an 'auto' 停止重试 (7 days).
// Nothing is chasing it — resolveItems keeps it out of the walk AND
// out of the loop's candidate set — so it must neither borrow a
// running loop's 重试中 wording nor be told that reloading retries.
var pPaused = !pStopped && pav ? isRetrySuppressed(pav) : false;
var pActive = !pStopped && !pPaused && _flapBgRunning;
var pHead = pStopped ? '已停止重试'
: (pActive ? '正在找回此视频快照…'
: (pPaused ? '暂未找回，自动重试已暂停' : '暂未找回，等待重试'));
// Live status block: only while the loop is actually running AND its
// progress belongs to THIS folder (the loop nulls _flapProgress on
// exit / folder switch). Answers "why still 重试中 / what is it doing"
// with the real loop state. showTip re-renders this once a second so
// the countdown and elapsed time tick visibly (proof it isn't stuck).
var liveHtml = '';
var prog = _flapProgress;
if (pActive && prog && prog.mediaId === detectMediaId()) {
var stateLine;
if (prog.phase === 'sleeping') {
var secs = Math.max(0, Math.ceil((prog.nextWalkAt - Date.now()) / 1000));
stateLine = '当前：等待下次采样（约 ' + secs + ' 秒后）';
} else {
stateLine = '当前：正在重新采样（第 ' + (prog.page || 1) + ' 页）';
}
liveHtml = ''
+ '已采样 ' + prog.walk + ' 轮 · 整夹还剩 ' + prog.remaining + ' 项待找回
' + esc(stateLine) + '
' + '已用时 ' + fmtElapsed(Date.now() - prog.startedAt) + ' · 连续 ' + prog.dry + '/' + prog.maxDry + ' 轮无新增即停' + '
';
}
var pBody = pStopped
? '此视频的自动重试已由你手动停止，脚本不会再为它请求任何接口。点封面上的「恢复重试」按钮，或在本卡片右上「···」菜单选同名项，即可恢复并立即重新抓取一轮。'
: (pActive
? 'bilibili 的 android 收藏接口会随机漏掉一部分失效视频，脚本正在后台多次重新采样把它捞回来。找回后本卡片会自动更新封面与标题，无需手动操作。'
: (pPaused
// The give-up copy below promises that a reload re-tries. With
// an auto record in place that is false: the next resolve skips
// the page walk for this av entirely. Say what actually happens.
? '后台已多次重新采样仍未取回——可能视频确实已被删除，也可能是 bilibili 接口暂时不返回。为避免每次进入收藏夹都重跑一轮，脚本已暂停对它的自动重试，约一周后自动恢复；期间重新整理本页不会再为它请求接口。如需立刻再试一轮，可在本卡片右上「···」菜单点「立即重试」。'
: '后台已多次重新采样仍未取回——可能视频确实已被删除，也可能是 bilibili 接口暂时不返回。重新整理本页会自动再试一轮；也可在本卡片右上「···」菜单点「立即重试」立刻再抓一轮。'));
// When the stop was recorded. Only for the manual mode: an auto
// record is not the user's decision and has no place in a tooltip
// that tells them what they themselves switched off.
var pStoppedAt = pStopped ? noRetryUserAt(pav) : null;
var pStoppedAtHtml = pStoppedAt
? '' + esc(stateLine) + '
' + '已用时 ' + fmtElapsed(Date.now() - prog.startedAt) + ' · 连续 ' + prog.dry + '/' + prog.maxDry + ' 轮无新增即停' + '
已于 '
+ esc(fmtTime(Math.floor(pStoppedAt / 1000))) + ' 停止
'
: '';
return ''
+ esc(pHead) + '
'
+ (pav ? 'AV ' + codeTag('av' + pav) + '
' : '')
+ (pbv ? 'BV ' + codeTag(pbv) + '
' : '')
+ liveHtml
+ ''
+ esc(pBody) + '
'
+ pStoppedAtHtml
+ ''
+ 'fav-fix · ' + (pStopped ? '已停止重试'
: (pActive ? '重试中（后台自动）'
: (pPaused ? '待重试（自动重试已暂停）' : '待重试'))) + '
';
}
var parts = [];
// Title — full width, bold, with source chip after the title text.
parts.push(''
+ esc(real.title || '（无标题）')
+ srcTag(real._src_title)
+ '
');
// 封面 — dedicated row showing WHICH source supplied the patched
// cover. The cover itself isn't shown in tooltip (it's on the
// card img), so this row exists purely for source attribution.
if (real.cover && real._src_cover) {
parts.push(row('封面', '已恢复', real._src_cover));
} else if (real._cover_pending) {
// Partial card: the row would otherwise silently vanish and the
// rich layout would read as full success. State is read LIVE
// (stop list + _flapBgRunning), same pattern as the _pending
// branch above, so the copy tracks the loop's life: user-stopped
// wins, then auto-suppressed (nothing is chasing it for ~7 days),
// then a running loop, then the plain fallback — the loop simply
// finished, or there is no loop at all (credential-less local
// restore, where the stamp is in-memory only).
var cav = real.oid != null ? String(real.oid) : (real.bvid ? bvToAv(real.bvid) : '');
var cStopped = cav ? isNoRetryUser(cav) : false;
var cPaused = !cStopped && cav ? isRetrySuppressed(cav) : false;
var cTxt = cStopped ? '暂未找回，已停止重试'
: (cPaused ? '暂未找回，自动重试已暂停'
: (_flapBgRunning ? '仍在后台重试' : '暂未找回'));
parts.push(row('封面', '' + esc(cTxt) + ''));
}
// UP 主
if (real.upper && (real.upper.name || real.upper.face)) {
var faceUrl = real.upper.face ? real.upper.face.replace(/^http:\/\//, 'https://') : '';
// Only render the avatar img for absolute http(s) faces (esc still
// guards attribute breakout; isHttpUrl rejects javascript:/data:).
var avatar = isHttpUrl(faceUrl)
? ''
+ esc(intro)
+ srcTag(real._src_intro)
+ '
');
}
// Footer — list of contributing sources + sources that queried but
// returned nothing. Two fields drive this:
// _sources = sources whose data ended up in some merged field
// _attempted = every source that actually queried this av
// (phase 1 paginated + phase 2 per-av). Tooltip
// shows attempted-minus-contributing as "已查询但
// 无记录" so the user can see "android + public
// + biliplus all came back empty, only jijidown
// had it" instead of those sources silently
// disappearing.
// _attempted_3rd = legacy field (3rd-party only). Read as a
// fallback so pre-0.7.2 cached entries still
// show whatever attempts they have.
var srcChips = '';
if (real._sources && real._sources.length) {
srcChips = '数据来源：' + real._sources.map(srcTag).join('') + '
';
}
var attempted = real._attempted || real._attempted_3rd || [];
var missAttempts = attempted.filter(function (s) {
return !real._sources || real._sources.indexOf(s) === -1;
});
var missChips = '';
if (missAttempts.length) {
missChips = '已查询但无记录：'
+ missAttempts.map(srcTag).join('') + '
';
}
parts.push(''
+ 'fav-fix · 数据来自收藏时的快照'
+ srcChips
+ missChips
+ '
');
return parts.join('');
}
function showTip(el, real, evt) {
var tip = getTip();
stopTipRefresh();
tip.innerHTML = buildTipHtml(real);
tip.style.display = 'block';
// Position: prefer above the element, centered horizontally;
// if it would clip off the top, place it below.
var r = el.getBoundingClientRect();
var vw = window.innerWidth, vh = window.innerHeight;
// Make sure layout is computed before reading offsetWidth.
tip.style.left = '0px'; tip.style.top = '0px';
var tw = tip.offsetWidth, th = tip.offsetHeight;
var left = Math.max(8, Math.min(vw - tw - 8, r.left + r.width / 2 - tw / 2));
var top = r.top - th - 10;
if (top < 8) top = Math.min(vh - th - 8, r.bottom + 10);
tip.style.left = left + 'px';
tip.style.top = top + 'px';
// rAF so the opacity transition actually animates from 0 → 1.
requestAnimationFrame(function () { tip.style.opacity = '1'; });
// Pending card: keep the live status fresh while hovering. Re-read the
// element's CURRENT real each tick (el.__favFixReal) so that if the flap
// loop recovers this card mid-hover, the tooltip upgrades to the normal
// rich layout and the refresh stops on its own. Position is left as set
// (content height barely changes between ticks).
if (real && real._pending) {
_tipRefreshTimer = setInterval(function () {
if (tip.style.display === 'none') { stopTipRefresh(); return; }
var liveReal = (el && el.__favFixReal) || real;
tip.innerHTML = buildTipHtml(liveReal);
if (!liveReal._pending) stopTipRefresh();
}, cfg('tooltipRefreshMs'));
}
}
function hideTip() {
var tip = getTip();
stopTipRefresh();
tip.style.opacity = '0';
setTimeout(function () {
if (tip.style.opacity === '0') tip.style.display = 'none';
}, 150);
}
// ─── Per-card menu injection ────────────────────────────────────────
//
// bilibili's own three-dot dropdown on each card (the "更多操作" menu)
// is the most natural place for per-item actions — copy AV/BV/full
// info, open the cover in a new tab, jump to a mirror site, clear
// this item's cache. cerenkov's approach (mouseenter on the trigger,
// delay 500ms, find the dynamically-rendered popper, append) works
// well; we port it to vanilla and add dedup via data-fav-fix-key
// so each item is only injected once per session.
function buildPlainInfo(real) {
var av = real.oid != null ? String(real.oid) : (real.bvid ? bvToAv(real.bvid) : null);
var bv = real.bvid || (av ? avToBv(av) : null);
// tag(field) → '[src]' or '' — inline source attribution.
function tag(field) {
var s = real['_src_' + field];
return s ? ' [' + s + ']' : '';
}
var lines = [];
lines.push('【fav-fix】数据来自收藏时的快照');
lines.push('────────────');
lines.push('标题：' + (real.title || '（无）') + tag('title'));
// Mirror of the tooltip's cover row (AGENTS.md invariant: the two must
// not diverge). Deliberately static — the copied text is a snapshot,
// so the live three-way suppression read would be stale by the time
// anyone reads the clipboard.
if (real.cover) lines.push('封面：（已恢复）' + tag('cover'));
else if (real._cover_pending) lines.push('封面：（后台重试中）');
if (real.upper) lines.push('UP 主：' + (real.upper.name || '（无）') + (real.upper.mid ? ' UID ' + real.upper.mid : '') + tag('upper'));
if (av) lines.push('AV：av' + av);
if (bv) lines.push('BV：' + bv + tag('bvid'));
if (real.duration || real.playback_desc) lines.push('时长：' + (real.playback_desc || fmtDuration(real.duration)) + tag('duration'));
if (real.cnt_info) {
var c = real.cnt_info, bits = [];
if (c.play != null) bits.push('播放 ' + c.play);
if (c.danmaku != null) bits.push('弹幕 ' + c.danmaku);
if (c.thumb_up != null) bits.push('点赞 ' + c.thumb_up);
if (c.coin != null) bits.push('投币 ' + c.coin);
if (c.reply != null) bits.push('评论 ' + c.reply);
if (c.collect != null) bits.push('收藏 ' + c.collect);
if (bits.length) lines.push('数据：' + bits.join(' · ') + tag('cnt_info'));
}
if (real.tid != null) lines.push('分区 TID：' + real.tid + tag('tid'));
// Use the same fallback chain + source as the hover tooltip
// (pickPubTs / pickPubSrc) so copied text matches what was shown.
var _pubTs = pickPubTs(real);
if (_pubTs) {
var _pubSrc = pickPubSrc(real);
lines.push('投稿：' + new Date(_pubTs * 1000).toLocaleString() + (_pubSrc ? ' [' + _pubSrc + ']' : ''));
}
if (real.fav_time) lines.push('收藏：' + new Date(real.fav_time * 1000).toLocaleString() + tag('fav_time'));
if (real.intro && real.intro.trim()) lines.push('简介：' + real.intro + tag('intro'));
if (real.link) lines.push('原 link：' + real.link);
lines.push('────────────');
if (real._sources) lines.push('数据来源：' + real._sources.join('、'));
// Same split as buildTipHtml's footer: show "queried but empty"
// sources so the user copying full info also sees the full chain.
var pAttempted = real._attempted || real._attempted_3rd || [];
var pMiss = pAttempted.filter(function (s) {
return !real._sources || real._sources.indexOf(s) === -1;
});
if (pMiss.length) lines.push('已查询但无记录：' + pMiss.join('、'));
return lines.join('\n');
}
function buildMenuItems(hit, real) {
var av = real.oid != null ? String(real.oid) : (real.bvid ? bvToAv(real.bvid) : null);
// Re-read the freshest cache entry. The `real` captured when injectCardMenu
// bound this card's dropdown can be STALE: a pending card may have since
// recovered (or vice-versa), and the new-UI popper handler keeps the
// original closure. av/bv identity is stable, but _pending / title /
// sources may have changed — build from the live entry so a recovered
// card never shows "立即重试" and a pending card never copies an empty
// snapshot. (buildMenuItems runs fresh on each menu open, so this stays
// current.)
if (av) { var _lc = loadCache(av); if (_lc) real = _lc; }
var bv = real.bvid || (av ? avToBv(av) : null);
// Same live-read reasoning as the loadCache line above, for the same
// reason: the user may have stopped or resumed this av since the
// dropdown was bound, and the closure would show the stale action.
var stopped = av ? isNoRetryUser(av) : false;
var items = [];
// Retry controls, mutually exclusive by card state (the existing
// 立即重试 / 清缓存并重抓 split, now with the stop switch folded in):
// stopped → 恢复重试 only. Offering 立即重试 next
// to it would be two buttons for one
// decision the user already made.
// _pending / _cover_pending → 立即重试 (re-arm now) + 停止重试.
// Partial cards carry NO badge (the
// cover is chased quietly in the
// background), so the menu — plus the
// amber outline and the tooltip's
// 封面 row — is their entry point.
// kickManualRetry re-derives the
// cover-only rule from loadCache, so
// a lone partial av is not retired by
// the title it already has.
if (av && stopped) items.push({
key: 'retry', label: '恢复重试',
onClick: function () { resumeRetryForAv(av); }
});
else if (av && (real._pending || real._cover_pending)) {
items.push({
key: 'retry', label: '立即重试',
onClick: function () { kickManualRetry(av); }
});
items.push({
key: 'stop-retry', label: '停止重试',
onClick: function () { stopRetryForAv(av); }
});
}
if (av) items.push({
key: 'cp-av', label: '复制 AV 号',
successMsg: '已复制 av' + av + ' 至剪贴板',
onClick: function () { GM_setClipboard('av' + av, 'text'); }
});
if (bv) items.push({
key: 'cp-bv', label: '复制 BV 号',
successMsg: '已复制 ' + bv + ' 至剪贴板',
onClick: function () { GM_setClipboard(bv, 'text'); }
});
items.push({
key: 'cp-info', label: '复制完整信息',
successMsg: '完整信息已复制至剪贴板',
onClick: function () { GM_setClipboard(buildPlainInfo(real), 'text'); }
});
// Cover URL may come from an untrusted 3rd-party source — only offer
// "open cover" for an absolute http(s) URL (isHttpUrl rejects
// javascript:/data: that GM_openInTab would otherwise navigate to).
var coverUrl = real.cover ? String(real.cover).replace(/^http:\/\//, 'https://') : '';
if (coverUrl && !COVER_PLACEHOLDER_RE.test(coverUrl) && isHttpUrl(coverUrl)) items.push({
key: 'open-cover', label: '查看原始封面',
onClick: function () {
// Re-check at click time (defensive; coverUrl is captured above).
if (!isHttpUrl(coverUrl)) { toast('封面链接异常，已拦截', 'warn'); return; }
GM_openInTab(coverUrl, { active: true, insert: true, setParent: true });
}
});
if (av) items.push({
key: 'open-bp', label: '在 biliplus 查看',
onClick: function () {
GM_openInTab('https://www.biliplus.com/video/av' + av + '/',
{ active: true, insert: true, setParent: true });
}
});
// Hidden on _pending cards: they have no real cached snapshot to clear
// (just a placeholder stub), so "清缓存并重抓" is a heavier, noisier
// duplicate of "立即重试" (full-page foreground re-resolve + spinner
// re-flash vs. a quiet android re-walk). Hidden on _cover_pending
// (partial) cards for the opposite reason: they DO hold a real
// title/UP/date snapshot, and clearing it discards data the card is
// already displaying just to re-chase an image 立即重试 re-samples
// without touching. The retry-flavored actions are mutually exclusive
// by card state: 立即重试 for pending/partial, 清缓存并重抓 for
// recovered/terminal cards where nuking a possibly-wrong snapshot
// actually means something. (real is the live loadCache re-read above,
// so this self-corrects as the card transitions pending↔recovered.)
// Also hidden while the av is user-stopped: "恢复重试" already IS a
// clear-and-refetch (resumeRetryForAv drops the caches and re-runs
// patchOnce), and a second button that clears the cache while every
// network path stays suppressed would only downgrade a patched card to
// a bare pending stub.
if (av && !real._pending && !real._cover_pending && !stopped) items.push({
// Label kept short to avoid wrapping inside bilibili's
// fixed-width card-menu popper. "清除本条缓存并重新抓取" (11
// chars) wrapped to two lines and the second line overflowed
// the popper bounds — see git log around this label change.
key: 'clear-cache', label: '清缓存并重抓',
successMsg: '缓存已清除，重新抓取中',
onClick: function () {
// An 'auto' 停止重试 record would silently gut this action:
// the caches would be dropped and then resolveItems would skip
// every network source, leaving the card worse off than before
// the click. An explicit user action overrides what the loop
// concluded, so drop that record too. (A 'user' record cannot be
// present — this item is not offered for stopped cards.)
clearNoRetry(av);
// Cache nuke for this av (GM item + in-memory rows + page
// promises). Shared with forceRefetch() via dropItemCaches so
// both paths really re-fetch instead of re-merging stale rows.
dropItemCaches(av);
// The hit captured in this closure is from whenever
// injectCardMenu was last called — possibly stale by now if
// bilibili's SPA re-rendered the card. Operating on stale
// refs paints overlays into detached subtrees that the user
// never sees. Re-resolve to the LIVE element by hunting for
// the card whose link mentions this av's avid or bvid.
var bvid = null;
try { bvid = avToBv(av); } catch (e) { /* invalid av */ }
var sel = 'a[href*="/video/av' + av + '"]'
+ (bvid ? ', a[href*="/video/' + bvid + '"]' : '');
var liveContainer = null, liveImg = null;
document.querySelectorAll(sel).forEach(function (a) {
if (liveContainer) return;
// Resolve to the WHOLE card (same scope findInvalidContainers
// now uses) so the title reset, mark-clearing, and the
// __favFixReal tooltip binding all act on the node markPatched
// actually touched — the cover-only sub-div never held the
// title leaf, which is why the reset used to miss it.
var card = a.closest(CARD_SELECTOR);
if (card) {
liveContainer = card;
liveImg = card.querySelector('img[src*="' + PLACEHOLDER_COVER_TOKEN + '"]')
|| card.querySelector('img');
return;
}
var n = a;
while (n && n !== document.body) {
var img = n.querySelector && n.querySelector('img');
if (img) { liveContainer = n; liveImg = img; return; }
n = n.parentElement;
}
});
// Fallback to closure hit if live lookup misses (defensive
// — should not happen for a card the user just clicked).
if (!liveContainer) liveContainer = hit && hit.container;
if (!liveImg) liveImg = hit && hit.img;
// Tear down any prior overlay on the LIVE img (rapid
// double-click stacks spinners otherwise).
if (liveImg) clearLoading({ img: liveImg, container: liveContainer });
// Reset img: restore the placeholder src if we swapped it,
// strip inline styles applied by markPatched / _no_source,
// drop marker attrs so findInvalidContainers re-detects.
if (liveImg) {
var orig = liveImg.getAttribute('data-fav-fix-original');
if (orig) {
liveImg.src = orig;
liveImg.removeAttribute('data-fav-fix-original');
}
liveImg.style.outline = '';
liveImg.style.outlineOffset = '';
liveImg.style.opacity = '';
liveImg.style.filter = '';
liveImg.removeAttribute('data-fav-fix-marked');
liveImg.removeAttribute('data-fav-fix-loading');
// Hygiene: the item is hidden for partial cards, but the
// card's state can shift between menu render and click —
// a full reset must not leave the amber partial marker.
liveImg.removeAttribute('data-fav-fix-partial');
}
// Reset container: revert any title text we wrote
// (recovered title or "（视频已删除）"), drop marker attrs.
// Keep `data-fav-fix-tipbound` + bound listeners — they
// read __favFixReal live, so the next markPatched picks up
// the new payload automatically.
if (liveContainer) {
var prevReal = liveContainer.__favFixReal;
var patchedTitles = ['（视频已删除）'];
if (prevReal && prevReal.title) patchedTitles.push(prevReal.title);
var walker = document.createTreeWalker(liveContainer, NodeFilter.SHOW_TEXT, null);
var node;
while ((node = walker.nextNode())) {
var t = node.nodeValue.trim();
if (patchedTitles.indexOf(t) !== -1) {
node.nodeValue = node.nodeValue.replace(t, INVALID_TITLE);
}
}
patchedTitles.forEach(function (pt) {
liveContainer.querySelectorAll('[title="' + pt + '"]').forEach(function (el) {
el.setAttribute('title', INVALID_TITLE);
});
});
liveContainer.removeAttribute('data-fav-fix-marked');
liveContainer.removeAttribute('data-fav-fix-loading');
liveContainer.removeAttribute('data-fav-fix-partial');
liveContainer.__favFixReal = null;
}
// Paint spinner on the LIVE img immediately — user sees the
// click took effect before any network round-trip.
if (liveImg) markLoading({ img: liveImg, container: liveContainer });
// Fire patchOnce immediately rather than going through
// schedule()'s 400ms debounce — the user just told us they
// want action now. patchOnce dedups via `data-fav-fix-loading`
// so the spinner we just painted won't double-stack.
patchOnce().catch(function (e) { warn('clear-cache patchOnce threw:', e); });
}
});
return items;
}
function appendMenuItems(popper, items, opts) {
// opts: { itemClass, itemTag }
// Clear-then-append, NOT dedup-by-key. bilibili's new-UI dropdown reuses
// / pools popper nodes across cards (observed: the same popper, or a
// small pool, serves whichever card is hovered). The old dedup-by-key
// kept the FIRST card's items when a different card reused the popper —
// so a card could show a previous card's stale av bindings, or (once the
// item set became state-specific) a recovered card showing 立即重试 / a
// pending card showing 清缓存并重抓. Removing our prior items first
// guarantees the popper reflects ONLY the current card. The handler
// re-runs on every trigger mouseenter, so this stays fresh; it only ever
// touches our own [data-fav-fix-key] nodes, never bilibili's.
Array.from(popper.querySelectorAll('[data-fav-fix-key]')).forEach(function (el) { el.remove(); });
items.forEach(function (it) {
var el = document.createElement(opts.itemTag || 'div');
el.className = opts.itemClass + ' bili-fav-fix-menu-item';
el.setAttribute('data-fav-fix-key', it.key);
el.textContent = it.label;
el.style.cursor = 'pointer';
// Hard cap on item width — bilibili's popper is fixed-width and
// long labels otherwise wrap onto a 2nd line that bleeds past
// the popper edge. nowrap + ellipsis truncates cleanly inside
// the popper if someone ever adds a label past ~6 Chinese chars.
el.style.whiteSpace = 'nowrap';
el.style.overflow = 'hidden';
el.style.textOverflow = 'ellipsis';
el.addEventListener('click', function (e) {
e.stopPropagation();
try { it.onClick(); } catch (err) { warn('menu', it.key, 'threw', err); }
// Confirmation goes to the toast (bottom-center), NOT back
// into the menu cell. Previous in-place text replacement
// (label = successMsg for 1.5s) caused the menu to bleed
// out of bounds because the popper width is fixed and most
// successMsgs were 10+ chars. Toast has its own width logic
// (max-width + word-wrap) so it handles long strings.
if (it.successMsg) toast(it.successMsg, 'ok');
});
popper.appendChild(el);
});
}
function injectCardMenu(hit, real) {
if (!hit.container) return;
// New UI: trigger is .bili-card-dropdown inside the card; the
// popper is rendered LATE (appended to body, not the card) and
// gets class .visible only while it's open. Wait 500ms after
// mouseenter to give the popper time to render before we look.
var trigger = hit.container.querySelector('.bili-card-dropdown');
if (trigger && !trigger.__favFixBound) {
trigger.__favFixBound = true;
trigger.addEventListener('mouseenter', function () {
// Card mouseenter already fired our hover tooltip; close it
// so it doesn't overlap with the B 站 native dropdown popper.
// (mouseleave on the card never fires because the three-dot
// is INSIDE the card.)
hideTip();
setTimeout(function () {
var popper = document.querySelector('.bili-card-dropdown-popper.visible');
if (!popper) { log('new-UI popper not visible at inject time'); return; }
hideTip(); // belt-and-suspenders: kill tooltip again when popper appears
appendMenuItems(popper, buildMenuItems(hit, real), {
itemClass: 'bili-card-dropdown-popper__item',
itemTag: 'div'
});
}, 500);
});
return;
}
// Old UI: - rendered inline inside
// the card. We can append directly (no async wait). The trigger
// is .be-dropdown-trigger; bind tooltip-hide on it too.
var oldTrigger = hit.container.querySelector('.be-dropdown-trigger');
if (oldTrigger && !oldTrigger.__favFixBound) {
oldTrigger.__favFixBound = true;
oldTrigger.addEventListener('mouseenter', hideTip);
}
var oldMenu = hit.container.querySelector('.be-dropdown-menu');
if (oldMenu && !oldMenu.__favFixBound) {
oldMenu.__favFixBound = true;
appendMenuItems(oldMenu, buildMenuItems(hit, real), {
itemClass: 'be-dropdown-item',
itemTag: 'li'
});
}
}
// ─── Loading indicator ──────────────────────────────────────────────
// Painted the instant findInvalidContainers() returns a hit (BEFORE
// any API call). Visual = white semi-transparent overlay on the cover
// area with a centered gray rotating ring. The user picked this style
// over the previous orange-pulse-outline + corner-badge combo.
//
// Lifecycle:
// - markLoading(hit) on detect (patchOnce, before resolveItems)
// - clearLoading(hit) on resolve failure (patchOnce catch)
// - clearLoading(hit) on _no_source / no-img path (markPatched call)
// - clearLoading(hit) on img.onload / onerror (success-with-cover
// path) so the overlay outlives the cover-src swap and the user
// doesn't see the gray placeholder flicker to the real cover
// - clearLoading(hit) safety-net timer (4s) for edge cases where
// neither onload nor onerror fires (browser-cached src etc.)
//
// Idempotent via data-fav-fix-loading on img + container. Skips hits
// with no img (Strategy 2 / inline-SVG placeholders): they have no
// cover area to anchor an overlay to, so no visual feedback there —
// acceptable, those hits are rare.
var _loadingStylesInjected = false;
function ensureLoadingStyles() {
if (_loadingStylesInjected) return;
_loadingStylesInjected = true;
var st = document.createElement('style');
st.id = '__fav_fix_loading_styles';
st.textContent = [
// Spinner: only rotate is animated; centering is via flexbox on
// the overlay parent, so the transform doesn't fight the
// centering math (a common spinner bug).
'@keyframes __fav_fix_spin {',
' to { transform: rotate(360deg); }',
'}',
'.fav-fix-loading-overlay {',
' position: absolute; inset: 0;',
' background: rgba(255,255,255,.42);',
' z-index: 2147483645;',
' pointer-events: none;',
' display: flex; align-items: center; justify-content: center;',
// Inherit cover rounded corners so the overlay doesn't bleed
// past the card's curved edges. bilibili cover wraps use ~6px
// border-radius; `inherit` picks that up automatically.
' border-radius: inherit;',
'}',
'.fav-fix-loading-spinner {',
' width: 32px; height: 32px;',
// Ring effect: faint full circle + opaque top arc that rotates.
' border: 3px solid rgba(120,120,120,.22);',
' border-top-color: rgba(80,80,80,.85);',
' border-radius: 50%;',
' animation: __fav_fix_spin 0.9s linear infinite;',
'}'
].join('\n');
(document.head || document.documentElement).appendChild(st);
}
function markLoading(hit) {
// Skip if no img — Strategy 2 (title-text fallback) hits have no
// cover area to anchor an overlay to. Painting on the whole card
// container would obscure the title/footer too aggressively.
if (!hit || !hit.img) return;
if (hit.img.getAttribute('data-fav-fix-loading')) return; // dedup
if (hit.img.getAttribute('data-fav-fix-marked')) return; // already done
// Partial cards (markPartial below) already display a real title; a
// TTL-expiry re-resolve must not flash a spinner over content the
// user can read while only the cover is still being chased.
if (hit.img.getAttribute('data-fav-fix-partial')) return;
ensureLoadingStyles();
var coverWrap = hit.img.parentElement;
if (!coverWrap) return;
// Defensive: if bilibili's cover wrap happens to be position:static
// (shouldn't be — they have play-time badges etc. that need it),
// promote to relative so the overlay anchors correctly. Won't
// affect layout when already positioned.
var pos = (coverWrap.ownerDocument.defaultView || window)
.getComputedStyle(coverWrap).position;
if (pos === 'static') coverWrap.style.position = 'relative';
var overlay = document.createElement('div');
overlay.className = 'fav-fix-loading-overlay';
overlay.setAttribute('data-fav-fix-overlay', '1');
var spinner = document.createElement('div');
spinner.className = 'fav-fix-loading-spinner';
overlay.appendChild(spinner);
coverWrap.appendChild(overlay);
hit.img.setAttribute('data-fav-fix-loading', '1');
// Mark container too so stats().cardsLoading reflects card count
// (a card == one img). Container attr is the truth source for
// counting; img attr is what the dedup check reads.
if (hit.container) hit.container.setAttribute('data-fav-fix-loading', '1');
}
function clearLoading(hit) {
if (!hit) return;
if (hit.img) {
hit.img.removeAttribute('data-fav-fix-loading');
var coverWrap = hit.img.parentElement;
if (coverWrap) {
var overlay = coverWrap.querySelector('[data-fav-fix-overlay]');
if (overlay) overlay.remove();
}
}
if (hit.container) {
hit.container.removeAttribute('data-fav-fix-loading');
// Belt-and-braces: scan container for orphaned overlays in case
// some bilibili DOM reshuffle moved the img between markLoading
// and clearLoading (rare but observed on virtualized scrolls).
var stray = hit.container.querySelectorAll('[data-fav-fix-overlay]');
for (var i = 0; i < stray.length; i++) stray[i].remove();
}
}
// ─── Retry indicator (background android flap recovery) ──────────────
// A small corner badge on the cover so the user can SEE that a deleted
// item is being re-fetched in the background (runFlapRecovery), instead
// of the card looking inert — and, since 0.13.0, the switch that turns
// that retrying off. Three states, passed as a string:
// 'active' → spinning dot + "重试中" (loop alive — owns the retry,
// keeps sampling android on its backoff)
// 'waiting' → pulsing gray + "待重试" (loop gave up; a fresh reload
// re-kicks it, OR the card's "立即重试" menu item does so
// on demand via kickManualRetry)
// 'stopped' → static dark gray + "已停止重试" (the user pressed the
// badge; the av is on the 停止重试 list and no automatic
// path will request it again)
// Hovering swaps the label to the action the click performs (停止重试 /
// 恢复重试). That swap is PURE CSS — two spans, one hidden by :hover —
// because MutationObserver re-runs the patch pass constantly and a JS
// textContent swap would fight the hover state on every tick.
// The badge is just the at-a-glance cue; the FULL explanation of what the
// three states mean lives in the card's hover tooltip (buildTipHtml's
// _pending branch), bound for pending cards via bindCardAffordances.
// Removed by clearPending() the moment the item recovers (real cover) or
// is written terminal. Distinct from markLoading's full-cover overlay so
// it reads as "still trying" rather than "page loading". No emoji.
var _retryStylesInjected = false;
function ensureRetryStyles() {
if (_retryStylesInjected) return;
_retryStylesInjected = true;
var st = document.createElement('style');
st.id = '__fav_fix_retry_styles';
st.textContent = [
'@keyframes __fav_fix_retry_spin { to { transform: rotate(360deg); } }',
'@keyframes __fav_fix_retry_pulse { 0%,100%{opacity:.95} 50%{opacity:.5} }',
'.fav-fix-retry-badge {',
' position:absolute; left:6px; top:6px; z-index:2147483646;',
' display:flex; align-items:center; gap:5px;',
' padding:3px 7px; border-radius:10px;',
' font:600 11px/1 -apple-system,Segoe UI,sans-serif;',
' color:#fff; background:rgba(192,57,43,.82);',
// Status only, never a click target. The action lives in the
// centred button below, where the user can actually see it.
' pointer-events:none; user-select:none;',
'}',
'.fav-fix-retry-badge .fav-fix-retry-dot {',
' width:9px; height:9px; border-radius:50%;',
' border:2px solid rgba(255,255,255,.4); border-top-color:#fff;',
' animation:__fav_fix_retry_spin .8s linear infinite;',
'}',
'.fav-fix-retry-badge.waiting {',
' background:rgba(127,140,141,.8);',
' animation:__fav_fix_retry_pulse 1.8s ease-in-out infinite;',
'}',
'.fav-fix-retry-badge.waiting .fav-fix-retry-dot { animation:none; border-top-color:rgba(255,255,255,.55); }',
// Stopped: no animation anywhere and no spinner dot. The card must
// read as "nothing is happening here", which is the whole point.
'.fav-fix-retry-badge.stopped {',
' background:rgba(60,64,67,.88);',
' animation:none;',
'}',
'.fav-fix-retry-badge.stopped .fav-fix-retry-dot { display:none; }',
// THE action control: a real button, centred on the cover, visible
// at rest. An earlier revision made the corner badge itself
// clickable, and a status label reads as a status label no matter
// what it does on hover. The affordance has to be its own object,
// sitting where the eye already lands.
//
// Icon-only and circular: a labelled pill covers a third of the
// cover art. The wording survives as title + aria-label, so the
// meaning is one hover away and screen readers still get it.
'.fav-fix-retry-action {',
' position:absolute; left:50%; top:50%;',
' transform:translate(-50%,-50%); z-index:2147483646;',
' width:52px; height:52px; border-radius:50%;',
' display:flex; align-items:center; justify-content:center;',
' border:1px solid rgba(255,255,255,.18);',
' color:#fff; background:rgba(28,28,30,.86);',
' cursor:pointer; pointer-events:auto; user-select:none;',
' box-shadow:0 2px 10px rgba(0,0,0,.35);',
' transition:background .15s, box-shadow .15s, transform .12s;',
'}',
'.fav-fix-retry-action svg { width:36px; height:36px; display:block; fill:currentColor; }',
'.fav-fix-retry-action > * { pointer-events:none; }',
// Every transform here MUST re-state translate(-50%,-50%): the
// centring lives in the same property, so a bare scale() would
// snap the button to the cover's bottom-right quadrant on hover.
'.fav-fix-retry-action:hover {',
' background:rgba(192,57,43,.92); box-shadow:0 3px 14px rgba(0,0,0,.45);',
' transform:translate(-50%,-50%) scale(1.08);',
'}',
'.fav-fix-retry-action:active { transform:translate(-50%,-50%) scale(.94); }',
'.fav-fix-retry-action.resume:hover { background:rgba(52,120,190,.92); }'
].join('\n');
(document.head || document.documentElement).appendChild(st);
}
// Badge label per state. Status wording only; it is not clickable.
var RETRY_BADGE_TEXT = {
active: '重试中',
waiting: '待重试',
stopped: '已停止重试'
};
// Button wording per state. Names the ACTION, never the state. No longer
// rendered as visible text — it is the button's title and accessible name.
var RETRY_ACTION_TEXT = {
active: '停止重试',
waiting: '停止重试',
stopped: '恢复重试'
};
// Button glyph per state. A stop square and a refresh arrow, deliberately
// NOT a pause/play pair: a play triangle centred on a video cover reads as
// "play this video", which is exactly the wrong thing to suggest here.
var RETRY_ACTION_ICON = {
active: '',
waiting: '',
stopped: ''
};
// Write a state onto an existing badge. Early-returns when the state is
// unchanged so the observer's repeated patch passes don't churn text nodes.
function applyRetryBadgeState(badge, state) {
if (!RETRY_BADGE_TEXT[state]) state = 'waiting';
if (badge.getAttribute('data-fav-fix-retry-state') === state) return;
badge.setAttribute('data-fav-fix-retry-state', state);
badge.classList.toggle('waiting', state === 'waiting');
badge.classList.toggle('stopped', state === 'stopped');
var t = badge.querySelector('[data-fav-fix-retry-txt]');
if (t) t.textContent = RETRY_BADGE_TEXT[state];
}
// Same for the action button. data-fav-fix-retry-state on the BUTTON is the
// click handler's source of truth, so it is stamped here rather than read
// off the badge: the two nodes are updated in the same pass, but the
// handler must not depend on that ordering.
function applyRetryActionState(btn, state) {
if (!RETRY_ACTION_TEXT[state]) state = 'waiting';
btn.classList.toggle('resume', state === 'stopped');
if (btn.getAttribute('data-fav-fix-retry-state') === state) return;
btn.setAttribute('data-fav-fix-retry-state', state);
btn.innerHTML = RETRY_ACTION_ICON[state];
btn.title = RETRY_ACTION_TEXT[state];
btn.setAttribute('aria-label', RETRY_ACTION_TEXT[state]);
}
// The two user-facing transitions, defined once so the cover button, the
// card menu (11-menu.js) and the debug surface (17-boot.js) cannot drift.
function stopRetryForAv(av) {
setNoRetryUser(av);
toast('已停止重试，可再次点击恢复', 'ok');
// Repaint so any other card of the same av (and the control, when the
// caller did not update it in place) reflects the new state.
schedule();
}
function resumeRetryForAv(av) {
clearNoRetry(av);
// Drop the _pending stub as well: with the suppression gone the whole
// point is to ask the network again, and a live short-TTL stub would
// have patchOnce serve the cached "still nothing" instead.
dropItemCaches(av);
toast('已恢复重试，正在重新抓取', 'ok');
patchOnce().catch(function (e) { warn('resume-retry patchOnce threw:', e); });
}
// Bind the button's click ONCE per element. Idempotent via
// __favFixActionBound because markPending re-runs on every observer tick
// for the same node.
function bindRetryAction(btn) {
if (btn.__favFixActionBound) return;
btn.__favFixActionBound = true;
// The button sits inside the card, and the card is an .
// stopPropagation keeps the event away from the card's own handlers and
// from bilibili's document-level delegates, but it does NOT stop the
// anchor's default navigation, which needs preventDefault. Both are
// applied to mousedown as well as click: bilibili has document-level
// listeners that rewrite anchor behaviour (AGENTS.md gotcha 20, last
// bullet: an appended to the document had its blob: href hijacked
// and navigated the whole tab), and some of that machinery acts before
// a click event ever exists.
var swallow = function (e) { e.preventDefault(); e.stopPropagation(); };
btn.addEventListener('mousedown', swallow);
btn.addEventListener('click', function (e) {
swallow(e);
// Read av + state from the DOM at click time, never from a closure:
// this node is reused by later render passes (and by bilibili's
// virtualized scroll), so a captured value goes stale the moment the
// card's state, or the card itself, changes.
var av = btn.getAttribute('data-fav-fix-retry-av');
if (!av) return;
if (btn.getAttribute('data-fav-fix-retry-state') === 'stopped') {
// Flip out of 'stopped' HERE: nothing repaints this card until
// applyPatch runs after the whole resolve (phase 2 alone is
// budgeted at 10s), and a button still reading the resume label
// stays clickable throughout. A second click would re-enter
// resumeRetryForAv: another cache drop, another toast, and a
// _patchDirty second full resolve pass.
applyRetryActionState(btn, _flapBgRunning ? 'active' : 'waiting');
resumeRetryForAv(av);
} else {
// Flip in place rather than waiting for the next render pass:
// the flap loop may be mid-backoff and nothing else would touch
// this card for up to two minutes.
applyRetryActionState(btn, 'stopped');
stopRetryForAv(av);
}
});
}
function markPending(hit, state, av) {
if (!hit || !hit.img) return; // need a cover area to anchor to
var coverWrap = hit.img.parentElement;
if (!coverWrap) return;
ensureRetryStyles();
var pos = (coverWrap.ownerDocument.defaultView || window)
.getComputedStyle(coverWrap).position;
if (pos === 'static') coverWrap.style.position = 'relative';
var badge = coverWrap.querySelector('[data-fav-fix-retry]');
if (!badge) {
badge = document.createElement('div');
badge.setAttribute('data-fav-fix-retry', '1');
badge.className = 'fav-fix-retry-badge';
var dot = document.createElement('span');
dot.className = 'fav-fix-retry-dot';
var txt = document.createElement('span');
txt.setAttribute('data-fav-fix-retry-txt', '1');
badge.appendChild(dot);
badge.appendChild(txt);
coverWrap.appendChild(badge);
}
applyRetryBadgeState(badge, state);
// The control itself, centred on the cover. Created alongside the badge
// and torn down with it (clearPending removes both).
var btn = coverWrap.querySelector('[data-fav-fix-retry-action]');
if (!btn) {
btn = document.createElement('div');
btn.setAttribute('data-fav-fix-retry-action', '1');
btn.setAttribute('role', 'button');
btn.setAttribute('tabindex', '0');
btn.className = 'fav-fix-retry-action';
coverWrap.appendChild(btn);
}
// Re-stamped every pass: the same nodes can end up serving a different
// card after a virtualized re-render.
btn.setAttribute('data-fav-fix-retry-av', av == null ? '' : String(av));
applyRetryActionState(btn, state);
bindRetryAction(btn);
}
function clearPending(hit) {
if (!hit) return;
var scopes = [];
if (hit.img && hit.img.parentElement) scopes.push(hit.img.parentElement);
if (hit.container) scopes.push(hit.container);
for (var s = 0; s < scopes.length; s++) {
// Both nodes: the corner status badge and the centred action button.
var b = scopes[s].querySelectorAll('[data-fav-fix-retry], [data-fav-fix-retry-action]');
for (var i = 0; i < b.length; i++) b[i].remove();
}
}
// ─── Mark a patched item ────────────────────────────────────────────
// - solid red outline (4px) on the cover img — uses CSS outline so
// it doesn't reflow layout; outline-offset:-4px tucks it inside
// the rounded-corner clip so it doesn't bleed past corners
// - rich hover tooltip showing title / UP / stats / dates / intro
// - data-fav-fix-marked guard avoids double-binding on observer re-runs
// Bind the hover tooltip + inject our card-menu items onto a card, WITHOUT
// touching its cover / outline / title. markPatched calls this for recovered
// and terminal cards; applyPatch's pending branch calls it directly so a
// card still being chased by the flap loop ALSO gets the rich tooltip (now a
// 重试中/待重试 state explainer) and the "立即重试" menu item — previously
// pending cards skipped markPatched entirely and were left with only a bare
// badge. __favFixReal is read live by the tooltip handler, so a later
// markPatched (on recovery) upgrades the tooltip in place without re-binding.
function bindCardAffordances(hit, real) {
var bindEl = hit.container || hit.img;
if (!bindEl) return;
bindEl.__favFixReal = real;
if (!bindEl.getAttribute('data-fav-fix-tipbound')) {
bindEl.setAttribute('data-fav-fix-tipbound', '1');
bindEl.addEventListener('mouseenter', function (e) {
if (bindEl.__favFixReal) showTip(bindEl, bindEl.__favFixReal, e);
});
bindEl.addEventListener('mouseleave', hideTip);
}
// Inject per-card menu items (复制 AV/BV、复制完整信息、查看封面、
// 在 biliplus 打开、清缓存、以及 pending 卡的「立即重试」). Safe to call
// repeatedly; dedup via data-fav-fix-key on the menu items themselves.
try { injectCardMenu(hit, real); }
catch (e) { warn('injectCardMenu threw:', e); }
}
function markPatched(hit, real) {
// NOTE: clearLoading() is NOT called here. The caller (patchOnce
// application loop) decides when to clear:
// - _no_source / Strategy-2 paths: clear immediately, no img-load
// to wait on.
// - success-with-cover path: wait for img.onload before clearing
// so the overlay covers the placeholder-to-real-cover swap.
// Calling clearLoading here would defeat that "wait for onload"
// behavior — the overlay would vanish the instant patchCover
// assigns the new src, exposing the gray placeholder for the
// ~150ms CDN download window.
// Two visual styles:
// - recovered (any source returned data): solid red outline, the
// "we know what this used to be" cue.
// - unrecoverable (real._no_source): dashed gray outline, the
// "we tried every source and they all whiffed" cue. Lower
// visual weight so it doesn't shout when the situation is
// literally unfixable (true 404).
var isUnrecoverable = real && real._no_source;
var outlineCss = isUnrecoverable
? '3px dashed rgba(127,140,141,.85)'
: '4px solid rgba(192,57,43,.85)';
if (hit.img && !hit.img.getAttribute('data-fav-fix-marked')) {
hit.img.setAttribute('data-fav-fix-marked', isUnrecoverable ? 'nodata' : '1');
hit.img.style.outline = outlineCss;
hit.img.style.outlineOffset = '-4px';
}
// Also mark the container so `stats().cardsMarked` reflects EVERY
// patched card — not just ones whose placeholder was a real
'
+ '
';
}).join('');
var expanded = false; // default-collapsed; matches body.display:none above
header.addEventListener('click', function () {
expanded = !expanded;
body.style.display = expanded ? 'block' : 'none';
var toggle = header.querySelector('.__fav_fix_banner_toggle');
if (toggle) toggle.textContent = expanded ? '点击收起' : '点击展开';
});
banner.appendChild(header);
banner.appendChild(body);
// Pin to body so bilibili's SPA re-renders don't blow it away.
if (document.body) document.body.appendChild(banner);
}
function detectMissingAndRender(mediaId) {
// De-dupe up front. Observer ticks fire patchOnce repeatedly; we
// only need one render per (mediaId, session). Manual re-scan via
// menu deletes from this set first.
if (_missingBannerShown.has(mediaId)) return Promise.resolve();
// In-flight dedup. The old code set _missingBannerShown only AFTER
// two awaits, so boot()'s 1500ms trigger and patchOnce's end-of-run
// trigger routinely raced through the guard and BOTH fetched + both
// rendered (TOCTOU). Share one Promise per mediaId instead: a second
// concurrent call returns the same in-flight scan. On failure the
// entry is dropped (finally) WITHOUT marking shown, so a later tick
// can retry.
if (_missingInFlight.has(mediaId)) return _missingInFlight.get(mediaId);
var p = (async function () {
try {
// Parallel: ids endpoint + full phase-1 walk. ids is cheap
// (single GET, no auth); phase-1 walk is N pages so it
// dominates the wall time on first scan.
var all, phase1;
try {
var r = await Promise.all([
fetchAllAvList(mediaId),
fetchFullPhase1Avs(mediaId)
]);
all = r[0];
phase1 = r[1];
} catch (e) {
warn('detectMissing: parallel fetch failed:', e.message);
return;
}
if (!all.length) return;
var phase1Avs = phase1.avs;
if (phase1Avs.size === 0) {
// Either no enabled paginated source or every page failed.
// Without a phase-1 baseline we can't compute a meaningful
// gap (subtracting against empty = false-positive 100%
// missing, which is exactly the 0.8.0 bug). Skip silently.
log('detectMissing: phase-1 set empty, skip');
return;
}
if (!phase1.complete) {
// The walk did NOT reach a natural has_more=false end —
// it was cut short by the page-walk cap or a page
// error. The unwalked tail would be falsely reported as
// "silently dropped" (the >600-item false positive). Skip
// WITHOUT marking shown: the {avs,complete} result is
// cached, so repeat ticks return instantly and re-skip;
// a manual rescan (which clears the cache) can retry.
log('detectMissing: phase-1 walk incomplete (declared=' + all.length
+ ' walked=' + phase1Avs.size + ', cap=' + cfg('maxPageWalk')
+ ' pages) — skipping gap detection to avoid false positives');
return;
}
var missing = all.filter(function (x) {
return !phase1Avs.has(String(x.id));
});
log('missing detect: declared=' + all.length
+ ' phase1=' + phase1Avs.size + ' missing=' + missing.length);
_missingBannerShown.add(mediaId);
if (missing.length === 0) return;
// Guard against a folder switch mid-scan: if the user
// navigated to a different favlist while we were walking,
// detectMediaId() no longer matches and the new folder will
// run its own scan. Rendering here would paint the previous
// folder's gap over the current page.
if (detectMediaId() !== mediaId) {
log('detectMissing: folder changed mid-scan, skip render for', mediaId);
return;
}
renderMissingBanner(mediaId, all.length, missing);
} catch (e) {
warn('detectMissing failed:', e.message);
} finally {
_missingInFlight.delete(mediaId);
}
})();
_missingInFlight.set(mediaId, p);
return p;
}
// Apply a resolved item to one card. Returns one of four outcomes:
// 'patched' | 'partial' | 'pending' | 'unrecoverable'. 'partial' is the
// _cover_pending shape — real title painted, cover still chased by the
// background loop — kept a distinct value so the counting sites never
// re-derive the classification themselves (this function is the single
// DOM-mutation chokepoint and the one place that knows).
// Extracted so the fast path (sync cache-hit) and the slow path (async
// resolver result) share the same DOM-mutation logic — they only differ
// in *when* applyPatch fires and whether markLoading ran first.
function applyPatch(hit, real) {
if (real._no_source) {
// All sources whiffed. Replace title text with an explicit
// "(永久删除)" marker so findInvalidContainers' Strategy 2
// stops re-detecting this hit on every observer tick (the
// raw "已失效视频" string would otherwise keep matching),
// and grey out the placeholder image so it visually reads
// as "we tried, gone forever". Still mark + bind tooltip.
patchTitle(hit.container, '（视频已删除）');
if (hit.img) {
// Avoid replacing the src (the placeholder URL is at
// least valid and rendered); just desaturate + dim.
hit.img.style.filter = 'grayscale(1) opacity(.55)';
}
// No new cover src to wait for — clear loading overlay now.
// (No-op for fast-path cards that never had loading marked.)
clearLoading(hit);
clearPending(hit);
// Defensive: a partial→terminal transition must not leave a
// dangling amber outline under the gray one markPatched sets.
clearPartial(hit);
markPatched(hit, real);
return 'unrecoverable';
}
if (real._pending) {
// Still being chased by the background android flap loop
// (runFlapRecovery). Leave the card's cover/title untouched (native
// "已失效视频" placeholder) so it stays re-detectable and gets
// upgraded IN PLACE the moment a walk recovers it — but DO show a
// retry indicator so the user can see work is happening: a spinning
// "重试中" badge while the loop is alive (it owns the retry and will
// keep sampling on its backoff), a static "待重试" once the loop has
// given up (only a fresh reload, after the short cache TTL, re-kicks
// it), or a static "已停止重试" when the user switched this av off.
// Clear the first-pass loading overlay so the two don't stack.
clearLoading(hit);
// Defensive: a partial→pending transition (cover-pending merge
// degraded back to a bare stub) must not keep the amber outline —
// markPending only manages the badge, never the img outline.
clearPartial(hit);
// The stop list is queried LIVE (07a-noretry.js), never through a
// cache field: the user's press has to show on the very next render
// pass, and the decision must survive a cache purge that the merge
// record would not.
// Three-way, and the middle case is the one that bites: an av
// carrying an 'auto' record is NOT in the running loop's candidate
// set (resolveItems dropped it via isRetrySuppressed), so borrowing
// _flapBgRunning would paint 重试中 — spinner and all — on a card
// nothing is sampling, while the loop's own progress block counts
// "还剩 N 项" over a set that excludes it. Only a card the loop can
// actually be chasing may show 'active'.
var pav = real.oid != null ? String(real.oid) : null;
var pSuppressed = pav ? isRetrySuppressed(pav) : false;
markPending(hit, pav && isNoRetryUser(pav) ? 'stopped'
: ((_flapBgRunning && !pSuppressed) ? 'active' : 'waiting'), pav);
// Pending cards used to stop here with only a bare badge — no
// tooltip, none of our menu items. Give them the same hover tooltip
// (now a 重试中/待重试 state explainer) and card menu (now incl.
// "立即重试") as patched cards, minus the outline/title: those stay
// native ("已失效视频") so the card remains re-detectable and gets
// upgraded in place the moment a walk recovers it.
bindCardAffordances(hit, real);
return 'pending';
}
if (real._cover_pending) {
// Title recovered, cover still a placeholder (the background loop
// keeps chasing the image — see 08-resolver.js). Paint the title
// NOW (it is genuine data), but report the honest 'partial'
// outcome instead of full success, and mark via markPartial —
// amber dashed outline, NO data-fav-fix-marked — so the card
// stays re-detectable and the cover lands in place the moment the
// loop saves a merge that carries one (12-markers.js has the full
// repaint-gap rationale). Deliberately no patchCover (nothing to
// paint) and no badge (quiet background fill, not a retry owner).
clearPending(hit);
clearPartial(hit); // defensive; markPartial below re-stamps
clearLoading(hit);
if (real.title) patchTitle(hit.container, real.title);
markPartial(hit, real);
return 'partial';
}
// Recovered (or android-down degenerate): drop any retry badge first,
// and the amber partial residue — this is the partial→recovered
// upgrade path, and a recovered card keeping a stale
// data-fav-fix-partial would double-count in stats().cardsPartial
// (detection is safe either way: markPatched sets data-fav-fix-marked,
// which excludes the card from Strategy 1).
clearPending(hit);
clearPartial(hit);
if (real.cover && hit.img) {
// Defer clearLoading until the new cover actually paints.
// Without this the overlay vanishes the moment we swap
// src — but the new image takes ~100-300ms to download
// from hdslb CDN, so the user sees the gray placeholder
// flash before the real cover appears. With the deferred
// clear, the spinner covers that gap and the swap looks
// instant. Fast-path cards never had a spinner so the
// clearLoading inside finish() is just a no-op for them.
(function (img, h) {
var done = false;
var finish = function () {
if (done) return; done = true;
img.removeEventListener('load', finish);
img.removeEventListener('error', finish);
clearLoading(h);
};
img.addEventListener('load', finish);
img.addEventListener('error', finish);
// Safety net: if neither event fires (browser cached
// the new src because the same hdslb URL was loaded
// earlier this session, or some other edge), the
// spinner would hang forever. The default is generous
// for hdslb but short enough to not feel broken.
setTimeout(finish, cfg('coverLoadTimeoutMs'));
// Third arg = av: lets patchCover fall back to the local
// backup's cover Blob if this URL 404s (09-dom.js).
patchCover(img, real.cover, real.oid != null ? String(real.oid) : null);
})(hit.img, hit);
} else {
// Either no real.cover (rare — source returned title
// only) or no hit.img (Strategy 2). No img-load event
// to await; clear loading immediately. (For Strategy 2
// markLoading skipped it anyway, so this is mostly the
// title-only branch.)
clearLoading(hit);
}
if (real.title) patchTitle(hit.container, real.title);
markPatched(hit, real);
return 'patched';
}
// ─── Credential-less restore ────────────────────────────────────────
// Avs this pass already looked up locally and found nothing for. Without it
// every observer tick would re-open an IndexedDB transaction per unpatched
// card. Folder-scoped: dropAllInMemory() clears it (13-missing.js), and so
// does a backup run, which is the one thing that can turn a miss into a hit
// without a page load.
var _localOnlyMiss = new Set();
// …and the HIT twin: av → the backup-served merge applyPatch accepted.
// Needed because this path never saveCache()s (red line) while partial
// cards deliberately stay re-detectable (markPartial omits
// data-fav-fix-marked) — so a logged-out folder full of title-only backup
// records would otherwise re-open an IDB transaction per card on EVERY
// observer tick, the exact thrash _localOnlyMiss exists to prevent, just
// through the hit door. Cleared wherever _localOnlyMiss is cleared (folder
// switch, backup run, import, promotion write). Login makes it moot:
// patchOnceInner then takes the resolver path, never this one.
var _localOnlyHits = new Map();
// Runs INSTEAD of the resolver when there is no access_key. It must not
// touch the network (android owns every invalid-item snapshot and is
// appkey+token signed, so the rescue chain genuinely cannot run) and must
// not write the GM cache — a later logged-in resolve has to stay free to
// ask android and the third-party archives about whatever the local layers
// could not answer. Two credential-free sources are available: a merge
// persisted by an earlier session, and the IndexedDB backup, which was
// captured while the videos were still alive and needs no login at all.
// Before this path existed, a fully backed-up folder restored NOTHING once
// the user logged out.
async function restoreLocalOnly(hits) {
var todo = [];
var patched = 0;
var partial = 0;
hits.forEach(function (hit) {
var av = getAvFromHit(hit);
if (!av || _localOnlyMiss.has(av)) return;
var c = loadCache(av) || _localOnlyHits.get(av);
if (c) {
try {
var r = applyPatch(hit, c);
if (r === 'patched') patched++;
else if (r === 'partial') partial++;
} catch (e) { warn('local-only fast-path applyPatch threw for av', av, e); }
} else {
todo.push({ hit: hit, av: av });
}
});
if (todo.length && SOURCES.backup && SOURCES.backup.enabled()) {
var avs = todo.map(function (t) { return t.av; });
var recs = null;
try { recs = await SOURCES.backup.fetchAvs(avs); }
catch (e) { warn('local-only backup lookup failed:', e && e.message); }
if (recs) {
todo.forEach(function (t) {
var item = recs.get(t.av);
if (!item) { _localOnlyMiss.add(t.av); return; }
// Run it through the normal merge so the card, the tooltip
// and the clipboard text see exactly the shape they see on
// the logged-in path (_src_* provenance included).
var real = mergeBySource({ backup: item });
if (real._degenerate) { _localOnlyMiss.add(t.av); return; }
real._attempted = ['backup'];
// A title-only backup record (no cover bytes — 15a's
// supply-side gate withheld the url) must render as an
// honest 'partial', not full success. The resolver's
// classifier never runs on this path (it is androidUp-
// gated), so stamp the merge here. IN MEMORY ONLY: this
// path never saveCache()s — a later logged-in resolve
// must stay free to chase the cover for real.
if (real._src_title && !real._src_cover) real._cover_pending = true;
try {
var r = applyPatch(t.hit, real);
if (r === 'patched') patched++;
else if (r === 'partial') partial++;
// Memoise the accepted merge so the next tick serves
// it from memory instead of re-opening an IDB
// transaction (see _localOnlyHits above).
if (r === 'patched' || r === 'partial') _localOnlyHits.set(t.av, real);
} catch (e) { warn('local-only applyPatch threw for av', t.av, e); }
});
}
} else {
todo.forEach(function (t) { _localOnlyMiss.add(t.av); });
}
log('no access_key —', patched, 'restored +', partial,
'partial (cover pending) of', hits.length,
'invalid card(s) from local data (GM cache + backup);',
'the rest need a login');
}
// Re-entrancy guard. patchOnceInner is async and a phase-1 walk can take
// seconds; schedule()'s 400ms debounce clears pendingTick the instant the
// timer fires, so a later observer tick (or the clear-cache menu, which
// calls patchOnce directly) could start a SECOND run while the first is
// still awaiting. Concurrent runs share pageCache/pageItems and could
// clobber each other mid-walk. Serialize here: if a run is in flight, mark
// dirty and let the current run loop once more when it finishes (so the
// trigger that arrived mid-run — e.g. a clear-cache that just nuked the
// cache, or the background flap recovery calling schedule() after it
// upgrades a recovered item — is never dropped). The background flap loop
// (runFlapRecovery) itself is NOT serialized by this guard: it runs
// outside patchOnce and only writes pageItems (never pageCache), so it
// can't corrupt a concurrent foreground walk.
var _patchInFlight = false;
var _patchDirty = false;
async function patchOnce() {
if (_patchInFlight) { _patchDirty = true; return; }
_patchInFlight = true;
try {
do {
_patchDirty = false;
await patchOnceInner();
} while (_patchDirty);
} finally {
_patchInFlight = false;
}
}
async function patchOnceInner() {
if (!isFavPage()) return;
var mediaId = detectMediaId();
if (!mediaId) { log('cannot detect mediaId from URL'); return; }
var hits = findInvalidContainers();
if (hits.length === 0) return;
var auth = getAuth();
if (!auth.access_key) {
// No credential → the NETWORK rescue chain is unavailable, but the
// local layers are not: restore what the GM cache and the local
// backup can serve instead of leaving a fully backed-up folder
// untouched. Nothing below this point is reachable without a login.
await restoreLocalOnly(hits);
return;
}
log('detected', hits.length, 'invalid items, mediaId=', mediaId);
// ─── Cache-hit fast path ──────────────────────────────────────
// Synchronously split hits BEFORE any markLoading: cards whose
// av already has a valid GM-storage entry get patched IMMEDIATELY
// with zero spinner. Only cache-miss cards go through the async
// resolver, and only those cards show the loading pulse. Before
// this split everything got markLoading'd up front and then the
// whole batch awaited resolveItems — a single cache-miss card
// (e.g. the one the user just cleared) would drag every other
// card's spinner along for the entire phase-1 fetch.
var cachedPairs = []; // [{hit, av, real}, ...] → patch now
var todoHits = []; // unresolved → async resolver
hits.forEach(function (hit) {
var av = getAvFromHit(hit);
if (!av) { todoHits.push(hit); return; } // BV-unconvertible → let finally cleanup catch it
var c = loadCache(av);
if (c) cachedPairs.push({ hit: hit, av: av, real: c });
else todoHits.push(hit);
});
var patched = 0;
var partial = 0;
var unrecoverable = 0;
// Patch cached cards first — no spinner, no await.
cachedPairs.forEach(function (p) {
try {
var r = applyPatch(p.hit, p.real);
if (r === 'patched') patched++;
else if (r === 'partial') partial++;
else if (r === 'unrecoverable') unrecoverable++;
// Folder accretion (15e): a cache-hit av never reaches the
// resolver's promotion hooks, so without this its backup
// record would keep only the folder it was first promoted in
// for the whole cache TTL (panel filter / export grouping
// would omit it elsewhere). Memoised + no-op'd internally.
if (r === 'patched' || r === 'partial') maybeAccrueFolder(p.av, mediaId);
} catch (e) {
warn('fast-path applyPatch threw for av', p.av, e);
}
});
if (todoHits.length === 0) {
log('all', hits.length, 'cards satisfied by GM cache (fast path)');
detectMissingAndRender(mediaId);
return;
}
// ─── Cache-miss slow path ────────────────────────────────────
// Paint loading indicator only on cards that actually need a
// network round-trip. Cache hits already got their cover above
// and must not spin.
todoHits.forEach(markLoading);
var todoAvs = todoHits.map(getAvFromHit).filter(Boolean);
var merged;
try { merged = await resolveItems(todoAvs, mediaId); }
catch (e) {
warn('resolve failed:', e);
toast('数据解析失败：' + e.message, 'err');
// Resolve threw — never going to call applyPatch, so the
// loading pulse would otherwise stick forever. Clear it.
todoHits.forEach(clearLoading);
return;
}
try {
todoHits.forEach(function (hit) {
var av = getAvFromHit(hit);
if (!av) return;
var real = merged.get(av);
if (!real) { log('av', av, 'no data from any source'); return; }
var r = applyPatch(hit, real);
if (r === 'patched') patched++;
else if (r === 'partial') partial++;
else if (r === 'unrecoverable') unrecoverable++;
});
} finally {
// Catch loading-state leaks. applyPatch() clears loading on
// the success/nodata paths; this finally catches the rest:
// - BV un-convertible (getAvFromHit returned null)
// - merged.get(av) was null (no data from any source)
// - an exception was thrown mid-loop (patchTitle / patchCover
// on weird DOM); without finally, schedule()'s outer .catch
// would swallow the throw and leave the badge pulsing forever.
// Only walks todoHits because cachedPairs never had loading.
todoHits.forEach(function (hit) {
if ((hit.container && hit.container.getAttribute('data-fav-fix-loading'))
|| (hit.img && hit.img.getAttribute('data-fav-fix-loading'))) {
clearLoading(hit);
}
});
}
if (patched > 0 || partial > 0 || unrecoverable > 0) {
log('patched', patched, '/ partial', partial,
'/ unrecoverable', unrecoverable,
'/ total', hits.length,
'(fast-path', cachedPairs.length, '+ slow-path', todoHits.length + ')');
}
// After main patching settles, async-check for "ghost" items —
// avs that bilibili declared in the collection's full ids list but
// never returned in any page response (silently dropped). Doesn't
// block patchOnce; renders a sticky banner if a gap is found. Per-
// mediaId dedup inside detectMissingAndRender prevents repeat
// renders on observer re-ticks.
detectMissingAndRender(mediaId);
}
// ─── Lifecycle ──────────────────────────────────────────────────────
var lastUrl = location.href;
var pendingTick = null;
function schedule() {
if (pendingTick) return;
pendingTick = setTimeout(function () {
pendingTick = null;
patchOnce().catch(function (e) { warn('patchOnce threw:', e); });
}, cfg('patchDebounceMs'));
}
function startObserver() {
var mo = new MutationObserver(function () {
if (location.href !== lastUrl) {
lastUrl = location.href;
// New folder → flush every in-memory cache (page promises,
// raw rows, ids list, phase-1 avs, banner-shown, in-flight
// scans). Per-avid GM storage cache is intentionally NOT
// cleared (re-hits reuse stored data; clear from menu if
// needed). The render-time detectMediaId() guard already stops
// a stale in-flight scan from painting the new folder.
dropAllInMemory();
var oldBanner = document.getElementById('__fav_fix_missing_banner');
if (oldBanner) oldBanner.remove();
// Boot-style detection trigger for the new folder. Delay
// matches the boot() path so bilibili's SPA has settled.
setTimeout(function () {
var mid = detectMediaId();
if (mid) detectMissingAndRender(mid);
}, cfg('spaSwitchDelayMs'));
}
schedule();
});
mo.observe(document.body, { childList: true, subtree: true });
}
// ─── Toast ──────────────────────────────────────────────────────────
function toast(msg, kind) {
var color = kind === 'err' ? '#c0392b' : kind === 'warn' ? '#e67e22' : kind === 'ok' ? '#27ae60' : '#34495e';
var el = document.createElement('div');
el.textContent = 'fav-fix: ' + msg;
el.style.cssText = [
// Bottom-center: anchor at left:50% and use translateX(-50%)
// for self-centering regardless of width. bottom:32px keeps
// it above bilibili's own footer / floating buttons but still
// visually clearly "in the bottom band".
'position:fixed', 'left:50%', 'bottom:32px',
'transform:translateX(-50%)',
'z-index:2147483647',
'padding:8px 14px', 'border-radius:8px',
'font:600 13px/1.3 -apple-system,Segoe UI,sans-serif',
'color:#fff', 'background:' + color,
'box-shadow:0 4px 12px rgba(0,0,0,.25)', 'pointer-events:none',
// max-width + word-wrap: caps the toast width at 360px so a
// long error string ("授权响应异常：错误码 -3, bilibili 长描述…")
// doesn't stretch the box past the viewport edge. Wraps onto
// multiple lines instead. break-word handles long unspaced
// CJK / URLs. text-align:center reads better for centered toast.
'max-width:360px', 'white-space:normal', 'text-align:center',
'overflow-wrap:break-word', 'word-break:break-word'
].join(';');
if (document.body) document.body.appendChild(el);
else document.addEventListener('DOMContentLoaded', function () { document.body.appendChild(el); }, { once: true });
setTimeout(function () { try { el.remove(); } catch (e) {} }, 4500);
}
// ─── Manual backup to IndexedDB (pre-emptive snapshot) ──────────────
//
// Everything else in this script is AFTER-THE-FACT rescue: an item is
// already invalid and we go begging android / public / biliplus /
// jijidown for whatever snapshot they kept. This module is the opposite —
// the user triggers it while the videos are still ALIVE and we copy the
// whole folder (metadata AND the cover image BYTES) into IndexedDB. When
// an item later dies, SOURCES.backup answers from local disk: no network,
// no third party, no flap.
//
// Why IndexedDB and not GM storage: GM_setValue serializes to JSON, which
// cannot hold a Blob. Cover bytes are the whole point (a metadata-only
// backup still dies when bilibili's CDN purges the image), so the store
// has to be one that persists structured-cloneable values.
//
// Cross-file invariants (see AGENTS.md):
// - The backup DB is NEVER touched by any cache-clearing path
// (clearAllItemCache / dropItemCaches / the "清除所有缓存" menu). Those
// clear DERIVED data that can be re-fetched; a backup cannot.
// - IndexedDB is origin-scoped. space.bilibili.com and www.bilibili.com
// therefore keep SEPARATE backup databases; a folder backed up on one
// origin does not restore on the other. Documented, not worked around.
// - Adding SOURCES.backup changes merge semantics, so CACHE_VERSION was
// bumped (07-cache.js) — otherwise entries cached before this feature
// would never consult the backup.
// - Writing an item is an UPSERT WITH CARRY-FORWARD, never a blind
// full-record replace. idbPut() replaces the whole record, so every
// field a re-run cannot re-derive (above all the cover Blob) must be
// read from the stored record and copied into the new one first. A
// backup is the user's only copy; a re-run that finds less than the
// last one must degrade to "kept what we had", never to data loss.
var BACKUP_DB_NAME = 'bili-fav-fix-backup';
var BACKUP_DB_VERSION = 1;
var BACKUP_STORE_ITEMS = 'items';
var BACKUP_STORE_META = 'meta';
// Walk limits. 500 pages x ps=20 = 10000 items: far above the rescue-walk
// cap (cfg('maxPageWalk'), where a long walk delays a DOM patch)
// because a backup is an explicit, user-initiated, one-off operation and
// truncating it silently loses data the user asked us to keep.
// → cfg('backupMaxPages'), default 500.
// → cfg('backupPageDelayMs'), default 300 — politeness gap between pages.
// → cfg('backupBlobConcurrency'), default 3 — parallel cover downloads.
// → cfg('backupProgressEvery'), default 3 — toast every N pages (page 1
// always).
// ─── IndexedDB plumbing ─────────────────────────────────────────────
// Lazy single open, promise-wrapped. No third-party wrapper library: the
// four operations below are all this feature needs, and the core ships as
// one inlined IIFE where every extra KB is downloaded on each page load.
var _backupDbPromise = null;
function backupDb() {
if (_backupDbPromise) return _backupDbPromise;
_backupDbPromise = new Promise(function (resolve, reject) {
if (typeof indexedDB === 'undefined') {
reject(new Error('IndexedDB unavailable in this context'));
return;
}
var req = indexedDB.open(BACKUP_DB_NAME, BACKUP_DB_VERSION);
req.onupgradeneeded = function () {
var db = req.result;
if (!db.objectStoreNames.contains(BACKUP_STORE_ITEMS)) {
// keyPath 'av' is a STRING everywhere (String(oid)), matching
// the GM cache key type so the two layers can be compared
// without coercion surprises.
var items = db.createObjectStore(BACKUP_STORE_ITEMS, { keyPath: 'av' });
items.createIndex('bvid', 'bvid', { unique: false });
}
if (!db.objectStoreNames.contains(BACKUP_STORE_META)) {
db.createObjectStore(BACKUP_STORE_META, { keyPath: 'media_id' });
}
};
req.onsuccess = function () { resolve(req.result); };
req.onerror = function () { reject(req.error || new Error('indexedDB.open failed')); };
req.onblocked = function () { reject(new Error('indexedDB.open blocked by another tab')); };
});
// Never cache a REJECTED open: a transient failure (private-mode quota,
// a blocked upgrade from another tab) would otherwise disable the
// backup for the rest of the page's life.
_backupDbPromise.catch(function () { _backupDbPromise = null; });
return _backupDbPromise;
}
function idbReq(req) {
return new Promise(function (resolve, reject) {
req.onsuccess = function () { resolve(req.result); };
req.onerror = function () { reject(req.error || new Error('IndexedDB request failed')); };
});
}
function idbGet(store, key) {
return backupDb().then(function (db) {
return idbReq(db.transaction(store, 'readonly').objectStore(store).get(key));
});
}
function idbPut(store, value) {
return backupDb().then(function (db) {
return idbReq(db.transaction(store, 'readwrite').objectStore(store).put(value));
});
}
// Deletion lives in the storage layer next to get/put, but it is NEVER
// called by any cache-clearing path (see the invariants at the top of this
// file). Its only caller is the backup manager panel (15b), where the user
// explicitly asks for a record to go away — and that caller must also drop
// the two derived layers keyed off the same av, or the deleted snapshot
// keeps restoring cards. See AGENTS.md gotcha 20.
function idbDelete(store, key) {
return backupDb().then(function (db) {
return idbReq(db.transaction(store, 'readwrite').objectStore(store).delete(key));
});
}
function idbCount(store) {
return backupDb().then(function (db) {
return idbReq(db.transaction(store, 'readonly').objectStore(store).count());
});
}
// Cursor walk — the only way to aggregate over the store without loading
// every Blob-bearing record into memory at once.
function idbCursorEach(store, fn) {
return backupDb().then(function (db) {
return new Promise(function (resolve, reject) {
var req = db.transaction(store, 'readonly').objectStore(store).openCursor();
req.onsuccess = function () {
var cur = req.result;
if (!cur) { resolve(); return; }
try { fn(cur.value); } catch (e) { reject(e); return; }
cur.continue();
};
req.onerror = function () { reject(req.error || new Error('cursor failed')); };
});
});
}
// ─── Helpers ────────────────────────────────────────────────────────
function backupSleep(ms) {
return new Promise(function (r) { setTimeout(r, ms); });
}
// bilibili cover URLs carry an "@'
+ '
'
+ ''
+ ''
+ 'av' + av + (bv ? ' · ' + bv : '')
+ ''
+ '暂无备份数据
' + '可在 Tampermonkey 菜单中选择「fav-fix：备份当前收藏夹」开始备份
';
} else if (!total) {
body.innerHTML = '' + '可在 Tampermonkey 菜单中选择「fav-fix：备份当前收藏夹」开始备份
没有符合条件的备份条目
';
}
var pending = [];
for (var i = 0; i < slice.length; i++) {
var r = slice[i];
var row = document.createElement('div');
row.className = 'fav-fix-mgr-row';
// Four provenance tags, one CSS class: 'merged' (walker fallback
// from the rescue cache), 'restored' (auto-promoted full
// recovery, 15e), 'restored_meta' (auto-promoted title-only —
// coverless on purpose, its image is still being chased).
// 'live' / absent = captured while the video was alive.
var isAutoRec = r.data_source === 'merged'
|| r.data_source === 'restored'
|| r.data_source === 'restored_meta';
var tagCls = isAutoRec ? ' fav-fix-mgr-tag-merged' : '';
var tagTxt = r.data_source === 'merged' ? '取自还原缓存'
: r.data_source === 'restored' ? '自动还原'
: r.data_source === 'restored_meta' ? '自动还原·无封面'
: '备份时有效';
// The visible date follows the active sort key, labeled so a list
// sorted by 收藏时间 does not show seemingly shuffled backup dates.
var dateStr = s.sort.indexOf('backed') === 0
? '备份于 ' + mgrDate(r.backed_at)
: '收藏于 ' + (r.fav_time ? mgrDate(r.fav_time * 1000) : '未知');
var sub = [
r.upperName || '未知 UP 主',
dateStr,
r.cover_size ? fmtBytes(r.cover_size) : '无封面',
r.bvid || ('av' + r.av)
].join(' · ');
// Membership tag. The wording carries its own scope so the reader
// never has to remember what the badge is relative to: with one
// folder selected it says 此收藏夹, under 全部 it says 任何收藏夹.
// 未检查 is a real third state, not a blank — an absent tag would
// be indistinguishable from "checked and still there".
var mem = membershipStatus(r.av, r.media_ids, s.folder, s.membership);
var scoped = s.folder !== '*';
var memTxt = mem === 'out' ? (scoped ? '不在此收藏夹' : '不在任何收藏夹')
: mem === 'in' ? (scoped ? '在此收藏夹' : '在收藏夹')
: '未检查';
// Second occurrence of this URL shape (13-missing.js:266 is the
// first); rule of three says do not extract a helper yet. bvid is
// preferred because the av path only redirects, and esc() guards
// the href for the same defense-in-depth reason as there.
var vidUrl = 'https://www.bilibili.com/video/'
+ (r.bvid ? esc(r.bvid) : 'av' + esc(String(r.av)));
// An empty title would render an anchor with no text — a dead
// click target in the one place the row promises a link. Records
// whose title never resolved get a visible stand-in instead.
var nameTxt = esc(r.title || '（无标题）');
row.innerHTML =
''
+ (r.hasCover
? '无封面
')
+ ''
+ ''
+ '' + nameTxt + ''
+ '
'
+ '';
body.appendChild(row);
var img = row.querySelector('.fav-fix-mgr-thumb');
if (img) pending.push({ av: r.av, img: img });
/* jshint loopfunc:true */
(function (rec) {
row.querySelector('.fav-fix-mgr-del')
.addEventListener('click', function () { mgrDeleteOne(rec); });
})(r);
}
if (pending.length) mgrLoadThumbs(pending);
s.els.pageInfo.textContent = '第 ' + (total ? s.page : 0) + ' / ' + (total ? pages : 0)
+ ' 页 · 共 ' + total + ' 项' + mgrFolderMetaText();
s.els.prev.disabled = s.busy || s.page <= 1;
s.els.next.disabled = s.busy || s.page >= pages;
// The four long operations mutually exclude each other (mgrLocked);
// browsing stays free during all of them.
var locked = mgrLocked();
s.els.bulk.disabled = locked || !total;
s.els.bulk.textContent = '删除当前筛选结果（' + total + ' 项）';
// The export and import buttons live in the footer, so a re-render
// never rebuilds them — but their disabled state is derived from the
// same counters as the rows and has to be recomputed here all the
// same. Their LABELS are left alone: they carry no count (unlike the
// bulk delete), and during a run each holds the progress text its own
// handler owns.
s.els.exportBtn.disabled = locked || !total;
// No `!total` term for import: an empty store is exactly the state an
// import exists to fix, so this is the one footer action that must
// stay reachable when the list has nothing in it.
s.els.importBtn.disabled = locked;
// Gated on the INDEX, not the filtered total: an empty filter result
// is often precisely what a scan would explain (everything currently
// reads 未检查), while an empty store has no folder to check at all.
s.els.check.disabled = locked || !s.index.length;
// The backup button was the one control the matrix disabled in its own
// click handler but never repainted from mgrLocked, so during any OTHER
// long operation it kept offering itself and its guard silently
// swallowed the click. Its label is left alone: while a walk owns it,
// that label is the progress text its handler is driving.
s.els.backup.disabled = locked;
if (locked) {
var dels = s.els.body.querySelectorAll('.fav-fix-mgr-del');
for (var d = 0; d < dels.length; d++) dels[d].disabled = true;
}
}
// Re-entrancy guard for both delete paths: an in-flight delete must not be
// raced by a second click, a page flip or a filter change mid-batch.
function mgrSetBusy(on) {
var s = _mgrState;
// Defence in depth: every caller already checks the panel is still the
// one it started with, but a release arriving after close must never
// throw out of a promise callback.
if (!s) return;
s.busy = on;
// Recompute rather than blanket-enable on release: a delete that ends
// without a re-render (the failure path) must not leave 下一页 clickable
// on the last page.
var pages = Math.max(1, Math.ceil(s.filtered.length / cfg('mgrPageSize')));
// s.busy is already assigned above, so mgrLocked() sees this release.
// Same computation as in mgrRenderList: a delete that ends without a
// re-render must not hand the footer buttons back while another long
// operation still owns the panel.
var locked = mgrLocked();
s.els.prev.disabled = on || s.page <= 1;
s.els.next.disabled = on || s.page >= pages;
s.els.bulk.disabled = locked || !s.filtered.length;
s.els.exportBtn.disabled = locked || !s.filtered.length;
s.els.importBtn.disabled = locked;
s.els.check.disabled = locked || !s.index.length;
s.els.backup.disabled = locked;
var dels = s.els.body.querySelectorAll('.fav-fix-mgr-del');
for (var i = 0; i < dels.length; i++) dels[i].disabled = locked;
}
// Called by exportBackupRows (15c-backup-export.js) once a run releases
// _exportRunning. Only the panel that STARTED an export repaints itself
// when it ends; a panel opened after that one was closed mid-run derives
// its locked controls from the module flag and would otherwise stay locked
// until some unrelated interaction happened to re-render it.
function mgrExportReleased() {
var s = _mgrState;
if (!s || s.exportBusy) return; // no panel, or the owner repaints itself
mgrRenderList();
}
// The import counterpart, called by importBackupFile (15d-backup-import.js)
// once a run releases _importRunning, for exactly the same reason: a panel
// that did not start the run has importBusy false and derives its locked
// controls from the module flag alone.
function mgrImportReleased() {
var s = _mgrState;
if (!s || s.importBusy) return; // no panel, or the owner repaints itself
mgrRenderList();
}
// The membership counterpart, called by scanMembership (15f-membership.js)
// once a run releases _membershipRunning. Same reason as the two above —
// and one more: this panel did not start the scan, so its in-memory
// snapshots predate the run and every row's tag would keep showing the
// old verdict until some unrelated interaction happened to re-render.
function mgrMembershipReleased() {
var s = _mgrState;
if (!s || s.membershipBusy) return; // no panel, or the owner repaints itself
mgrReloadMembership();
if (s.status !== '*') mgrApplyFilter();
mgrRenderList();
}
// The search box stays editable during a delete on purpose: disabling an
// input mid IME composition (Chinese input is the expected case) drops the
// composition and steals focus. The debounced handler therefore discards
// whatever was typed while busy, and no further input event is guaranteed
// to arrive — so the box is re-read once the batch releases, otherwise the
// panel keeps showing typed text over a list filtered by the old query.
// Returns true when the query moved, so callers can restart at page 1.
function mgrResyncSearch() {
var s = _mgrState;
if (!s || s.els.search.value === s.query) return false;
s.query = s.els.search.value;
return true;
}
// Settles the panel after a delete attempt. Also runs on the failure path,
// where `removed` is empty but the search box may still have moved.
function mgrAfterDelete(removed) {
var s = _mgrState;
if (!s) return;
var requery = mgrResyncSearch();
if (!removed.size && !requery) return;
s.index = s.index.filter(function (r) { return !removed.has(r.av); });
var page = s.page;
var folder = s.folder;
// Every surface derived from the index goes stale on a delete, the
// folder dropdown included: its option labels carry per-folder counts,
// and the rebuild is also what drops a folder that just lost its last
// item (resetting s.folder to '*' when that folder was selected).
mgrRenderFolders();
mgrApplyFilter();
// Keep the reader where they were — unless the filter itself changed,
// in which case the old page number means nothing and page 1 (set by
// mgrApplyFilter) is the honest landing spot.
if (!requery && s.folder === folder) s.page = page;
mgrRenderHead();
mgrRenderList();
}
// Full refresh after an in-panel backup: the index, the folder-name map
// and every surface derived from them are stale. Search text typed during
// the run is honoured (mgrResyncSearch), the folder selection survives
// unless its folder vanished (mgrRenderFolders resets it), and deletes are
// blocked for the whole backup, so this can never repaint rows out from
// under an in-flight delete batch.
function mgrRefreshIndex() {
var s = _mgrState;
if (!s) return Promise.resolve();
return Promise.all([buildBackupIndex(), mgrBuildFolderNames()]).then(function (res) {
if (_mgrState !== s) return;
s.index = res[0];
s.names = res[1].names;
s.metas = res[1].metas;
// A walk can introduce a folder the index did not mention before;
// if a snapshot for it is already on disk, load it now rather than
// showing 未检查 over data we hold.
mgrReloadMembership();
mgrLoadQuota();
mgrResyncSearch();
mgrRenderHead();
mgrRenderFolders();
mgrApplyFilter();
mgrRenderList();
}).catch(function (e) {
warn('mgr: refresh failed', e && e.message);
});
}
function mgrDeleteOne(rec) {
var s = _mgrState;
if (mgrLocked()) return;
if (!confirm('确定删除该条目的备份？\n\n' + rec.title + '\n\n删除后无法恢复。')) return;
mgrSetBusy(true);
deleteBackupAv(rec.av).then(function () {
// The record left IDB whether or not the panel survived the await,
// so the page-keyed promise cache — which would otherwise replay
// pre-delete rows for the rest of this page's life — is dropped
// unconditionally; only the UI work below belongs to a live panel.
pageCache.clear();
if (_mgrState !== s) return; // panel closed mid-delete
mgrSetBusy(false);
mgrAfterDelete(new Set([rec.av]));
toast('已删除 1 项备份', 'ok');
}).catch(function (e) {
if (_mgrState !== s) { // panel closed mid-delete
warn('mgr: delete failed after close', e && e.message);
return;
}
mgrSetBusy(false);
mgrAfterDelete(new Set());
toast('删除失败：' + (e && e.message), 'err');
});
}
async function mgrDeleteFiltered() {
var s = _mgrState;
if (mgrLocked()) return;
var targets = s.filtered.slice();
if (!targets.length) return;
// Every narrowing control has to appear here: the message claims the
// batch is the WHOLE store, and a status filter narrows the set just
// as a folder or a search term does. Leaving it out would announce
// 将清空全部备份 over a 仅不在收藏夹 selection.
var whole = (s.folder === '*' && s.status === '*' && !s.query.trim());
var msg = whole
? '将清空全部备份，共 ' + targets.length + ' 项。\n\n删除后无法恢复，确定继续？'
: '将删除当前筛选结果，共 ' + targets.length + ' 项。\n\n删除后无法恢复，确定继续？';
if (!confirm(msg)) return;
mgrSetBusy(true);
var removed = new Set();
var failed = 0;
// Serial, not Promise.all: each delete is its own transaction and the
// whole set is a few hundred records at worst (measured in seconds),
// while a few hundred parallel transactions is how the connection gets
// starved. A mid-way failure keeps everything already removed.
for (var i = 0; i < targets.length; i++) {
try {
await deleteBackupAv(targets[i].av);
removed.add(targets[i].av);
} catch (e) {
failed++;
warn('mgr: delete failed for av', targets[i].av, e && e.message);
}
}
// Dropped once per batch, and before the state guard: the records left
// IDB regardless of whether the panel is still open.
if (removed.size) pageCache.clear();
if (_mgrState !== s) return; // panel closed mid-batch
mgrSetBusy(false);
mgrAfterDelete(removed);
toast('已删除 ' + removed.size + ' 项备份'
+ (failed ? ' · 失败 ' + failed + ' 项' : ''), failed ? 'warn' : 'ok');
}
// Packs the current filter into a ZIP (15c-backup-export.js). Read-only,
// so unlike the delete paths it asks for no confirmation.
//
// The row list is SNAPSHOT at click time: the export then owns its own
// copy and the user may keep searching, paging and switching folders while
// it runs. Closing the panel mid-run does not cancel it either — the file
// was asked for and a read-only job has nothing to roll back — so every UI
// touch below is gated on the panel still being the one this run started
// with, while the completion toast (which does not belong to the panel)
// fires from exportBackupRows regardless.
//
// renderToken is deliberately NOT involved: that mechanism exists for
// thumbnail objectURL lifetime and means nothing here.
function mgrExportFiltered() {
var s = _mgrState;
if (mgrLocked()) return;
var rows = s.filtered.slice();
if (!rows.length) return;
s.exportBusy = true;
s.els.exportBtn.disabled = true;
s.els.exportBtn.textContent = '导出中 0%';
mgrRenderList();
// Percent, not "N / M": the row count is already in the page info line,
// and repainting the label on every one of several hundred rows is
// wasted layout work — only a whole-number change is written back.
var lastPct = -1;
exportBackupRows(rows, {
scope: {
folder: s.folder,
folderTitle: s.folder === '*' ? null : (s.names.get(String(s.folder)) || null),
query: s.query,
sort: s.sort
},
metas: s.metas,
onProgress: function (done, total) {
if (_mgrState !== s) return;
var pct = total ? Math.floor(done * 100 / total) : 100;
if (pct === lastPct) return;
lastPct = pct;
s.els.exportBtn.textContent = '导出中 ' + pct + '%';
}
}).catch(function (e) {
warn('mgr: export threw', e);
toast('导出失败：' + (e && e.message), 'err');
}).then(function () {
if (_mgrState !== s) return; // panel closed mid-export
s.exportBusy = false;
s.els.exportBtn.disabled = false;
s.els.exportBtn.textContent = '导出筛选结果';
// Nothing in the store changed, so the index stands; the re-render
// is purely to hand the rows and the bulk button back.
mgrRenderList();
});
}
// Merges a container written by the export back into the store
// (15d-backup-import.js). The opposite of mgrExportFiltered in one way
// that matters: this WRITES, so every surface derived from the index is
// stale afterwards and the panel takes the same full refresh an in-panel
// backup does.
//
// The current filter is deliberately NOT involved. An export packs what
// the user is looking at; an import merges what the FILE contains, and
// silently dropping records because a search box happened to be filled
// would be a data-loss surprise wearing a filter's clothes.
//
// The lock is taken in onStart, not here: a dismissed file dialog fires no
// event at all, so a lock taken at click time would never be released.
function mgrImportBackup() {
var s = _mgrState;
if (mgrLocked()) return;
// Percent for the same reason the export uses it — only a whole-number
// change is written back, so a thousand-item merge repaints the label
// a hundred times instead of a thousand.
var lastPct = -1;
importPickBackupFile({
onStart: function () {
if (_mgrState !== s) return; // panel closed while the dialog was open
s.importBusy = true;
s.els.importBtn.disabled = true;
s.els.importBtn.textContent = '导入中 0%';
mgrRenderList();
},
onProgress: function (done, total) {
if (_mgrState !== s) return;
var pct = total ? Math.floor(done * 100 / total) : 100;
if (pct === lastPct) return;
lastPct = pct;
s.els.importBtn.textContent = '导入中 ' + pct + '%';
},
onSettled: function (stats) {
if (_mgrState !== s) return; // panel closed mid-import
s.importBusy = false;
s.els.importBtn.disabled = false;
s.els.importBtn.textContent = '导入备份文件';
// A run that wrote nothing (refused, or every record already
// present) leaves the index, the folder map and the header
// totals valid, so the cursor walk is skipped and only the
// controls are handed back.
if (stats && (stats.added || stats.updated || stats.folders)) {
mgrRefreshIndex();
return;
}
mgrRenderList();
}
});
}
function closeBackupManager() {
if (!_mgrHost) return;
if (_mgrState) {
// Invalidate before revoking so a thumbnail read still in flight
// cannot resurrect an objectURL after the panel is gone.
_mgrState.renderToken++;
mgrRevokeThumbs();
}
if (_mgrState && _mgrState.onKeydown) {
document.removeEventListener('keydown', _mgrState.onKeydown, true);
}
try { _mgrHost.remove(); } catch (e) {}
_mgrHost = null;
_mgrState = null;
}
// ─── Entry point ────────────────────────────────────────────────────
// Driven by the Tampermonkey menu command and __biliFavFix.backup.manage().
async function openBackupManager() {
if (_mgrHost) {
// Single instance: a second invocation focuses the open panel
// rather than stacking a second overlay on top of it.
var open = _mgrHost.querySelector('.fav-fix-mgr-input');
if (open) open.focus();
return;
}
if (_mgrOpening) return;
if (typeof indexedDB === 'undefined') {
toast('当前环境不支持 IndexedDB，无法管理备份', 'err');
return;
}
_mgrOpening = true;
try {
// Probe the DB BEFORE painting anything: a panel that renders and
// then has to apologise is worse than never opening. idbCount also
// performs the lazy open, so a failure here is the open failing.
try { await idbCount(BACKUP_STORE_ITEMS); }
catch (e) {
toast('无法打开备份数据库：' + (e && e.message), 'err');
return;
}
ensureBackupManagerStyles();
var host = document.createElement('div');
host.className = 'fav-fix-mgr-overlay';
host.innerHTML = ''
+ '' + esc(sub)
+ '' + esc(tagTxt) + ''
+ '' + esc(memTxt) + ''
+ '
'
+ ''
+ '
';
document.body.appendChild(host);
_mgrHost = host;
_mgrState = {
index: [], filtered: [], page: 1, query: '', folder: '*',
sort: 'fav_desc', status: '*',
names: new Map(), metas: new Map(), quotaText: null,
// Folder membership snapshots (15f): media_id → Set of av
// strings, plus when each was taken. Loaded from GM storage on
// open and after every scan; absent entries are what the
// classifier reports as 未检查.
membership: new Map(), memberStamps: new Map(),
currentMid: detectMediaId(),
urls: [], renderToken: 0,
// One flag per long operation rather than a single lock: they
// exclude each other but disable different controls, and the
// release paths are independent.
busy: false, backupBusy: false, exportBusy: false, importBusy: false,
membershipBusy: false,
searchTimer: null,
onKeydown: null,
els: {
stat: host.querySelector('.fav-fix-mgr-stat'),
body: host.querySelector('.fav-fix-mgr-body'),
search: host.querySelector('.fav-fix-mgr-input'),
folder: host.querySelector('.fav-fix-mgr-select'),
// Queried by its own class, never by .fav-fix-mgr-select:
// the folder select above takes that selector by being
// first in document order, which is not a property worth
// making two controls depend on.
status: host.querySelector('.fav-fix-mgr-status'),
sort: host.querySelector('.fav-fix-mgr-sort'),
check: host.querySelector('.fav-fix-mgr-check'),
backup: host.querySelector('.fav-fix-mgr-backup'),
// Not `els.export`: a bare `export` identifier is reserved,
// and a property that cannot be destructured or aliased
// without care is not worth the two saved characters.
exportBtn: host.querySelector('.fav-fix-mgr-export'),
// Named importBtn for symmetry with exportBtn (and because
// `import` is a reserved word too).
importBtn: host.querySelector('.fav-fix-mgr-import'),
bulk: host.querySelector('.fav-fix-mgr-bulk'),
prev: host.querySelector('.fav-fix-mgr-prev'),
next: host.querySelector('.fav-fix-mgr-next'),
pageInfo: host.querySelector('.fav-fix-mgr-pageinfo')
}
};
var s = _mgrState;
host.querySelector('.fav-fix-mgr-close')
.addEventListener('click', closeBackupManager);
// Backdrop click only — a click that started inside the panel and
// ended on the overlay must not close it.
host.addEventListener('click', function (e) {
if (e.target === host) closeBackupManager();
});
// Capture phase: bilibili's own key handlers sit on document too,
// and Esc should reach us regardless of what has focus.
s.onKeydown = function (e) {
if (e.key === 'Escape') { e.stopPropagation(); closeBackupManager(); }
};
document.addEventListener('keydown', s.onKeydown, true);
s.els.search.addEventListener('input', function () {
if (s.searchTimer) clearTimeout(s.searchTimer);
s.searchTimer = setTimeout(function () {
// A re-render mid-batch would repaint the rows with their
// delete buttons enabled again, so filtering/paging stays
// frozen for the duration of a delete. What was typed is
// not lost: mgrResyncSearch re-reads the box on release.
if (_mgrState !== s || s.busy) return;
s.query = s.els.search.value;
mgrApplyFilter();
mgrRenderList();
}, cfg('mgrSearchDebounceMs'));
});
s.els.folder.addEventListener('change', function () {
if (s.busy) { s.els.folder.value = s.folder; return; }
s.folder = s.els.folder.value;
mgrApplyFilter();
mgrRenderList();
});
s.els.status.addEventListener('change', function () {
if (s.busy) { s.els.status.value = s.status; return; }
s.status = s.els.status.value;
mgrApplyFilter();
mgrRenderList();
});
s.els.sort.addEventListener('change', function () {
if (s.busy) { s.els.sort.value = s.sort; return; }
s.sort = s.els.sort.value;
mgrApplyFilter();
mgrRenderList();
});
// Scope follows the folder filter: one folder selected checks just
// that folder, 全部 checks every folder the index mentions. Unlike
// the backup button above it never re-detects the page's folder —
// it answers a question about what the panel is currently showing.
s.els.check.addEventListener('click', function () {
if (mgrLocked()) return;
var targets = s.folder !== '*' ? [s.folder] : mgrIndexFolderIds();
if (!targets.length) { toast('没有可检查的收藏夹', 'warn'); return; }
s.membershipBusy = true;
s.els.check.disabled = true;
s.els.check.textContent = '检查中…';
mgrRenderList();
scanMembership(targets).catch(function (e) {
warn('mgr: membership scan threw', e);
toast('检查失败：' + (e && e.message), 'err');
return null;
}).then(function () {
if (_mgrState !== s) return;
s.membershipBusy = false;
s.els.check.disabled = false;
s.els.check.textContent = '检查是否仍在收藏夹';
mgrReloadMembership();
// Every row's tag changes, but the filtered SET only moves
// when a status filter is active — so the reader keeps
// their page unless the filter itself was affected.
if (s.status !== '*') mgrApplyFilter();
mgrRenderList();
});
});
s.els.exportBtn.addEventListener('click', mgrExportFiltered);
s.els.importBtn.addEventListener('click', mgrImportBackup);
s.els.bulk.addEventListener('click', function () {
mgrDeleteFiltered().catch(function (e) {
warn('mgr: bulk delete threw', e);
toast('批量删除失败：' + (e && e.message), 'err');
});
});
// In-panel backup: backupCurrentFolder() re-detects the folder at
// run time, so the flow for a folder the dropdown does not list
// yet is: switch the page to it, click this, and the refresh below
// adds it as a filter option. Deletes are blocked for the duration
// (see mgrRenderList); browsing stays free.
s.els.backup.addEventListener('click', function () {
if (mgrLocked()) return;
s.backupBusy = true;
s.els.backup.disabled = true;
s.els.backup.textContent = '备份中…';
mgrRenderList();
backupCurrentFolder().catch(function (e) {
warn('mgr: in-panel backup threw', e);
toast('备份失败：' + (e && e.message), 'err');
return null;
}).then(function () {
if (_mgrState !== s) return;
s.backupBusy = false;
s.els.backup.disabled = false;
s.els.backup.textContent = '备份当前收藏夹';
// The run may have been for a different folder than the
// one the panel opened on — re-detect so the 当前收藏夹
// marker follows what was actually just backed up.
s.currentMid = detectMediaId();
return mgrRefreshIndex();
});
});
s.els.prev.addEventListener('click', function () {
if (s.page > 1) { s.page--; mgrRenderList(); }
});
s.els.next.addEventListener('click', function () {
s.page++; mgrRenderList();
});
var index, layers;
try {
index = await buildBackupIndex();
layers = await mgrBuildFolderNames();
}
catch (e) {
warn('mgr: index build failed', e);
closeBackupManager();
toast('读取备份列表失败：' + (e && e.message), 'err');
return;
}
if (_mgrState !== s) return; // closed while the cursor was walking
s.index = index;
s.names = layers.names;
s.metas = layers.metas;
// Snapshots persist across sessions, so a panel opened long after
// the last scan still shows its verdicts. Must follow s.index —
// the folder set to load is derived from it.
mgrReloadMembership();
mgrRenderHead();
mgrRenderFolders();
mgrApplyFilter();
mgrRenderList();
mgrLoadQuota();
s.els.search.focus();
} finally {
_mgrOpening = false;
}
}
// ─── Backup export (ZIP) ────────────────────────────────────────────
//
// The IndexedDB backup is origin-scoped, invisible outside DevTools and
// evictable under storage pressure (navigator.storage.persist() is a
// request, not a guarantee). This module is the way out of the browser: it
// packs a panel selection into ONE .zip the user can keep anywhere —
// items.json for the metadata, covers/'
+ '
'
+ ''
+ '
'
+ ''
+ ''
+ '备份管理
'
+ '正在读取备份…
'
+ ''
+ ''
+ ''
// Next to the folder select because both are filters; 排序
// stays last as the only control that reorders rather than
// narrows. Option labels avoid naming a scope — what "在收藏夹"
// means depends on the folder selection, and the per-row tag
// is where that scope is spelled out.
+ ''
+ ''
+ '
'
+ ''
+ '
'
+ '正在读取备份…
'
+ ''
+ '
'
+ ''
// Neutral outline, no count: the red framing and the item
// count on the bulk delete are a confirmation affordance for a
// destructive act, and an export needs neither.
// First of the three neutral actions: it is the one that
// produces the information the other controls filter on, and
// it reads left-to-right as 检查 → 导出 → 导入 before the
// destructive action at the far end.
+ ''
+ ''
// Beside the export and equally neutral: the two halves of the
// same round trip belong next to each other, and both stay
// quieter than the destructive action to their right.
+ ''
+ ''
+ '
'
+ ''
+ ''
+ ''
+ ''
+ '
'
+ '