perfectionist-plugins 1.8.0 → 2.0.0

package/README.md

@@ -67,6 +67,28 @@ Built for [Pengu Loader](https://pengu.lol)
       auto-open mystery loot (icons, ward skins), and auto-open chests with keys.
     </td>
   </tr>
+  <tr>
+    <td>&nbsp;</td>
+  </tr>
+  <tr>
+    <th align="left">🚀 BetterClient</th>
+  </tr>
+  <tr>
+    <td>
+      Debloats the client without changing how it looks or behaves: telemetry and analytics calls are dropped,
+      duplicate requests are merged, and immutable payloads (game-data assets and rune definitions) are cached
+      instead of re-downloaded and re-parsed every time a screen renders.
+      <br><br>
+      Tiles are marked for asynchronous decode, so building bot lists, champion grids and the tournament-draft
+      board no longer stalls the UI, and the in-game un-gate pass backs off to one check every five seconds once it
+      has nothing left to unlock.
+      <br><br>
+      It also keeps the social panel, friend requests and settings usable while a game is running.
+      <br><br>
+      For memory creep, <code>tools/betterclient-monitor.mjs</code> logs per-process RAM and client phase to CSV and
+      diffs heap snapshots.
+    </td>
+  </tr>
 </table>
 
 ## Install

package/auto-read.js

@@ -1,5 +1,5 @@
 const PLUGIN_ID = "auto-read";
-const version = "1.1.0";
+const version = "1.2.0";
 
 const SWEEP_DEBOUNCE_MS = 500;
 const ITEM_COOLDOWN_MS = 10 * 60 * 1000;
@@ -39,6 +39,13 @@ const CLASH_BULK_ACKS = [
   "/lol-clash/v1/eog-player-update/acknowledge",
   "/lol-clash/v1/game-end/acknowledge",
 ];
+const IDENTITY_NOTICE_TYPES = ["ACHIEVEMENT_TITLE", "SUMMONER_ICON", "REGALIA_BANNER"];
+const IDENTITY_ACK_URI = "/lol-inventory/v1/notification/acknowledge";
+const TOKENS_PREFS_URI = "/lol-settings/v2/account/LCUPreferences/lol-customizer-tokens";
+const LEVELUP_PREFS_URI = "/lol-settings/v2/account/LCUPreferences/lol-challenges-latest-level-up";
+const TFT_BATTLE_PASS_URI = "/lol-tft-pass/v1/battle-pass";
+const TFT_HOME_HUB_URI = "/lol-tft/v1/tft/homeHub";
+const TFT_PREFS_URI = "/lol-settings/v2/account/LCUPreferences/lol-tft";
 const PIP_STYLE_ID = "auto-read-pips-style";
 const PIP_CSS = ".activity-center__tab_label_notification { display: none !important; }";
 
@@ -201,6 +208,65 @@ async function sweepNotices() {
   }
 }
 
