perfectionist-plugins 1.9.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/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 });
+}

package/hide-unowned-skins.js

@@ -5,6 +5,7 @@ const STYLE_ID = "perfectionist-hide-unowned-skins-style";
 const HIDDEN_CLASS = "perf-unowned-skin-hidden";
 const SKIN_ITEM_SELECTOR = ".skin-selection-item";
 const DOT_SELECTOR = ".skin-selection-indicator-selector";
+const SELECTED_CLASS = "skin-selection-item-selected";
 const SESSION_URI = "/lol-champ-select/v1/session";
 const SELECTION_URI = "/lol-champ-select/v1/session/my-selection";
 const CAROUSEL_URI = "/lol-champ-select/v1/skin-carousel-skins";
@@ -270,6 +271,7 @@ let allSkinIds = null;
 let currentChampionId = null;
 let carouselOrder = [];
 let selectedSkinId = null;
+let lastServerSkinId = null;
 let failure = null;
 let requestToken = 0;
 let refreshTimer = null;
@@ -284,6 +286,10 @@ const lastAppliedLeft = new Map();
 const skinSuffixCache = new Map();
 let repackTimer = null;
 let removeStyle = null;
+let lastSelectedDomIndex = -1;
+let navFixAt = 0;
+let lastSkipSignature = null;
+const widthCache = new Map();
 
 function logError(scope, error) {
   console.error(`[Perfectionist] Hide Unowned Skins: ${scope}`, error);
@@ -327,6 +333,39 @@ function pruneRepack() {
   }
 }
 
+function guardSelection(items) {
+  const selectedIndex = items.findIndex((item) => item.classList.contains(SELECTED_CLASS));
+  if (selectedIndex < 0) return false;
+  const previous = lastSelectedDomIndex;
+  lastSelectedDomIndex = selectedIndex;
+  const selected = items[selectedIndex];
+  const hidden = selected.classList.contains(HIDDEN_CLASS) || Boolean(selected.parentElement?.classList.contains(HIDDEN_CLASS));
+  if (!hidden) {
+    lastSkipSignature = null;
+    return false;
+  }
+
+  const visible = items.map((item, index) => (item.classList.contains(HIDDEN_CLASS) ? -1 : index)).filter((index) => index >= 0);
+  if (visible.length === 0) return false;
+
+  const forward = previous < 0 ? true : selectedIndex >= previous;
+  const target = forward
+    ? (visible.find((index) => index > selectedIndex) ?? visible[0])
+    : ([...visible].reverse().find((index) => index < selectedIndex) ?? visible[visible.length - 1]);
+  const skinId = readSkinId(items[target]);
+  if (skinId === null) return false;
+
+  const signature = `${selectedIndex}:${skinId}`;
+  if (lastSkipSignature === signature) return true;
+  const now = Date.now();
+  if (now < navFixAt) return true;
+  navFixAt = now + 150;
+  lastSkipSignature = signature;
+  lastSelectedDomIndex = target;
+  selectSkin(skinId).catch((error) => logError("could not skip the unowned skin.", error));
+  return true;
+}
+
 function repackVisibleItems(items) {
   pruneRepack();
   const visible = items.filter((item) => !item.classList.contains(HIDDEN_CLASS));
@@ -343,7 +382,14 @@ function repackVisibleItems(items) {
   if (!anchor) anchor = visible[Math.floor(visible.length / 2)];
   const anchorDomIndex = items.indexOf(anchor);
 
-  const widthOf = (item) => item.getBoundingClientRect().width || (item === anchor ? 117 : 73);
+  const widthOf = (item) => {
+    const measured = item.getBoundingClientRect().width;
+    if (measured > 0) {
+      widthCache.set(item, measured);
+      return measured;
+    }
+    return widthCache.get(item) ?? (item === anchor ? 117 : 73);
+  };
   const toPx = (item) => {
     const raw = item.style.left || "0";
     if (raw.endsWith("px")) return parseFloat(raw);
@@ -424,8 +470,10 @@ function applyAll() {
     else if (dotsHidden === 0 && dotList.hasAttribute("data-perf-dots")) dotList.removeAttribute("data-perf-dots");
   }
 
-  if (ownedSkinIds !== null && hidden > 0) scheduleRepack();
-  else if (hidden === 0) restoreRepack();
+  if (ownedSkinIds !== null && hidden > 0) {
+    if (guardSelection(items)) runRepack();
+    else scheduleRepack();
+  } else if (hidden === 0) restoreRepack();
 }
 
 function scheduleRepack() {
@@ -585,11 +633,13 @@ function updateForSession(session, selection) {
 
   const knownUnownedSkin = allSkinIds !== null && allSkinIds.has(serverSkinId) && !ownedSkinIds.has(serverSkinId);
   if (!selectInFlight && knownUnownedSkin) {
-    const fallback = nextOwnedSkin(ownedSkinIds, 0, 1);
+    const direction = lastServerSkinId !== null && serverSkinId !== null && serverSkinId < lastServerSkinId ? -1 : 1;
+    const fallback = nextOwnedSkin(ownedSkinIds, serverSkinId ?? 0, direction) ?? nextOwnedSkin(ownedSkinIds, 0, 1);
     if (fallback !== null) {
       selectSkin(fallback).catch((error) => logError("could not correct the selected skin.", error));
     }
   }
+  if (!selectInFlight && belongsToChampion && ownedSkinIds.has(serverSkinId)) lastServerSkinId = serverSkinId;
 
   applyAllGuarded();
 }

package/package.json

@@ -1,34 +1,37 @@
-{
-  "name": "perfectionist-plugins",
-  "version": "1.9.0",
-  "description": "Small plugins that fix the annoying parts of League of Legends champ select. Built for Pengu Loader.",
-  "type": "module",
-  "main": "perfectionist-utils.js",
-  "exports": {
-    ".": "./perfectionist-utils.js",
-    "./perfectionist-utils.js": "./perfectionist-utils.js",
-    "./ban-blocker.js": "./ban-blocker.js",
-    "./hide-unowned-skins.js": "./hide-unowned-skins.js",
-    "./unlock-profile-skins.js": "./unlock-profile-skins.js",
-    "./auto-claimer.js": "./auto-claimer.js",
-    "./auto-read.js": "./auto-read.js"
-  },
-  "files": [
-    "perfectionist-utils.js",
-    "ban-blocker.js",
-    "hide-unowned-skins.js",
-    "unlock-profile-skins.js",
-    "auto-claimer.js",
-    "auto-read.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/SrKing-9812/Perfectionist-Plugins.git"
-  },
-  "keywords": [
-    "pengu-loader",
-    "league-of-legends",
-    "plugin"
-  ],
-  "author": "Sr. King"
-}
+{
+  "name": "perfectionist-plugins",
+  "version": "2.0.0",
+  "description": "Small plugins that fix the annoying parts of League of Legends champ select. Built for Pengu Loader.",
+  "type": "module",
+  "main": "perfectionist-utils.js",
+  "exports": {
+    ".": "./perfectionist-utils.js",
+    "./perfectionist-utils.js": "./perfectionist-utils.js",
+    "./ban-blocker.js": "./ban-blocker.js",
+    "./hide-unowned-skins.js": "./hide-unowned-skins.js",
+    "./unlock-profile-skins.js": "./unlock-profile-skins.js",
+    "./auto-claimer.js": "./auto-claimer.js",
+    "./auto-read.js": "./auto-read.js",
+    "./better-client.js": "./better-client.js"
+  },
+  "files": [
+    "perfectionist-utils.js",
+    "ban-blocker.js",
+    "hide-unowned-skins.js",
+    "unlock-profile-skins.js",
+    "auto-claimer.js",
+    "auto-read.js",
+    "better-client.js",
+    "tools/betterclient-monitor.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SrKing-9812/Perfectionist-Plugins.git"
+  },
+  "keywords": [
+    "pengu-loader",
+    "league-of-legends",
+    "plugin"
+  ],
+  "author": "Sr. King"
+}

package/perfectionist-utils.js

@@ -6,7 +6,7 @@ const PANEL_ID = "perfectionist-plugins-panel";
 const STYLE_ID = "perfectionist-plugins-style";
 const TAB_TITLE = "Perfectionism";
 
-export const version = "1.8.0";
+export const version = "2.0.0";
 
 const PKG = "perfectionist-plugins";
 const CDN = "https://cdn.jsdelivr.net/npm";
@@ -22,6 +22,13 @@ const BUNDLED_MODULES = [
     description: "Shared core for the Perfectionism plugins.",
     core: true,
   },
+  {
+    id: "better-client",
+    file: "better-client.js",
+    name: "BetterClient",
+    version: "1.2.0",
+    description: "Debloats the client: blocks telemetry, merges duplicate requests, caches immutable data, decodes images asynchronously and fixes several bugs.",
+  },
   {
     id: "ban-blocker",
     file: "ban-blocker.js",
@@ -29,13 +36,6 @@ const BUNDLED_MODULES = [
     version: "3.6.0",
     description: "During bans, blocking a teammate instantly claims the champion they hover to ban.",
   },
-  {
-    id: "hide-unowned-skins",
-    file: "hide-unowned-skins.js",
-    name: "Hide Unowned Skins",
-    version: "2.4.0",
-    description: "In champion select, only shows the skins you own for the picked champion.",
-  },
   {
     id: "unlock-profile-skins",
     file: "unlock-profile-skins.js",
@@ -43,6 +43,13 @@ const BUNDLED_MODULES = [
     version: "1.2.1",
     description: "Unlocks every skin in the Set profile background window.",
   },
+  {
+    id: "hide-unowned-skins",
+    file: "hide-unowned-skins.js",
+    name: "Hide Unowned Skins",
+    version: "2.4.0",
+    description: "In champion select, only shows the skins you own for the picked champion.",
+  },
   {
     id: "auto-claimer",
     file: "auto-claimer.js",
@@ -741,9 +748,6 @@ function installedModules() {
   return getAvailableModules().filter(isInstalled);
 }
 
-// The master switch is a UI lock only: it greys out every card's settings and
-// toggle (same treatment as a disabled parent's child options) while each
-// plugin keeps its own enabled/disabled state untouched.
 function masterLocked() {
   return installedModules().length > 0 && state.masterLocked === true;
 }

package/tools/betterclient-monitor.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+// BetterClient memory monitor.
+//
+// Samples every League/Riot process once per interval, records client phase
+// (read straight from the LCU with the running client's own credentials) and
+// writes a CSV you can chart. With --diff it compares two V8 heap snapshots and
+// prints the constructors that grew the most.
+//
+//   node tools/betterclient-monitor.mjs                     # live table + CSV
+//   node tools/betterclient-monitor.mjs --minutes 240       # long session
+//   node tools/betterclient-monitor.mjs --snapshots 15      # heap snapshots via CDP
+//   node tools/betterclient-monitor.mjs --diff a.heapsnapshot b.heapsnapshot
+//
+// Nothing is installed and nothing is written outside --out / --snapshot-dir.
+
+import { execFileSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import https from "node:https";
+
+const args = process.argv.slice(2);
+const flag = (name, fallback) => {
+  const index = args.indexOf(`--${name}`);
+  if (index === -1) return fallback;
+  const value = args[index + 1];
+  return value && !value.startsWith("--") ? value : true;
+};
+
+const diffFiles = args.filter((entry) => entry.endsWith(".heapsnapshot"));
+if (args.includes("--diff")) {
+  diffSnapshots(diffFiles[0], diffFiles[1]);
+  process.exit(0);
+}
+
+const intervalSec = Number(flag("interval", 5));
+const minutes = Number(flag("minutes", 0));
+const out = String(flag("out", "betterclient-monitor.csv"));
+const snapshotEvery = Number(flag("snapshots", 0));
+const snapshotDir = String(flag("snapshot-dir", "heapsnapshots"));
+const snapshotPrefix = String(flag("prefix", "betterclient"));
+
+const NAMES = ["LeagueClient", "LeagueClientUx", "LeagueClientUxRender", "RiotClientServices", "RiotClientCrashHandler"];
+
+function powershell(script) {
+  return execFileSync("powershell", ["-NoProfile", "-Command", script], { encoding: "utf8", windowsHide: true });
+}
+
+function sampleProcesses() {
+  const filter = NAMES.map((name) => `$_.ProcessName -eq '${name}'`).join(" -or ");
+  const script = `Get-Process -ErrorAction SilentlyContinue | Where-Object { ${filter} } | ForEach-Object { "$($_.ProcessName)|$($_.Id)|$($_.WorkingSet64)|$($_.PrivateMemorySize64)|$($_.TotalProcessorTime.TotalSeconds)" }`;
+  const rows = powershell(script)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [name, pid, workingSet, priv, cpu] = line.split("|");
+      return { name, pid: Number(pid), mb: Math.round(Number(workingSet) / 1048576), privateMb: Math.round(Number(priv) / 1048576), cpu: Number(cpu) };
+    });
+  return rows.sort((a, b) => a.pid - b.pid);
+}
+
+let lcu = null;
+function discoverLcu() {
+  if (lcu) return lcu;
+  try {
+    const commandLine = powershell(`(Get-CimInstance Win32_Process -Filter "Name='LeagueClientUx.exe'").CommandLine`);
+    const port = /"?"--app-port=(\d+)/.exec(commandLine)?.[1];
+    const token = /"?"--remoting-auth-token=([\w-]+)/.exec(commandLine)?.[1];
+    if (port && token) lcu = { port: Number(port), token };
+  } catch {}
+  return lcu;
+}
+
+function lcuGet(path) {
+  const auth = discoverLcu();
+  if (!auth) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const request = https.request(
+      {
+        host: "127.0.0.1",
+        port: auth.port,
+        path,
+        method: "GET",
+        rejectUnauthorized: false,
+        headers: { Authorization: `Basic ${Buffer.from(`riot:${auth.token}`).toString("base64")}`, Accept: "application/json" },
+        timeout: 4000,
+      },
+      (response) => {
+        let body = "";
+        response.on("data", (chunk) => (body += chunk));
+        response.on("end", () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch {
+            resolve(body);
+          }
+        });
+      },
+    );
+    request.on("error", () => resolve(null));
+    request.on("timeout", () => {
+      request.destroy();
+      resolve(null);
+    });
+    request.end();
+  });
+}
+
+async function cdpTarget() {
+  for (const port of [9222, 9223, 9229, 9333]) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(1500) });
+      if (!response.ok) continue;
+      const targets = await response.json();
+      const page = targets.find((t) => t.webSocketDebuggerUrl && /league|client|riot/i.test(t.url ?? "")) ?? targets.find((t) => t.webSocketDebuggerUrl);
+      if (page) return page.webSocketDebuggerUrl;
+    } catch {}
+  }
+  return null;
+}
+
+async function takeHeapSnapshot() {
+  const url = await cdpTarget();
+  if (!url) {
+    console.log("[snapshot] no CDP endpoint found - start the client with a remote debugging port to record heap snapshots");
+    return null;
+  }
+  if (!existsSync(snapshotDir)) mkdirSync(snapshotDir, { recursive: true });
+  const name = `${snapshotDir}/${snapshotPrefix}-${new Date().toISOString().replace(/[:.]/g, "-")}.heapsnapshot`;
+  const socket = new WebSocket(url);
+  const chunks = [];
+  let id = 0;
+  const send = (method, params = {}) => socket.send(JSON.stringify({ id: ++id, method, params }));
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("snapshot timed out")), 180000);
+    socket.addEventListener("open", () => {
+      send("HeapProfiler.enable");
+      send("HeapProfiler.collectGarbage");
+      send("HeapProfiler.takeHeapSnapshot", { reportProgress: false, captureNumericValue: false });
+    });
+    socket.addEventListener("message", (event) => {
+      const message = JSON.parse(event.data);
+      if (message.method === "HeapProfiler.addHeapSnapshotChunk") chunks.push(message.params.chunk);
+      if (message.id === id) {
+        clearTimeout(timer);
+        if (message.error) reject(new Error(message.error.message));
+        else resolve();
+      }
+    });
+    socket.addEventListener("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  }).finally(() => socket.close());
+  writeFileSync(name, chunks.join(""));
+  console.log(`[snapshot] wrote ${name} (${(chunks.join("").length / 1048576).toFixed(1)} MB)`);
+  return name;
+}
+
+function diffSnapshots(fromPath, toPath) {
+  if (!fromPath || !toPath) {
+    console.log("usage: node tools/betterclient-monitor.mjs --diff old.heapsnapshot new.heapsnapshot");
+    return;
+  }
+  for (const path of [fromPath, toPath]) {
+    if (!existsSync(path)) {
+      console.log(`missing file: ${path}`);
+      return;
+    }
+  }
+  const tally = (snapshot) => {
+    const nodeFields = snapshot.snapshot.meta.node_fields;
+    const nodeTypes = snapshot.snapshot.meta.node_types[nodeFields.indexOf("type")];
+    const nameOffset = nodeFields.indexOf("name");
+    const sizeOffset = nodeFields.indexOf("self_size");
+    const width = nodeFields.length;
+    const nodes = snapshot.nodes;
+    const strings = snapshot.strings;
+    const map = new Map();
+    for (let i = 0; i < nodes.length; i += width) {
+      const type = nodeTypes[nodes[i]];
+      const name = strings[nodes[i + nameOffset]] ?? type;
+      const key = `${type}:${name}`;
+      const entry = map.get(key) ?? { count: 0, bytes: 0 };
+      entry.count += 1;
+      entry.bytes += nodes[i + sizeOffset];
+      map.set(key, entry);
+    }
+    return map;
+  };
+  const before = tally(JSON.parse(readFileSync(fromPath, "utf8")));
+  const after = tally(JSON.parse(readFileSync(toPath, "utf8")));
+  const rows = [];
+  for (const [key, value] of after) {
+    const previous = before.get(key) ?? { count: 0, bytes: 0 };
+    rows.push({ key, count: value.count - previous.count, bytes: value.bytes - previous.bytes });
+  }
+  rows.sort((a, b) => b.bytes - a.bytes);
+  console.log(`\ntop growers between the two snapshots:`);
+  for (const row of rows.slice(0, 25)) {
+    if (row.bytes <= 0) break;
+    console.log(`  +${(row.bytes / 1048576).toFixed(2)} MB  ${String(row.count).padStart(7)} nodes  ${row.key}`);
+  }
+  const total = rows.reduce((sum, row) => sum + row.bytes, 0);
+  console.log(`\nnet ${(total / 1048576).toFixed(1)} MB`);
+}
+
+const started = Date.now();
+const history = new Map();
+writeFileSync(out, "timestamp,phase,pid,process,working_set_mb,private_mb,cpu_seconds,cpu_percent\n");
+console.log(`writing ${out} - every ${intervalSec}s${minutes ? ` for ${minutes} min` : " until Ctrl+C"}`);
+
+const lastCpu = new Map();
+let lastCpuAt = Date.now();
+let tick = 0;
+
+async function loop() {
+  tick += 1;
+  let phase = "?";
+  try {
+    phase = await lcuGet("/lol-gameflow/v1/gameflow-phase");
+  } catch {}
+  const rows = sampleProcesses();
+  const now = Date.now();
+  const elapsed = (now - lastCpuAt) / 1000;
+  const parts = [];
+  for (const row of rows) {
+    const previous = lastCpu.get(row.pid);
+    const cpuPercent = previous !== undefined && elapsed > 0 ? Math.max(0, ((row.cpu - previous) / elapsed) * 100) : 0;
+    lastCpu.set(row.pid, row.cpu);
+    appendFileSync(out, `${new Date(now).toISOString()},${phase},${row.pid},${row.name},${row.mb},${row.privateMb},${row.cpu.toFixed(1)},${cpuPercent.toFixed(1)}\n`);
+    parts.push(`${row.name.replace("LeagueClient", "LC")}#${row.pid} ${row.mb}MB ${cpuPercent.toFixed(0)}%`);
+    const series = history.get(row.pid) ?? [];
+    series.push(row.mb);
+    history.set(row.pid, series);
+  }
+  lastCpuAt = now;
+  const totalMb = rows.reduce((sum, row) => sum + row.mb, 0);
+  console.log(`[${new Date(now).toLocaleTimeString()}] phase=${phase} total=${totalMb}MB | ${parts.join(" | ")}`);
+
+  if (snapshotEvery > 0 && tick % Math.max(1, Math.round((snapshotEvery * 60) / intervalSec)) === 0) {
+    await takeHeapSnapshot().catch((error) => console.log(`[snapshot] failed: ${error.message}`));
+  }
+
+  if (minutes > 0 && now - started >= minutes * 60 * 1000) {
+    console.log("\ngrowth over the run:");
+    for (const [pid, series] of history) {
+      if (series.length < 2) continue;
+      const first = series[0];
+      const last = series[series.length - 1];
+      const delta = last - first;
+      const minutesRun = Math.max(0.1, (Date.now() - started) / 60000);
+      const perHour = (delta / minutesRun) * 60;
+      const row = rows.find((entry) => entry.pid === pid);
+      console.log(`  ${row?.name ?? "process"}#${pid}: ${first}MB -> ${last}MB (${delta >= 0 ? "+" : ""}${delta}MB, ${perHour >= 0 ? "+" : ""}${perHour.toFixed(0)}MB/h)`);
+      if (perHour > 200) console.log("    ^ leak candidate - this process alone keeps growing");
+    }
+    console.log(`\nfull series in ${out}`);
+    process.exit(0);
+  }
+}
+
+while (true) {
+  try {
+    await loop();
+  } catch (error) {
+    console.log(`sample failed: ${error.message}`);
+  }
+  await new Promise((resolve) => setTimeout(resolve, intervalSec * 1000));
+}