+async function sweepIdentity() {
+  for (const type of IDENTITY_NOTICE_TYPES) {
+    const list = await getJson(`/lol-inventory/v1/notifications/${type}`).catch(() => null);
+    if (!Array.isArray(list)) continue;
+    for (const note of list) {
+      const id = note?.id;
+      if (id == null || note.acknowledged === true) continue;
+      if (!ready(`invnote:${id}`, ITEM_COOLDOWN_MS)) continue;
+      stamp(`invnote:${id}`);
+      await sendJson("POST", IDENTITY_ACK_URI, { id }).catch(() => {});
+    }
+  }
+  if (!ready("tokens-visit", BULK_COOLDOWN_MS)) return;
+  const [tokens, levelUp] = await Promise.all([
+    getJson(TOKENS_PREFS_URI).catch(() => null),
+    getJson(LEVELUP_PREFS_URI).catch(() => null),
+  ]);
+  const lastVisit = Number(tokens?.data?.lastVisitTime ?? 0);
+  const lastLevelUp = Number(levelUp?.data?.lastLevelUpTime ?? 0);
+  if (!lastVisit || !(lastLevelUp > lastVisit)) return;
+  stamp("tokens-visit");
+  await sendJson("PUT", TOKENS_PREFS_URI, { schemaVersion: 1, data: { lastVisitTime: Date.now() } }).catch(() => {});
+}
+
+async function sweepTft() {
+  const bp = await getJson(TFT_BATTLE_PASS_URI).catch(() => null);
+  if (bp && Array.isArray(bp.milestones) && Array.isArray(bp.bonuses)) {
+    const list = [...bp.milestones, ...bp.bonuses];
+    const claimable = list.some((m) => m && m.status === "CLAIMABLE" && !m.isLocked);
+    const pending = list.some((m) => m && m.isClaimRequestPending);
+    const passId = bp?.info?.passId;
+    if (claimable && !pending && passId && ready("tft-claim", BULK_COOLDOWN_MS)) {
+      stamp("tft-claim");
+      await sendJson("PUT", `/lol-tft-pass/v1/pass/${encodeURIComponent(passId)}/milestone/claimAllRewards`).catch(() => {});
+    }
+  }
+  if (!ready("tft-promos", BULK_COOLDOWN_MS)) return;
+  const [hub, prefs] = await Promise.all([
+    getJson(TFT_HOME_HUB_URI).catch(() => null),
+    getJson(TFT_PREFS_URI).catch(() => null),
+  ]);
+  const store = hub?.storePromoOfferIds;
+  const battle = hub?.battlePassOfferIds;
+  const tact = hub?.tacticianPromoOfferIds;
+  if (!hub?.enabled || !Array.isArray(store) || !Array.isArray(battle) || !Array.isArray(tact)) return;
+  const target = { storeOfferIds: [battle[0], store[0]], tacticianOfferIds: tact };
+  const seen = prefs?.data?.seenOfferIds;
+  const same =
+    Array.isArray(seen?.storeOfferIds) &&
+    seen.storeOfferIds.length === target.storeOfferIds.length &&
+    seen.storeOfferIds.every((value, index) => value === target.storeOfferIds[index]) &&
+    Array.isArray(seen?.tacticianOfferIds) &&
+    seen.tacticianOfferIds.length === target.tacticianOfferIds.length &&
+    seen.tacticianOfferIds.every((value, index) => value === target.tacticianOfferIds[index]);
+  if (same) return;
+  stamp("tft-promos");
+  await sendJson("PATCH", TFT_PREFS_URI, { data: { seenOfferIds: target }, schemaVersion: 1 }).catch(() => {});
+}
+
 function syncPips() {
   const wanted = active && on("pips");
   let style = document.getElementById(PIP_STYLE_ID);
@@ -230,7 +296,11 @@ async function runSweep() {
   try {
     if (on("quests")) await sweepQuests().catch(() => {});
     if (on("loot")) await sweepLootMarks().catch(() => {});
-    if (on("rewards")) await sweepRewards().catch(() => {});
+    if (on("rewards")) {
+      await sweepRewards().catch(() => {});
+      await sweepIdentity().catch(() => {});
+    }
+    if (on("tft")) await sweepTft().catch(() => {});
     if (on("clash")) await sweepClash().catch(() => {});
     if (on("ranked")) await sweepRanked().catch(() => {});
     if (on("notices")) await sweepNotices().catch(() => {});
@@ -247,7 +317,7 @@ function onEnable(utils) {
   api = utils;
   active = true;
   cooldowns.clear();
-  for (const uri of [MISSIONS_URI, LOOT_URI, CLASH_FLAGS_URI, REWARDS_GRANTS_URI, LOOT_NOTIF_URI, MASTERY_NOTIF_URI, ...HONOR_NOTICES.map((n) => n.uri), RANKED_NOTIF_URI, EOS_NOTIF_URI, ...NOTICE_LIST_URIS]) {
+  for (const uri of [MISSIONS_URI, LOOT_URI, CLASH_FLAGS_URI, REWARDS_GRANTS_URI, LOOT_NOTIF_URI, MASTERY_NOTIF_URI, ...HONOR_NOTICES.map((n) => n.uri), RANKED_NOTIF_URI, EOS_NOTIF_URI, ...NOTICE_LIST_URIS, ...IDENTITY_NOTICE_TYPES.map((type) => `/lol-inventory/v1/notifications/${type}`), TOKENS_PREFS_URI, LEVELUP_PREFS_URI, TFT_BATTLE_PASS_URI, TFT_HOME_HUB_URI, TFT_PREFS_URI]) {
     try {
       const off = api.subscribe(uri, scheduleSweep);
       if (off) unsubscribes.push(off);
@@ -286,7 +356,7 @@ export function init() {
     utils.registerPlugin({
       id: PLUGIN_ID,
       name: "Auto Read",
-      description: "Automatically marks quests, loot, Clash and client notices as read so no badge or dot stays lit.",
+      description: "Automatically marks quests, loot, Clash, TFT and client notices as read so no badge or dot stays lit.",
       version,
       defaultEnabled: true,
       options: [
@@ -299,6 +369,7 @@ export function init() {
             { id: "quests", label: "Quests", description: "Quest and mission badges, including the mission button counter.", default: true },
             { id: "loot", label: "Loot marks", description: "The new mark on freshly earned loot.", default: true },
             { id: "rewards", label: "Rewards", description: "The dot on your avatar for new tokens, titles and banners, plus mastery, honor and loot notifications.", default: true },
+            { id: "tft", label: "TFT tab", description: "Claims claimable TFT pass rewards and marks TFT promo offers as seen so the TFT tab dot stays off.", default: true },
             { id: "clash", label: "Clash", description: "Clash tab flags and Clash notifications.", default: true },
             { id: "ranked", label: "Ranked", description: "Ranked, end-of-season and champion mastery notices.", default: true },
             { id: "notices", label: "Notices", description: "Patch, patcher, leaver buster, lobby, behavior and gameflow notices.", default: true },

package/better-client.js

@@ -0,0 +1,512 @@
+const PLUGIN_ID = "better-client";
+const version = "1.2.0";
+
+const MAX_CACHE_ENTRIES = 24;
+const MAX_CACHE_ENTRY_BYTES = 2 * 1024 * 1024;
+const MAX_CACHE_BYTES = 16 * 1024 * 1024;
+const UNGATE_MS = 1000;
+const UNGATE_IDLE_MS = 5000;
+const UNGATE_BACKOFF_AFTER = 20;
+const PHASE_POLL_MS = 5000;
+const IMAGE_BATCH = 200;
+
+const TELEMETRY_HOST = /(^|\.)(telemetry|analytics|metrics|sentry|bugsnag|crash-?report(er)?|pulse|tracking|beacon|datadog|loggly)(\.|:|$)/i;
+const TELEMETRY_PATH = /(^|\/)(lol-telemetry|lol-analytics|lol-metrics|lol-rms|rms|lol-sentry|lol-crash|telemetry|analytics|metrics|sentry|bugsnag|crash-?report\w*|tracking|beacon)(\/|$)/i;
+const ASSET_PATH = /^\/lol-game-data\/assets\//i;
+const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
+
+const STATIC_ENDPOINTS = [
+  ["/lol-game-data/assets/", 60 * 60 * 1000],
+  ["/lol-perks/v1/perks", 60 * 60 * 1000],
+  ["/performance/v1/quickstats", 5000],
+];
+
+const UNGATE_SELECTORS = [
+  ".app-controls-settings",
+  ".lol-settings-button",
+  "[class*='social-panel']",
+  ".social-panel",
+  ".lol-social-panel",
+  ".lol-navigation",
+  ".lol-navigation-item",
+  "[class*='friends-list']",
+];
+const BLOCK_MARKER = "[disabled], [aria-disabled='true'], [style*='pointer-events']";
+
+let api = null;
+let active = false;
+let phase = "None";
+let unsubscribes = [];
+let restores = [];
+let ungateTimer = null;
+let ungateIdle = 0;
+let phaseTimer = null;
+let cacheBytes = 0;
+
+const cache = new Map();
+const inflight = new Map();
+
+function baseHref() {
+  try {
+    return typeof location !== "undefined" ? location.href : "https://127.0.0.1/";
+  } catch {
+    return "https://127.0.0.1/";
+  }
+}
+
+function resolveUrl(raw, base) {
+  try {
+    return new URL(String(raw), base ?? baseHref());
+  } catch {
+    return null;
+  }
+}
+
+function isLocalHost(host) {
+  return LOCAL_HOSTS.has(String(host ?? "").replace(/^\[|\]$/g, ""));
+}
+
+function isTelemetryUrl(raw, base) {
+  const url = resolveUrl(raw, base);
+  if (!url || url.protocol === "data:" || url.protocol === "blob:") return false;
+  if (ASSET_PATH.test(url.pathname)) return false;
+  if (isLocalHost(url.hostname)) return TELEMETRY_PATH.test(url.pathname);
+  return TELEMETRY_HOST.test(url.hostname) || TELEMETRY_PATH.test(url.pathname);
+}
+
+function shouldBlockUrl(raw, base) {
+  return isTelemetryUrl(raw, base);
+}
+
+function staticTtl(path) {
+  if (!path) return 0;
+  for (const [prefix, ttl] of STATIC_ENDPOINTS) {
+    if (path.startsWith(prefix)) return ttl;
+  }
+  return 0;
+}
+
+function methodOf(input, init) {
+  const method = init?.method ?? (input && typeof input === "object" && "method" in input ? input.method : "GET");
+  return String(method ?? "GET").toUpperCase();
+}
+
+function urlOf(input) {
+  if (typeof input === "string") return input;
+  if (input && typeof input === "object") {
+    if (typeof input.url === "string") return input.url;
+    if (typeof input.href === "string") return input.href;
+  }
+  return String(input);
+}
+
+function emptyJsonResponse(env) {
+  const Ctor = env?.Response ?? (typeof Response !== "undefined" ? Response : null);
+  if (!Ctor) return undefined;
+  try {
+    return new Ctor("{}", { status: 200, headers: { "Content-Type": "application/json" } });
+  } catch {
+    return undefined;
+  }
+}
+
+function evictOne(key) {
+  const entry = cache.get(key);
+  if (!entry) return;
+  cacheBytes -= entry.bytes;
+  cache.delete(key);
+}
+
+function evict(max) {
+  while (cache.size >= max) evictOne(cache.keys().next().value);
+}
+
+function storeInCache(key, ttl, response) {
+  const type = String(response.headers?.get?.("Content-Type") ?? "");
+  if (type && !/json|javascript|plain/i.test(type)) return;
+  const length = Number(response.headers?.get?.("Content-Length") ?? 0) || 0;
+  if (length > MAX_CACHE_ENTRY_BYTES) return;
+  evict(MAX_CACHE_ENTRIES);
+  cache.set(key, { at: Date.now(), ttl, res: response.clone(), bytes: length });
+  cacheBytes += length;
+  while (cacheBytes > MAX_CACHE_BYTES && cache.size > 1) {
+    evictOne(cache.keys().next().value);
+  }
+}
+
+function clearVolatileCache() {
+  for (const [key, entry] of [...cache]) {
+    if (entry.ttl < 60 * 60 * 1000) evictOne(key);
+  }
+}
+
+function createFetch(env) {
+  const native = env.fetch.bind(env);
+
+  function betterFetch(input, init) {
+    const raw = urlOf(input);
+    const method = methodOf(input, init);
+
+    if (active && shouldBlockUrl(raw)) {
+      return Promise.resolve(emptyJsonResponse(env));
+    }
+
+    const url = resolveUrl(raw);
+    const local = url ? isLocalHost(url.hostname) : false;
+    const cacheable = local && method === "GET";
+    const key = `${method} ${url ? url.origin + url.pathname + url.search : raw}`;
+
+    if (cacheable && active) {
+      const pending = inflight.get(key);
+      if (pending) {
+        return pending.then((response) => (response?.clone ? response.clone() : response));
+      }
+    }
+
+    if (cacheable && active) {
+      const ttl = staticTtl(url?.pathname);
+      const hit = ttl ? cache.get(key) : null;
+      if (hit && Date.now() - hit.at < hit.ttl) {
+        return Promise.resolve(hit.res.clone());
+      }
+    }
+
+    const request = native(input, init);
+    if (local && (method === "GET" || method === "HEAD")) {
+      inflight.set(key, request);
+      const done = () => inflight.delete(key);
+      request.then(done, done);
+      if (cacheable) {
+        request.then((response) => {
+          const ttl = staticTtl(url?.pathname);
+          if (!response?.ok || !ttl || !active) return;
+          storeInCache(key, ttl, response);
+        }, () => {});
+      }
+    }
+    return request;
+  }
+
+  betterFetch.__better = true;
+  return betterFetch;
+}
+
+function emitBlockedXhr(xhr, env) {
+  const reply = "{}";
+  try {
+    Object.defineProperty(xhr, "readyState", { configurable: true, get: () => 4 });
+    Object.defineProperty(xhr, "status", { configurable: true, get: () => 200 });
+    Object.defineProperty(xhr, "responseText", { configurable: true, get: () => reply });
+    Object.defineProperty(xhr, "response", { configurable: true, get: () => reply });
+  } catch {}
+  const EventCtor = env.Event ?? (typeof Event !== "undefined" ? Event : null);
+  if (!EventCtor) return;
+  setTimeout(() => {
+    try {
+      xhr.dispatchEvent(new EventCtor("readystatechange"));
+      xhr.dispatchEvent(new EventCtor("load"));
+      xhr.dispatchEvent(new EventCtor("loadend"));
+    } catch {}
+  }, 0);
+}
+
+function installXhr(env) {
+  const proto = env.XMLHttpRequest?.prototype;
+  if (!proto || proto.__better) return null;
+  const nativeOpen = proto.open;
+  const nativeSend = proto.send;
+  proto.open = function (method, url, ...rest) {
+    this.__betterUrl = String(url);
+    return nativeOpen.call(this, method, url, ...rest);
+  };
+  proto.send = function (body) {
+    if (active && shouldBlockUrl(this.__betterUrl)) {
+      emitBlockedXhr(this, env);
+      return undefined;
+    }
+    return nativeSend.call(this, body);
+  };
+  proto.__better = true;
+  return () => {
+    proto.open = nativeOpen;
+    proto.send = nativeSend;
+    delete proto.__better;
+  };
+}
+
+function installBeacon(env) {
+  const nav = env.navigator;
+  if (!nav?.sendBeacon || nav.sendBeacon.__better) return null;
+  const native = nav.sendBeacon.bind(nav);
+  const patched = function (url) {
+    if (active && shouldBlockUrl(url)) return true;
+    return native(url, arguments[1]);
+  };
+  patched.__better = true;
+  nav.sendBeacon = patched;
+  return () => {
+    nav.sendBeacon = native;
+  };
+}
+
+let imageObserver = null;
+let imageQueue = [];
+let imageFlushTimer = null;
+
+function markAsyncDecode(img) {
+  if (!img || img.tagName !== "IMG" || img.decoding === "async") return 0;
+  try {
+    img.decoding = "async";
+    return 1;
+  } catch {
+    return 0;
+  }
+}
+
+function flushImageQueue() {
+  imageFlushTimer = null;
+  const batch = imageQueue.splice(0, IMAGE_BATCH);
+  for (const img of batch) markAsyncDecode(img);
+  if (imageQueue.length > 0) scheduleImageFlush();
+}
+
+function scheduleImageFlush() {
+  if (imageFlushTimer !== null) return;
+  imageFlushTimer = setTimeout(flushImageQueue, 150);
+}
+
+function enqueueImages(root) {
+  if (!root || root.nodeType !== 1) return 0;
+  let added = 0;
+  if (root.tagName === "IMG") {
+    imageQueue.push(root);
+    added += 1;
+  }
+  let list = [];
+  try {
+    list = root.querySelectorAll("img:not([decoding='async'])");
+  } catch {
+    list = [];
+  }
+  for (const img of list) {
+    imageQueue.push(img);
+    added += 1;
+  }
+  if (imageQueue.length > 6000) imageQueue.splice(0, imageQueue.length - 6000);
+  if (added > 0) scheduleImageFlush();
+  return added;
+}
+
+function installImageDecode() {
+  if (typeof document === "undefined" || !document.documentElement) return () => {};
+  const Obs = document.defaultView?.MutationObserver ?? MutationObserver;
+  if (imageObserver || !Obs) return () => {};
+  imageObserver = new Obs((records) => {
+    let queued = false;
+    for (const record of records) {
+      if (record.type === "attributes") {
+        if (enqueueImages(record.target) > 0) queued = true;
+        continue;
+      }
+      for (const node of record.addedNodes) {
+        if (node?.nodeType !== 1) continue;
+        if (enqueueImages(node) > 0) queued = true;
+      }
+    }
+    if (queued) scheduleImageFlush();
+  });
+  try {
+    imageObserver.observe(document.documentElement, { childList: true, subtree: true, attributes: true, attributeFilter: ["src"] });
+  } catch {
+    imageObserver = null;
+    return () => {};
+  }
+  enqueueImages(document.documentElement);
+  const sweep = setInterval(() => enqueueImages(document.documentElement), 30000);
+  return () => {
+    clearInterval(sweep);
+    clearTimeout(imageFlushTimer);
+    imageFlushTimer = null;
+    imageQueue = [];
+    imageObserver?.disconnect();
+    imageObserver = null;
+  };
+}
+
+function ungateNode(node) {
+  if (!node?.querySelectorAll) return 0;
+  let changed = 0;
+  const candidates = [];
+  try {
+    if (node.matches?.(BLOCK_MARKER)) candidates.push(node);
+    candidates.push(...node.querySelectorAll(BLOCK_MARKER));
+  } catch {
+    return 0;
+  }
+  for (const element of candidates) {
+    if (element.disabled === true) {
+      element.disabled = false;
+      changed += 1;
+    }
+    if (element.hasAttribute?.("disabled")) {
+      element.removeAttribute("disabled");
+      changed += 1;
+    }
+    if (element.getAttribute?.("aria-disabled") === "true") {
+      element.removeAttribute("aria-disabled");
+      changed += 1;
+    }
+    if (element.style?.pointerEvents === "none") {
+      element.style.pointerEvents = "";
+      changed += 1;
+    }
+  }
+  return changed;
+}
+
+function ungatePass() {
+  if (!active || phase !== "InProgress") return 0;
+  let changed = 0;
+  for (const selector of UNGATE_SELECTORS) {
+    let nodes = [];
+    try {
+      nodes = document.querySelectorAll(selector);
+    } catch {
+      nodes = [];
+    }
+    for (const node of nodes) changed += ungateNode(node);
+  }
+  return changed;
+}
+
+function ungateDelay() {
+  return ungateIdle >= UNGATE_BACKOFF_AFTER ? UNGATE_IDLE_MS : UNGATE_MS;
+}
+
+function ungateTick() {
+  ungateTimer = null;
+  if (!active || phase !== "InProgress") return;
+  const changed = ungatePass();
+  ungateIdle = changed > 0 ? 0 : ungateIdle + 1;
+  ungateTimer = setTimeout(ungateTick, ungateDelay());
+}
+
+function startUngate() {
+  if (ungateTimer) return;
+  ungateIdle = 0;
+  ungateTick();
+}
+
+function stopUngate() {
+  clearTimeout(ungateTimer);
+  ungateTimer = null;
+  ungateIdle = 0;
+}
+
+function onPhase(next) {
+  const value = typeof next === "string" ? next : next?.phase ?? phase;
+  if (!value || value === phase) {
+    if (value === "InProgress") startUngate();
+    return;
+  }
+  phase = value;
+  clearVolatileCache();
+  if (phase === "InProgress") startUngate();
+  else stopUngate();
+}
+
+async function refreshPhase() {
+  if (!active) return;
+  if (typeof document !== "undefined" && document.hidden) return;
+  try {
+    const current = await api?.lcu?.get?.("/lol-gameflow/v1/gameflow-phase");
+    if (current) onPhase(current);
+  } catch {}
+}
+
+function installNetwork(env) {
+  const installed = [];
+  try {
+    const originalFetch = env.fetch;
+    env.fetch = createFetch(env);
+    installed.push(() => {
+      env.fetch = originalFetch;
+    });
+  } catch {}
+  const xhr = installXhr(env);
+  if (xhr) installed.push(xhr);
+  const beacon = installBeacon(env);
+  if (beacon) installed.push(beacon);
+  return () => {
+    for (const restore of installed.reverse()) {
+      try {
+        restore();
+      } catch {}
+    }
+  };
+}
+
+function onEnable(utils) {
+  api = utils;
+  active = true;
+  restores = [installNetwork(window), installImageDecode()];
+  unsubscribes = [];
+  try {
+    const off = api.subscribe("/lol-gameflow/v1/gameflow-phase", onPhase);
+    if (off) unsubscribes.push(off);
+  } catch {}
+  try {
+    api
+      .lcu?.get?.("/lol-gameflow/v1/gameflow-phase")
+      .then((value) => onPhase(value))
+      .catch(() => {});
+  } catch {}
+  refreshPhase();
+  clearInterval(phaseTimer);
+  phaseTimer = setInterval(refreshPhase, PHASE_POLL_MS);
+  if (phase === "InProgress") startUngate();
+}
+
+function onDisable() {
+  active = false;
+  clearInterval(phaseTimer);
+  phaseTimer = null;
+  stopUngate();
+  for (const off of unsubscribes) {
+    try {
+      off();
+    } catch {}
+  }
+  unsubscribes = [];
+  for (const restore of restores.reverse()) {
+    try {
+      restore();
+    } catch {}
+  }
+  restores = [];
+  inflight.clear();
+  for (const key of [...cache.keys()]) evictOne(key);
+  cacheBytes = 0;
+  api = null;
+}
+
+export function init() {
+  const registerWith = (utils) => {
+    utils.registerPlugin({
+      id: PLUGIN_ID,
+      name: "BetterClient",
+      description:
+        "Debloats the client: blocks telemetry and analytics calls, merges duplicate requests, caches static client data, decodes images asynchronously and keeps settings, chat and friend requests usable during a game.",
+      version,
+      defaultEnabled: true,
+      onEnable,
+      onDisable,
+    });
+  };
+
+  if (window.PerfectionistUtils) {
+    registerWith(window.PerfectionistUtils);
+    return;
+  }
+  addEventListener("perfectionist:utils-ready", (e) => registerWith(e.detail ?? window.PerfectionistUtils), { once: true });
+}