1.2.0

.eslintrc.json

···
 {
+  "root": true,
   "extends": [
     "eslint:recommended",
     "plugin:@typescript-eslint/recommended",
···
     "@typescript-eslint/no-var-requires": "off",
 
     // https://canary.discord.com/channels/1154257010532032512/1154275441788583996/1181760413231230976
-    "no-unused-labels": "off"
+    "no-unused-labels": "off",
+
+    // baseUrl being set to ./packages/ makes language server suggest "types/src" instead of "@moonlight-mod/types"
+    "no-restricted-imports": [
+      "error",
+      {
+        "patterns": [
+          {
+            "group": ["types/*"],
+            "message": "Use @moonlight-mod/types instead"
+          },
+          {
+            "group": ["core/*"],
+            "message": "Use @moonlight-mod/core instead"
+          }
+        ]
+      }
+    ]
   },
   "settings": {
     "react": {

.github/workflows/browser.yml

···
+name: Browser extension builds
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  browser:
+    name: Browser extension builds
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 9
+          run_install: false
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+      - name: Build moonlight
+        env:
+          NODE_ENV: production
+        run: pnpm run build
+
+      - name: Build MV3
+        run: pnpm run browser
+      - name: Build MV2
+        run: pnpm run browser-mv2
+
+      - name: Upload MV3
+        uses: actions/upload-artifact@v4
+        with:
+          name: browser
+          path: ./dist/browser
+      - name: Upload MV2
+        uses: actions/upload-artifact@v4
+        with:
+          name: browser-mv2
+          path: ./dist/browser-mv2

.github/workflows/nightly.yml

···
       - name: Build moonlight
         env:
           NODE_ENV: production
+          MOONLIGHT_BRANCH: nightly
+          MOONLIGHT_VERSION: ${{ github.sha }}
         run: pnpm run build
 
       - name: Write ref/commit to file

.github/workflows/release.yml

···
       - name: Build moonlight
         env:
           NODE_ENV: production
+          MOONLIGHT_BRANCH: stable
+          MOONLIGHT_VERSION: ${{ github.ref_name }}
         run: pnpm run build
       - name: Create archive
         run: |

README.md

···
 <h3 align="center">
-  <img src="./img/wordmark.png" alt="moonlight" />
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./img/wordmark-light.png">
+    <source media="(prefers-color-scheme: light)" srcset="./img/wordmark.png">
+    <img src="./img/wordmark.png" alt="moonlight" />
+  </picture>
 
 <a href="https://discord.gg/FdZBTFCP6F">Discord server</a>
 \- <a href="https://github.com/moonlight-mod/moonlight">GitHub</a>
···
 
 moonlight is heavily inspired by hh3 (a private client mod) and the projects before it that it is inspired by, namely EndPwn. All core code is original or used with permission from their respective authors where not copyleft.
 
-**_This is an experimental passion project._** moonlight was not created out of malicious intent nor intended to seriously compete with other mods. Anything and everything is subject to change.
+**_This is an experimental passion project._** Anything and everything is subject to change, but it is stable enough for developers to experiment with.
 
 moonlight is licensed under the [GNU Lesser General Public License](https://www.gnu.org/licenses/lgpl-3.0.html) (`LGPL-3.0-or-later`). See [the documentation](https://moonlight-mod.github.io/) for more information.

build.mjs

···
 
 const prod = process.env.NODE_ENV === "production";
 const watch = process.argv.includes("--watch");
+const browser = process.argv.includes("--browser");
+const mv2 = process.argv.includes("--mv2");
+
+const buildBranch = process.env.MOONLIGHT_BRANCH ?? "dev";
+const buildVersion = process.env.MOONLIGHT_VERSION ?? "dev";
 
 const external = [
   "electron",
   "fs",
   "path",
   "module",
-  "events",
-  "original-fs", // wtf asar?
   "discord", // mappings
 
   // Silence an esbuild warning
···
 });
 
 async function build(name, entry) {
-  const outfile = path.join("./dist", name + ".js");
+  let outfile = path.join("./dist", name + ".js");
+  const browserDir = mv2 ? "browser-mv2" : "browser";
+  if (name === "browser") outfile = path.join("./dist", browserDir, "index.js");
 
   const dropLabels = [];
-  if (name !== "injector") dropLabels.push("injector");
-  if (name !== "node-preload") dropLabels.push("nodePreload");
-  if (name !== "web-preload") dropLabels.push("webPreload");
+  const labels = {
+    injector: ["injector"],
+    nodePreload: ["node-preload"],
+    webPreload: ["web-preload"],
+    browser: ["browser"],
+
+    webTarget: ["web-preload", "browser"],
+    nodeTarget: ["node-preload", "injector"]
+  };
+  for (const [label, targets] of Object.entries(labels)) {
+    if (!targets.includes(name)) {
+      dropLabels.push(label);
+    }
+  }
 
   const define = {
     MOONLIGHT_ENV: `"${name}"`,
-    MOONLIGHT_PROD: prod.toString()
+    MOONLIGHT_PROD: prod.toString(),
+    MOONLIGHT_BRANCH: `"${buildBranch}"`,
+    MOONLIGHT_VERSION: `"${buildVersion}"`
   };
 
-  for (const iterName of Object.keys(config)) {
+  for (const iterName of [
+    "injector",
+    "node-preload",
+    "web-preload",
+    "browser"
+  ]) {
     const snake = iterName.replace(/-/g, "_").toUpperCase();
     define[`MOONLIGHT_${snake}`] = (name === iterName).toString();
   }
 
   const nodeDependencies = ["glob"];
   const ignoredExternal = name === "web-preload" ? nodeDependencies : [];
+
+  const plugins = [deduplicatedLogging, taggedBuildLog(name)];
+  if (name === "browser") {
+    plugins.push(
+      copyStaticFiles({
+        src: mv2
+          ? "./packages/browser/manifestv2.json"
+          : "./packages/browser/manifest.json",
+        dest: `./dist/${browserDir}/manifest.json`
+      })
+    );
+
+    if (!mv2) {
+      plugins.push(
+        copyStaticFiles({
+          src: "./packages/browser/modifyResponseHeaders.json",
+          dest: `./dist/${browserDir}/modifyResponseHeaders.json`
+        })
+      );
+      plugins.push(
+        copyStaticFiles({
+          src: "./packages/browser/blockLoading.json",
+          dest: `./dist/${browserDir}/blockLoading.json`
+        })
+      );
+    }
+
+    plugins.push(
+      copyStaticFiles({
+        src: mv2
+          ? "./packages/browser/src/background-mv2.js"
+          : "./packages/browser/src/background.js",
+        dest: `./dist/${browserDir}/background.js`
+      })
+    );
+  }
 
   /** @type {import("esbuild").BuildOptions} */
   const esbuildConfig = {
     entryPoints: [entry],
     outfile,
 
-    format: "cjs",
-    platform: name === "web-preload" ? "browser" : "node",
+    format: "iife",
+    globalName: "module.exports",
+
+    platform: ["web-preload", "browser"].includes(name) ? "browser" : "node",
 
     treeShaking: true,
     bundle: true,
···
     dropLabels,
 
     logLevel: "silent",
-    plugins: [deduplicatedLogging, taggedBuildLog(name)]
+    plugins
   };
+
+  if (name === "browser") {
+    const coreExtensionsJson = {};
+
+    // eslint-disable-next-line no-inner-declarations
+    function readDir(dir) {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        const filePath = dir + "/" + file;
+        const normalizedPath = filePath.replace("./dist/core-extensions/", "");
+        if (fs.statSync(filePath).isDirectory()) {
+          readDir(filePath);
+        } else {
+          coreExtensionsJson[normalizedPath] = fs.readFileSync(
+            filePath,
+            "utf8"
+          );
+        }
+      }
+    }
+
+    readDir("./dist/core-extensions");
+
+    esbuildConfig.banner = {
+      js: `window._moonlight_coreExtensionsStr = ${JSON.stringify(
+        JSON.stringify(coreExtensionsJson)
+      )};`
+    };
+  }
 
   if (watch) {
     const ctx = await esbuild.context(esbuildConfig);
···
     entryPoints,
     outdir,
 
-    format: "cjs",
+    format: "iife",
+    globalName: "module.exports",
     platform: "node",
 
     treeShaking: true,
···
 
 const promises = [];
 
-for (const [name, entry] of Object.entries(config)) {
-  promises.push(build(name, entry));
-}
+if (browser) {
+  build("browser", "packages/browser/src/index.ts");
+} else {
+  for (const [name, entry] of Object.entries(config)) {
+    promises.push(build(name, entry));
+  }
 
-const coreExtensions = fs.readdirSync("./packages/core-extensions/src");
-for (const ext of coreExtensions) {
-  let copiedManifest = false;
+  const coreExtensions = fs.readdirSync("./packages/core-extensions/src");
+  for (const ext of coreExtensions) {
+    let copiedManifest = false;
 
-  for (const fileExt of ["ts", "tsx"]) {
-    for (const type of ["index", "node", "host"]) {
-      if (
-        fs.existsSync(
-          `./packages/core-extensions/src/${ext}/${type}.${fileExt}`
-        )
-      ) {
-        promises.push(buildExt(ext, type, !copiedManifest, fileExt));
-        copiedManifest = true;
+    for (const fileExt of ["ts", "tsx"]) {
+      for (const type of ["index", "node", "host"]) {
+        if (
+          fs.existsSync(
+            `./packages/core-extensions/src/${ext}/${type}.${fileExt}`
+          )
+        ) {
+          promises.push(buildExt(ext, type, !copiedManifest, fileExt));
+          copiedManifest = true;
+        }
       }
     }
   }

flake.lock

···
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1704295289,
-        "narHash": "sha256-9WZDRfpMqCYL6g/HNWVvXF0hxdaAgwgIGeLYiOhmes8=",
+        "lastModified": 1728067476,
+        "narHash": "sha256-/uJcVXuBt+VFCPQIX+4YnYrHaubJSx4HoNsJVNRgANM=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b0b2c5445c64191fd8d0b31f2b1a34e45a64547d",
+        "rev": "6e6b3dd395c3b1eb9be9f2d096383a8d05add030",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.11",
+        "ref": "nixos-24.05",
         "repo": "nixpkgs",
         "type": "github"
       }
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1702151865,
-        "narHash": "sha256-9VAt19t6yQa7pHZLDbil/QctAgVsA66DLnzdRGqDisg=",
+        "lastModified": 1727802920,
+        "narHash": "sha256-HP89HZOT0ReIbI7IJZJQoJgxvB2Tn28V6XS3MNKnfLs=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "666fc80e7b2afb570462423cb0e1cf1a3a34fedd",
+        "rev": "27e30d177e57d912d614c88c622dcfdb2e6e6515",
         "type": "github"
       },
       "original": {
···
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1709572248,
-        "narHash": "sha256-WhaKD4cIvZLbwI2vZTkpH/oEeqGiyMvdW3bLi24P0eU=",
-        "owner": "mojotech",
+        "lastModified": 1728137762,
+        "narHash": "sha256-iEFvPR3BopGyI5KjQ1DK+gEZ1dKDugq838tKdet2moQ=",
+        "owner": "NotNite",
         "repo": "pnpm2nix-nzbr",
-        "rev": "c3cfff81ea297cfb9dc18928652f375314dc287d",
+        "rev": "b7a60d3c7d106b601665e3f05dba6cdc6f59f959",
         "type": "github"
       },
       "original": {
-        "owner": "mojotech",
+        "owner": "NotNite",
         "repo": "pnpm2nix-nzbr",
         "type": "github"
       }

flake.nix

···
   description = "Yet another Discord mod";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
     flake-utils.url = "github:numtide/flake-utils";
-    pnpm2nix.url = "github:mojotech/pnpm2nix-nzbr";
+    pnpm2nix.url = "github:NotNite/pnpm2nix-nzbr";
   };
 
   outputs = { self, nixpkgs, flake-utils, pnpm2nix }:
-    let
-      mkMoonlight = { pkgs, mkPnpmPackage }:
-        mkPnpmPackage rec {
-          workspace = ./.;
-          src = ./.;
-          components = [
-            "packages/core"
-            "packages/core-extensions"
-            "packages/injector"
-            "packages/node-preload"
-            "packages/types"
-            "packages/web-preload"
-          ];
-          distDirs = [ "dist" ];
-
-          copyNodeModules = true;
-          buildPhase = "pnpm run build";
-          installPhase = "cp -r dist $out";
-
-          meta = with pkgs.lib; {
-            description = "Yet another Discord mod";
-            homepage = "https://moonlight-mod.github.io/";
-            license = licenses.lgpl3;
-            maintainers = with maintainers; [ notnite ];
-          };
-        };
-
-      nameTable = {
-        discord = "Discord";
-        discord-ptb = "DiscordPTB";
-        discord-canary = "DiscordCanary";
-        discord-development = "DiscordDevelopment";
-      };
-
-      darwinNameTable = {
-        discord = "Discord";
-        discord-ptb = "Discord PTB";
-        discord-canary = "Discord Canary";
-        discord-development = "Discord Development";
-      };
-
-      mkOverride = prev: moonlight: name:
-        let discord = prev.${name};
-        in discord.overrideAttrs (old: {
-          installPhase = let
-            folderName = nameTable.${name};
-            darwinFolderName = darwinNameTable.${name};
-
-            injected = ''
-              require("${moonlight}/injector").inject(
-                require("path").join(__dirname, "../_app.asar")
-              );
-            '';
-
-            packageJson = ''
-              {"name":"discord","main":"./injector.js","private":true}
-            '';
-
-          in old.installPhase + "\n" + ''
-            resources="$out/opt/${folderName}/resources"
-            if [ ! -d "$resources" ]; then
-              resources="$out/Applications/${darwinFolderName}.app/Contents/Resources"
-            fi
-
-            mv "$resources/app.asar" "$resources/_app.asar"
-            mkdir -p "$resources/app"
-
-            cat > "$resources/app/injector.js" <<EOF
-            ${injected}
-            EOF
-
-            echo '${packageJson}' > "$resources/app/package.json"
-          '';
-        });
-
-      overlay = final: prev: rec {
-        moonlight-mod = mkMoonlight {
-          pkgs = final;
-          mkPnpmPackage = pnpm2nix.packages.${final.system}.mkPnpmPackage;
-        };
-        discord = mkOverride prev moonlight-mod "discord";
-        discord-ptb = mkOverride prev moonlight-mod "discord-ptb";
-        discord-canary = mkOverride prev moonlight-mod "discord-canary";
-        discord-development =
-          mkOverride prev moonlight-mod "discord-development";
-      };
+    let overlay = import ./nix/overlay.nix { inherit pnpm2nix; };
     in flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = import nixpkgs {
···
           overlays = [ overlay ];
         };
       in {
+        # Don't use these unless you're testing things
         packages.default = pkgs.moonlight-mod;
         packages.moonlight-mod = pkgs.moonlight-mod;
 
···
         packages.discord-development = pkgs.discord-development;
       }) // {
         overlays.default = overlay;
+        homeModules.default = ./nix/home-manager.nix;
       };
 }

nix/default.nix

···
+{ pkgs, mkPnpmPackage }:
+
+mkPnpmPackage rec {
+  workspace = ./..;
+  src = ./..;
+
+  # Work around a bug with how it expects dist
+  components = [
+    "packages/core"
+    "packages/core-extensions"
+    "packages/injector"
+    "packages/node-preload"
+    "packages/types"
+    "packages/web-preload"
+  ];
+  distDirs = [ "dist" ];
+
+  copyNodeModules = true;
+  buildPhase = "pnpm run build";
+  installPhase = "cp -r dist $out";
+
+  meta = with pkgs.lib; {
+    description = "Yet another Discord mod";
+    homepage = "https://moonlight-mod.github.io/";
+    license = licenses.lgpl3;
+    maintainers = with maintainers; [ notnite ];
+  };
+}

nix/home-manager.nix

···
+{ config, lib, pkgs, ... }:
+
+let cfg = config.programs.moonlight-mod;
+in {
+  options.programs.moonlight-mod = {
+    enable = lib.mkEnableOption "Yet another Discord mod";
+
+    configs = let
+      # TODO: type this
+      type = lib.types.nullOr (lib.types.attrs);
+      default = null;
+    in {
+      stable = lib.mkOption {
+        inherit type default;
+        description = "Configuration for Discord Stable";
+      };
+
+      ptb = lib.mkOption {
+        inherit type default;
+        description = "Configuration for Discord PTB";
+      };
+
+      canary = lib.mkOption {
+        inherit type default;
+        description = "Configuration for Discord Canary";
+      };
+
+      development = lib.mkOption {
+        inherit type default;
+        description = "Configuration for Discord Development";
+      };
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
+    xdg.configFile."moonlight-mod/stable.json" =
+      lib.mkIf (cfg.configs.stable != null) {
+        text = builtins.toJSON cfg.configs.stable;
+      };
+
+    xdg.configFile."moonlight-mod/ptb.json" =
+      lib.mkIf (cfg.configs.ptb != null) {
+        text = builtins.toJSON cfg.configs.ptb;
+      };
+
+    xdg.configFile."moonlight-mod/canary.json" =
+      lib.mkIf (cfg.configs.canary != null) {
+        text = builtins.toJSON cfg.configs.canary;
+      };
+
+    xdg.configFile."moonlight-mod/development.json" =
+      lib.mkIf (cfg.configs.development != null) {
+        text = builtins.toJSON cfg.configs.development;
+      };
+  };
+}

nix/overlay.nix

···
+{ pnpm2nix }:
+
+let
+  nameTable = {
+    discord = "Discord";
+    discord-ptb = "DiscordPTB";
+    discord-canary = "DiscordCanary";
+    discord-development = "DiscordDevelopment";
+  };
+
+  darwinNameTable = {
+    discord = "Discord";
+    discord-ptb = "Discord PTB";
+    discord-canary = "Discord Canary";
+    discord-development = "Discord Development";
+  };
+
+  mkOverride = prev: moonlight: name:
+    let discord = prev.${name};
+    in discord.overrideAttrs (old: {
+      installPhase = let
+        folderName = nameTable.${name};
+        darwinFolderName = darwinNameTable.${name};
+
+        injected = ''
+          require("${moonlight}/injector").inject(
+            require("path").join(__dirname, "../_app.asar")
+          );
+        '';
+
+        packageJson = ''
+          {"name":"discord","main":"./injector.js","private":true}
+        '';
+
+      in old.installPhase + "\n" + ''
+        resources="$out/opt/${folderName}/resources"
+        if [ ! -d "$resources" ]; then
+          resources="$out/Applications/${darwinFolderName}.app/Contents/Resources"
+        fi
+
+        mv "$resources/app.asar" "$resources/_app.asar"
+        mkdir -p "$resources/app"
+
+        cat > "$resources/app/injector.js" <<EOF
+        ${injected}
+        EOF
+
+        echo '${packageJson}' > "$resources/app/package.json"
+      '';
+    });
+in final: prev: rec {
+  moonlight-mod = final.callPackage ./default.nix {
+    pkgs = final;
+    mkPnpmPackage = pnpm2nix.packages.${final.system}.mkPnpmPackage;
+  };
+  discord = mkOverride prev moonlight-mod "discord";
+  discord-ptb = mkOverride prev moonlight-mod "discord-ptb";
+  discord-canary = mkOverride prev moonlight-mod "discord-canary";
+  discord-development = mkOverride prev moonlight-mod "discord-development";
+}

package.json

···
   "scripts": {
     "build": "node build.mjs",
     "dev": "node build.mjs --watch",
+    "browser": "node build.mjs --browser",
+    "browser-mv2": "node build.mjs --browser --mv2",
     "lint": "eslint packages",
     "lint:fix": "eslint packages",
     "lint:report": "eslint --output-file eslint_report.json --format json packages",

packages/browser/blockLoading.json

···
+[
+  {
+    "id": 2,
+    "priority": 1,
+    "action": {
+      "type": "block"
+    },
+    "condition": {
+      "urlFilter": "*://discord.com/assets/*.js",
+      "resourceTypes": ["script"]
+    }
+  }
+]

packages/browser/manifest.json

···
+{
+  "manifest_version": 3,
+  "name": "moonlight",
+  "description": "Yet another Discord mod",
+  "version": "1.1.0",
+  "permissions": [
+    "declarativeNetRequestWithHostAccess",
+    "webRequest",
+    "scripting",
+    "webNavigation"
+  ],
+  "host_permissions": [
+    "https://moonlight-mod.github.io/*",
+    "https://api.github.com/*",
+    "https://*.discord.com/*"
+  ],
+  "content_scripts": [
+    {
+      "js": ["index.js"],
+      "matches": ["https://*.discord.com/*"],
+      "run_at": "document_start",
+      "world": "MAIN"
+    }
+  ],
+  "declarative_net_request": {
+    "rule_resources": [
+      {
+        "id": "modifyResponseHeaders",
+        "enabled": true,
+        "path": "modifyResponseHeaders.json"
+      },
+      {
+        "id": "blockLoading",
+        "enabled": true,
+        "path": "blockLoading.json"
+      }
+    ]
+  },
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "web_accessible_resources": [
+    {
+      "resources": ["index.js"],
+      "matches": ["https://*.discord.com/*"]
+    }
+  ]
+}

packages/browser/manifestv2.json

···
+{
+  "manifest_version": 2,
+  "name": "moonlight",
+  "description": "Yet another Discord mod",
+  "version": "1.1.0",
+  "permissions": [
+    "webRequest",
+    "webRequestBlocking",
+    "scripting",
+    "webNavigation",
+    "https://*.discord.com/assets/*.js",
+    "https://moonlight-mod.github.io/*",
+    "https://api.github.com/*",
+    "https://*.discord.com/*"
+  ],
+  "background": {
+    "scripts": ["background.js"]
+  },
+  "content_scripts": [
+    {
+      "js": ["index.js"],
+      "matches": ["https://*.discord.com/*"],
+      "run_at": "document_start",
+      "world": "MAIN"
+    }
+  ]
+}

packages/browser/modifyResponseHeaders.json

···
+[
+  {
+    "id": 1,
+    "priority": 2,
+    "action": {
+      "type": "modifyHeaders",
+      "responseHeaders": [
+        {
+          "header": "Content-Security-Policy",
+          "operation": "remove"
+        }
+      ]
+    },
+    "condition": {
+      "resourceTypes": ["main_frame"],
+      "initiatorDomains": ["discord.com"]
+    }
+  }
+]

packages/browser/package.json

···
+{
+  "name": "@moonlight-mod/browser",
+  "private": true,
+  "dependencies": {
+    "@moonlight-mod/core": "workspace:*",
+    "@moonlight-mod/types": "workspace:*",
+    "@moonlight-mod/web-preload": "workspace:*",
+    "@zenfs/core": "^1.0.2",
+    "@zenfs/dom": "^0.2.16"
+  }
+}

packages/browser/src/background-mv2.js

···
+/* eslint-disable no-console */
+/* eslint-disable no-undef */
+
+const starterUrls = ["web.", "sentry."];
+let blockLoading = true;
+let doing = false;
+let collectedUrls = new Set();
+
+chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {
+  const url = new URL(details.url);
+  if (!blockLoading && url.hostname.endsWith("discord.com")) {
+    console.log("Blocking", details.url);
+    blockLoading = true;
+    collectedUrls.clear();
+  }
+});
+
+async function doTheThing(urls, tabId) {
+  console.log("Doing", urls, tabId);
+
+  blockLoading = false;
+
+  try {
+    await chrome.scripting.executeScript({
+      target: { tabId },
+      world: "MAIN",
+      args: [urls],
+      func: async (urls) => {
+        try {
+          await window._moonlightBrowserInit();
+        } catch (e) {
+          console.log(e);
+        }
+
+        const scripts = [...document.querySelectorAll("script")].filter(
+          (script) => script.src && urls.some((url) => url.includes(script.src))
+        );
+
+        // backwards
+        urls.reverse();
+        for (const url of urls) {
+          const script = scripts.find((script) => url.includes(script.src));
+          console.log("adding new script", script);
+
+          const newScript = document.createElement("script");
+          for (const { name, value } of script.attributes) {
+            newScript.setAttribute(name, value);
+          }
+
+          script.remove();
+          document.documentElement.appendChild(newScript);
+        }
+      }
+    });
+  } catch (e) {
+    console.log(e);
+  }
+
+  doing = false;
+  collectedUrls.clear();
+}
+
+chrome.webRequest.onBeforeRequest.addListener(
+  async (details) => {
+    if (starterUrls.some((url) => details.url.includes(url))) {
+      console.log("Adding", details.url);
+      collectedUrls.add(details.url);
+    }
+
+    if (collectedUrls.size === starterUrls.length) {
+      if (doing) return;
+      if (!blockLoading) return;
+      doing = true;
+      const urls = [...collectedUrls];
+      const tabId = details.tabId;
+
+      // yes this is a load-bearing sleep
+      setTimeout(() => doTheThing(urls, tabId), 0);
+    }
+
+    if (blockLoading) return { cancel: true };
+  },
+  {
+    urls: ["https://*.discord.com/assets/*.js"]
+  },
+  ["blocking"]
+);
+
+chrome.webRequest.onHeadersReceived.addListener(
+  (details) => {
+    return {
+      responseHeaders: details.responseHeaders.filter(
+        (header) => header.name.toLowerCase() !== "content-security-policy"
+      )
+    };
+  },
+  { urls: ["https://*.discord.com/*"] },
+  ["blocking", "responseHeaders"]
+);

packages/browser/src/background.js

···
+/* eslint-disable no-console */
+/* eslint-disable no-undef */
+
+const starterUrls = ["web.", "sentry."];
+let blockLoading = true;
+let doing = false;
+let collectedUrls = new Set();
+
+chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {
+  const url = new URL(details.url);
+  if (!blockLoading && url.hostname.endsWith("discord.com")) {
+    await chrome.declarativeNetRequest.updateEnabledRulesets({
+      enableRulesetIds: ["modifyResponseHeaders", "blockLoading"]
+    });
+    blockLoading = true;
+    collectedUrls.clear();
+  }
+});
+
+chrome.webRequest.onBeforeRequest.addListener(
+  async (details) => {
+    if (details.tabId === -1) return;
+    if (starterUrls.some((url) => details.url.includes(url))) {
+      console.log("Adding", details.url);
+      collectedUrls.add(details.url);
+    }
+
+    if (collectedUrls.size === starterUrls.length) {
+      if (doing) return;
+      if (!blockLoading) return;
+      doing = true;
+      const urls = [...collectedUrls];
+      console.log("Doing", urls);
+
+      console.log("Running moonlight script");
+      try {
+        await chrome.scripting.executeScript({
+          target: { tabId: details.tabId },
+          world: "MAIN",
+          files: ["index.js"]
+        });
+      } catch (e) {
+        console.log(e);
+      }
+
+      console.log("Initializing moonlight");
+      try {
+        await chrome.scripting.executeScript({
+          target: { tabId: details.tabId },
+          world: "MAIN",
+          func: async () => {
+            try {
+              await window._moonlightBrowserInit();
+            } catch (e) {
+              console.log(e);
+            }
+          }
+        });
+      } catch (e) {
+        console.log(e);
+      }
+
+      console.log("Updating rulesets");
+      try {
+        blockLoading = false;
+        await chrome.declarativeNetRequest.updateEnabledRulesets({
+          disableRulesetIds: ["blockLoading"],
+          enableRulesetIds: ["modifyResponseHeaders"]
+        });
+      } catch (e) {
+        console.log(e);
+      }
+
+      console.log("Readding scripts");
+      try {
+        await chrome.scripting.executeScript({
+          target: { tabId: details.tabId },
+          world: "MAIN",
+          args: [urls],
+          func: async (urls) => {
+            const scripts = [...document.querySelectorAll("script")].filter(
+              (script) =>
+                script.src && urls.some((url) => url.includes(script.src))
+            );
+
+            // backwards
+            urls.reverse();
+            for (const url of urls) {
+              const script = scripts.find((script) => url.includes(script.src));
+              console.log("adding new script", script);
+
+              const newScript = document.createElement("script");
+              for (const { name, value } of script.attributes) {
+                newScript.setAttribute(name, value);
+              }
+
+              script.remove();
+              document.documentElement.appendChild(newScript);
+            }
+          }
+        });
+      } catch (e) {
+        console.log(e);
+      }
+
+      console.log("Done");
+      doing = false;
+      collectedUrls.clear();
+    }
+  },
+  {
+    urls: ["*://*.discord.com/assets/*.js"]
+  }
+);

packages/browser/src/index.ts

···
+import "@moonlight-mod/web-preload";
+import { readConfig, writeConfig } from "@moonlight-mod/core/config";
+import Logger, { initLogger } from "@moonlight-mod/core/util/logger";
+import { getExtensions } from "@moonlight-mod/core/extension";
+import { loadExtensions } from "@moonlight-mod/core/extension/loader";
+import { MoonlightBranch, MoonlightNode } from "@moonlight-mod/types";
+import { IndexedDB } from "@zenfs/dom";
+import { configure } from "@zenfs/core";
+import * as fs from "@zenfs/core/promises";
+
+function getParts(path: string) {
+  if (path.startsWith("/")) path = path.substring(1);
+  return path.split("/");
+}
+
+window._moonlightBrowserInit = async () => {
+  // Set up a virtual filesystem with IndexedDB
+  await configure({
+    mounts: {
+      "/": {
+        backend: IndexedDB,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore tsc tweaking
+        storeName: "moonlight-fs"
+      }
+    }
+  });
+
+  window.moonlightFS = {
+    async readFile(path) {
+      return new Uint8Array(await fs.readFile(path));
+    },
+    async readFileString(path) {
+      const file = await this.readFile(path);
+      return new TextDecoder().decode(file);
+    },
+    async writeFile(path, data) {
+      await fs.writeFile(path, data);
+    },
+    async writeFileString(path, data) {
+      const file = new TextEncoder().encode(data);
+      await this.writeFile(path, file);
+    },
+    async unlink(path) {
+      await fs.unlink(path);
+    },
+
+    async readdir(path) {
+      return await fs.readdir(path);
+    },
+    async mkdir(path) {
+      const parts = getParts(path);
+      for (let i = 0; i < parts.length; i++) {
+        const path = this.join(...parts.slice(0, i + 1));
+        if (!(await this.exists(path))) await fs.mkdir(path);
+      }
+    },
+
+    async rmdir(path) {
+      const entries = await this.readdir(path);
+
+      for (const entry of entries) {
+        const fullPath = this.join(path, entry);
+        const isFile = await this.isFile(fullPath);
+        if (isFile) {
+          await this.unlink(fullPath);
+        } else {
+          await this.rmdir(fullPath);
+        }
+      }
+
+      await fs.rmdir(path);
+    },
+
+    async exists(path) {
+      return await fs.exists(path);
+    },
+    async isFile(path) {
+      return (await fs.stat(path)).isFile();
+    },
+
+    join(...parts) {
+      let str = parts.join("/");
+      if (!str.startsWith("/")) str = "/" + str;
+      return str;
+    },
+    dirname(path) {
+      const parts = getParts(path);
+      return "/" + parts.slice(0, parts.length - 1).join("/");
+    }
+  };
+
+  // Actual loading begins here
+  const config = await readConfig();
+  initLogger(config);
+
+  const extensions = await getExtensions();
+  const processedExtensions = await loadExtensions(extensions);
+
+  function getConfig(ext: string) {
+    const val = config.extensions[ext];
+    if (val == null || typeof val === "boolean") return undefined;
+    return val.config;
+  }
+
+  const moonlightNode: MoonlightNode = {
+    config,
+    extensions,
+    processedExtensions,
+    nativesCache: {},
+    isBrowser: true,
+
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH as MoonlightBranch,
+
+    getConfig,
+    getConfigOption: <T>(ext: string, name: string) => {
+      const config = getConfig(ext);
+      if (config == null) return undefined;
+      const option = config[name];
+      if (option == null) return undefined;
+      return option as T;
+    },
+    getNatives: () => {},
+    getLogger: (id: string) => {
+      return new Logger(id);
+    },
+
+    getMoonlightDir() {
+      return "/";
+    },
+    getExtensionDir: (ext: string) => {
+      return `/extensions/${ext}`;
+    },
+
+    writeConfig
+  };
+
+  Object.assign(window, {
+    moonlightNode
+  });
+
+  // This is set by web-preload for us
+  await window._moonlightBrowserLoad();
+};

packages/browser/tsconfig.json

···
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2022"
+  }
+}

packages/core-extensions/package.json

···
   "name": "@moonlight-mod/core-extensions",
   "private": true,
   "dependencies": {
-    "@electron/asar": "^3.2.5",
-    "@moonlight-mod/types": "workspace:*"
+    "@moonlight-mod/core": "workspace:*",
+    "@moonlight-mod/types": "workspace:*",
+    "nanotar": "^0.1.1"
   }
 }

packages/core-extensions/src/contextMenu/index.tsx

···
     find: "Menu API only allows Items and groups of Items as children.",
     replace: [
       {
-        match: /(?<=let{navId[^}]+?}=(.),(.)=.\(.\))/,
+        match:
+          /(?<=let{navId[^}]+?}=(.),(.)=function .\(.\){.+(?=,.=function))/,
         replacement: (_, props, items) =>
           `,__contextMenu=!${props}.__contextMenu_evilMenu&&require("contextMenu_contextMenu")._patchMenu(${props}, ${items})`
       }

packages/core-extensions/src/contextMenu/webpackModules/contextMenu.ts

···
 }
 
 export const patches: Patch[] = [];
-function _patchMenu(props: MenuProps, items: InternalItem[]) {
+export function _patchMenu(props: MenuProps, items: InternalItem[]) {
   const matches = patches.filter((p) => p.navId === props.navId);
   if (!matches.length) return;
 
···
 }
 
 let menuProps: any;
-function _saveProps(self: any, el: any) {
+export function _saveProps(self: any, el: any) {
   menuProps = el.props;
 
   const original = self.props.closeContextMenu;
···
 
   return el;
 }
-
-module.exports = {
-  addItem,
-  _patchMenu,
-  _saveProps
-};
 
 // Unmangle Menu elements
 const code =

packages/core-extensions/src/contextMenu/webpackModules/evilMenu.ts

···
       "Menu API only allows Items and groups of Items as children."
     )[0].id
   ].toString();
-code = code.replace(
-  /onSelect:(.)}=(.),.=(.\(.\)),/,
-  `onSelect:$1}=$2;return $3;let `
-);
+code = code.replace(/,.=(?=function .\(.\){.+?,.=function)/, ";return ");
+code = code.replace(/,(?=__contextMenu)/, ";let ");
 const mod = new Function(
   "module",
   "exports",
···
 );
 const exp: any = {};
 mod({}, exp, require);
-const Menu = spacepack.findFunctionByStrings(exp, "isUsingKeyboardNavigation")!;
+const Menu = spacepack.findFunctionByStrings(
+  exp,
+  "Menu API only allows Items and groups of Items as children."
+)!;
 module.exports = (el: any) => {
   return Menu({
     children: el,

packages/core-extensions/src/disableSentry/host.ts

···
 import { join } from "node:path";
 import { Module } from "node:module";
-import { BrowserWindow } from "electron";
 
 const logger = moonlightHost.getLogger("disableSentry");
 
···
     logger.error("Failed to stub Sentry host side:", err);
   }
 }
-
-moonlightHost.events.on("window-created", (window: BrowserWindow) => {
-  window.webContents.session.webRequest.onBeforeRequest(
-    {
-      urls: [
-        "https://*.sentry.io/*",
-        "https://*.discord.com/error-reporting-proxy/*",
-        "https://discord.com/assets/sentry.*.js",
-        "https://*.discord.com/assets/sentry.*.js"
-      ]
-    },
-    function (details, callback) {
-      callback({ cancel: true });
-    }
-  );
-});

packages/core-extensions/src/disableSentry/index.ts

···
     }
   },
   {
-    find: "window.DiscordSentry.addBreadcrumb",
+    find: "this._sentryUtils=",
     replace: {
       type: PatchReplaceType.Normal,
-      match: /Z:function\(\){return .}/,
-      replacement:
-        'default:function(){return (...args)=>{moonlight.getLogger("disableSentry").debug("Sentry calling addBreadcrumb passthrough:", ...args);}}'
+      match: /(?<=this._sentryUtils=)./,
+      replacement: "undefined"
     }
   },
   {

packages/core-extensions/src/disableSentry/manifest.json

···
     "tagline": "Turns off Discord's error reporting systems",
     "authors": ["Cynosphere", "NotNite"],
     "tags": ["privacy"]
-  }
+  },
+  "blocked": [
+    "https://*.sentry.io/*",
+    "https://*.discord.com/error-reporting-proxy/*",
+    "https://discord.com/assets/sentry.*.js",
+    "https://*.discord.com/assets/sentry.*.js"
+  ]
 }

packages/core-extensions/src/markdown/index.ts

···
           `=require("markdown_markdown")._addRules({newline:${rules}}),${RULES}=(0,`
       },
       {
-        match: /(?<=var (.{1,2})={RULES:.+?})/,
+        match: /(?<=;(.{1,2}\.Z)={RULES:.+?})/,
         replacement: (_, rulesets) =>
           `;require("markdown_markdown")._applyRulesetBlacklist(${rulesets});`
       }
···
       },
       {
         match:
-          /(originalMatch:.}=(.);)(.+?)case"emoticon":(return .+?;)(.+?)case"link":{(.+?)}default:/,
+          /(originalMatch:.}=(.);)(.+?)case"emoticon":(return .+?;)(.+?)case"subtext":{(.+?)}default:/,
         replacement: (
           _,
           start,

packages/core-extensions/src/moonbase/index.tsx

···
-import { ExtensionWebExports } from "@moonlight-mod/types";
+import { ExtensionWebpackModule } from "@moonlight-mod/types";
 
-export const webpackModules: ExtensionWebExports["webpackModules"] = {
+export const webpackModules: Record<string, ExtensionWebpackModule> = {
   stores: {
     dependencies: [
       { id: "discord/packages/flux" },
···
     ]
   },
 
-  moonbase: {
+  settings: {
     dependencies: [
       { ext: "spacepack", id: "spacepack" },
       { ext: "settings", id: "settings" },
···
       { ext: "moonbase", id: "ui" }
     ],
     entrypoint: true
+  },
+
+  updates: {
+    dependencies: [
+      { id: "react" },
+      { ext: "moonbase", id: "stores" },
+      { ext: "notices", id: "notices" },
+      {
+        ext: "spacepack",
+        id: "spacepack"
+      }
+    ],
+    entrypoint: true
+  },
+
+  moonbase: {
+    dependencies: [{ ext: "moonbase", id: "stores" }]
   }
 };
 
+const bg = "#222034";
+const fg = "#FFFBA6";
+
 export const styles = [
-  ".moonbase-settings > :first-child { margin-top: 0px; }",
-  "textarea.moonbase-resizeable  { resize: vertical }"
+  `
+.moonbase-settings > :first-child {
+  margin-top: 0px;
+}
+
+textarea.moonbase-resizeable {
+  resize: vertical
+}
+
+.moonbase-updates-notice {
+  background-color: ${bg};
+  color: ${fg};
+  line-height: unset;
+  height: 36px;
+}
+
+.moonbase-updates-notice button {
+  color: ${fg};
+  border-color: ${fg};
+}
+
+.moonbase-updates-notice_text-wrapper {
+  display: inline-flex;
+  align-items: center;
+  line-height: 36px;
+  gap: 2px;
+}
+
+.moonbase-update-section {
+  background-color: ${bg};
+  --info-help-foreground: ${fg};
+  border: none !important;
+  color: ${fg};
+
+  display: flex;
+  flex-direction: row;
+  justify-content: space-between;
+}
+
+.moonbase-update-section > button {
+  color: ${fg};
+  background-color: transparent;
+  border-color: ${fg};
+}
+`.trim()
 ];

packages/core-extensions/src/moonbase/manifest.json

···
   "meta": {
     "name": "Moonbase",
     "tagline": "The official settings UI for moonlight",
-    "authors": ["Cynosphere", "NotNite"]
+    "authors": ["Cynosphere", "NotNite", "redstonekasi"]
   },
-  "dependencies": ["spacepack", "settings", "common"],
+  "dependencies": ["spacepack", "settings", "common", "notices"],
   "settings": {
     "sections": {
       "displayName": "Split into sections",
···
       "displayName": "Persist filter",
       "description": "Save extension filter in config",
       "type": "boolean"
+    },
+    "updateChecking": {
+      "displayName": "Automatic update checking",
+      "description": "Checks for updates to moonlight",
+      "type": "boolean",
+      "default": "true"
+    },
+    "updateBanner": {
+      "displayName": "Show update banner",
+      "description": "Shows a banner for moonlight and extension updates",
+      "type": "boolean",
+      "default": "true"
     }
-  }
+  },
+  "cors": [
+    "https://github.com/moonlight-mod/moonlight/releases/download/",
+    "https://objects.githubusercontent.com/github-production-release-asset-"
+  ]
 }

packages/core-extensions/src/moonbase/native.ts

···
+import { MoonlightBranch } from "@moonlight-mod/types";
+import type { MoonbaseNatives, RepositoryManifest } from "./types";
+import extractAsar from "@moonlight-mod/core/asar";
+import {
+  distDir,
+  repoUrlFile,
+  installedVersionFile
+} from "@moonlight-mod/types/constants";
+import { parseTarGzip } from "nanotar";
+
+const githubRepo = "moonlight-mod/moonlight";
+const githubApiUrl = `https://api.github.com/repos/${githubRepo}/releases/latest`;
+const artifactName = "dist.tar.gz";
+
+const nightlyRefUrl = "https://moonlight-mod.github.io/moonlight/ref";
+const nightlyZipUrl = "https://moonlight-mod.github.io/moonlight/dist.tar.gz";
+
+export const userAgent = `moonlight/${moonlightNode.version} (https://github.com/moonlight-mod/moonlight)`;
+
+async function getStableRelease(): Promise<{
+  name: string;
+  assets: {
+    name: string;
+    browser_download_url: string;
+  }[];
+}> {
+  const req = await fetch(githubApiUrl, {
+    cache: "no-store",
+    headers: {
+      "User-Agent": userAgent
+    }
+  });
+  return await req.json();
+}
+
+export default function getNatives(): MoonbaseNatives {
+  const logger = moonlightNode.getLogger("moonbase/natives");
+
+  return {
+    async checkForMoonlightUpdate() {
+      try {
+        if (moonlightNode.branch === MoonlightBranch.STABLE) {
+          const json = await getStableRelease();
+          return json.name !== moonlightNode.version ? json.name : null;
+        } else if (moonlightNode.branch === MoonlightBranch.NIGHTLY) {
+          const req = await fetch(nightlyRefUrl, {
+            cache: "no-store",
+            headers: {
+              "User-Agent": userAgent
+            }
+          });
+          const ref = (await req.text()).split("\n")[0];
+          return ref !== moonlightNode.version ? ref : null;
+        }
+
+        return null;
+      } catch (e) {
+        logger.error("Error checking for moonlight update", e);
+        return null;
+      }
+    },
+
+    async updateMoonlight() {
+      // Note: this won't do anything on browser, we should probably disable it
+      // entirely when running in browser.
+      async function downloadStable(): Promise<[ArrayBuffer, string]> {
+        const json = await getStableRelease();
+        const asset = json.assets.find((a) => a.name === artifactName);
+        if (!asset) throw new Error("Artifact not found");
+
+        logger.debug(`Downloading ${asset.browser_download_url}`);
+        const req = await fetch(asset.browser_download_url, {
+          cache: "no-store",
+          headers: {
+            "User-Agent": userAgent
+          }
+        });
+
+        return [await req.arrayBuffer(), json.name];
+      }
+
+      async function downloadNightly(): Promise<[ArrayBuffer, string]> {
+        logger.debug(`Downloading ${nightlyZipUrl}`);
+        const zipReq = await fetch(nightlyZipUrl, {
+          cache: "no-store",
+          headers: {
+            "User-Agent": userAgent
+          }
+        });
+
+        const refReq = await fetch(nightlyRefUrl, {
+          cache: "no-store",
+          headers: {
+            "User-Agent": userAgent
+          }
+        });
+        const ref = (await refReq.text()).split("\n")[0];
+
+        return [await zipReq.arrayBuffer(), ref];
+      }
+
+      const [tar, ref] =
+        moonlightNode.branch === MoonlightBranch.STABLE
+          ? await downloadStable()
+          : moonlightNode.branch === MoonlightBranch.NIGHTLY
+            ? await downloadNightly()
+            : [null, null];
+
+      if (!tar || !ref) return;
+
+      const dist = moonlightFS.join(moonlightNode.getMoonlightDir(), distDir);
+      if (await moonlightFS.exists(dist)) await moonlightFS.rmdir(dist);
+      await moonlightFS.mkdir(dist);
+
+      logger.debug("Extracting update");
+      const files = await parseTarGzip(tar);
+      for (const file of files) {
+        if (!file.data) continue;
+        // @ts-expect-error What do you mean their own types are wrong
+        if (file.type !== "file") continue;
+
+        const fullFile = moonlightFS.join(dist, file.name);
+        const fullDir = moonlightFS.dirname(fullFile);
+        if (!(await moonlightFS.exists(fullDir)))
+          await moonlightFS.mkdir(fullDir);
+        await moonlightFS.writeFile(fullFile, file.data);
+      }
+
+      logger.debug("Writing version file:", ref);
+      const versionFile = moonlightFS.join(
+        moonlightNode.getMoonlightDir(),
+        installedVersionFile
+      );
+      await moonlightFS.writeFileString(versionFile, ref.trim());
+
+      logger.debug("Update extracted");
+    },
+
+    async fetchRepositories(repos) {
+      const ret: Record<string, RepositoryManifest[]> = {};
+
+      for (const repo of repos) {
+        try {
+          const req = await fetch(repo, {
+            cache: "no-store",
+            headers: {
+              "User-Agent": userAgent
+            }
+          });
+          const json = await req.json();
+          ret[repo] = json;
+        } catch (e) {
+          logger.error(`Error fetching repository ${repo}`, e);
+        }
+      }
+
+      return ret;
+    },
+
+    async installExtension(manifest, url, repo) {
+      const req = await fetch(url, {
+        headers: {
+          "User-Agent": userAgent
+        }
+      });
+
+      const dir = moonlightNode.getExtensionDir(manifest.id);
+      // remake it in case of updates
+      if (await moonlightFS.exists(dir)) await moonlightFS.rmdir(dir);
+      await moonlightFS.mkdir(dir);
+
+      const buffer = await req.arrayBuffer();
+      const files = extractAsar(buffer);
+      for (const [file, buf] of Object.entries(files)) {
+        const fullFile = moonlightFS.join(dir, file);
+        const fullDir = moonlightFS.dirname(fullFile);
+
+        if (!(await moonlightFS.exists(fullDir)))
+          await moonlightFS.mkdir(fullDir);
+        await moonlightFS.writeFile(moonlightFS.join(dir, file), buf);
+      }
+
+      await moonlightFS.writeFileString(
+        moonlightFS.join(dir, repoUrlFile),
+        repo
+      );
+    },
+
+    async deleteExtension(id) {
+      const dir = moonlightNode.getExtensionDir(id);
+      await moonlightFS.rmdir(dir);
+    },
+
+    getExtensionConfig(id, key) {
+      const config = moonlightNode.config.extensions[id];
+      if (typeof config === "object") {
+        return config.config?.[key];
+      }
+
+      return undefined;
+    }
+  };
+}

packages/core-extensions/src/moonbase/node.ts

···
-import { MoonbaseNatives, RepositoryManifest } from "./types";
-import asar from "@electron/asar";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { repoUrlFile } from "types/src/constants";
-
-const logger = moonlightNode.getLogger("moonbase");
-
-async function fetchRepositories(repos: string[]) {
-  const ret: Record<string, RepositoryManifest[]> = {};
-
-  for (const repo of repos) {
-    try {
-      const req = await fetch(repo);
-      const json = await req.json();
-      ret[repo] = json;
-    } catch (e) {
-      logger.error(`Error fetching repository ${repo}`, e);
-    }
-  }
-
-  return ret;
-}
-
-async function installExtension(
-  manifest: RepositoryManifest,
-  url: string,
-  repo: string
-) {
-  const req = await fetch(url);
-
-  const dir = moonlightNode.getExtensionDir(manifest.id);
-  // remake it in case of updates
-  if (fs.existsSync(dir)) fs.rmdirSync(dir, { recursive: true });
-  fs.mkdirSync(dir, { recursive: true });
-
-  // for some reason i just can't .writeFileSync() a file that ends in .asar???
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "moonlight-"));
-  const tempFile = path.join(tempDir, "extension");
-  const buffer = await req.arrayBuffer();
-  fs.writeFileSync(tempFile, Buffer.from(buffer));
-
-  asar.extractAll(tempFile, dir);
-  fs.writeFileSync(path.join(dir, repoUrlFile), repo);
-}
-
-async function deleteExtension(id: string) {
-  const dir = moonlightNode.getExtensionDir(id);
-  fs.rmdirSync(dir, { recursive: true });
-}
-
-function getExtensionConfig(id: string, key: string): any {
-  const config = moonlightNode.config.extensions[id];
-  if (typeof config === "object") {
-    return config.config?.[key];
-  }
-
-  return undefined;
-}
-
-const exports: MoonbaseNatives = {
-  fetchRepositories,
-  installExtension,
-  deleteExtension,
-  getExtensionConfig
-};
-
-module.exports = exports;
+import getNatives from "./native";
+module.exports = getNatives();

packages/core-extensions/src/moonbase/types.ts

···
-import { DetectedExtension, ExtensionManifest } from "types/src";
+import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";
+import { DetectedExtension, ExtensionManifest } from "@moonlight-mod/types";
 
 export type MoonbaseNatives = {
+  checkForMoonlightUpdate(): Promise<string | null>;
+  updateMoonlight(): Promise<void>;
+
   fetchRepositories(
     repos: string[]
   ): Promise<Record<string, RepositoryManifest[]>>;
···
   manifest: ExtensionManifest | RepositoryManifest;
   source: DetectedExtension["source"];
   state: ExtensionState;
+  compat: ExtensionCompat;
+  hasUpdate: boolean;
 };

packages/core-extensions/src/moonbase/webpackModules/moonbase.ts

···
+import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import type { Moonbase } from "@moonlight-mod/types/coreExtensions/moonbase";
+
+export const moonbase: Moonbase = {
+  registerConfigComponent(ext, option, component) {
+    MoonbaseSettingsStore.registerConfigComponent(ext, option, component);
+  }
+};
+
+export default moonbase;

packages/core-extensions/src/moonbase/webpackModules/moonbase.tsx

···
-import settings from "@moonlight-mod/wp/settings_settings";
-import React from "@moonlight-mod/wp/react";
-import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-import { Moonbase, pages } from "@moonlight-mod/wp/moonbase_ui";
-
-import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
-import { MenuItem } from "@moonlight-mod/wp/discord/components/common/index";
-
-const { open } = spacepack.findByExports("setSection", "clearSubsection")[0]
-  .exports.Z;
-
-settings.addSection("moonbase", "Moonbase", Moonbase, null, -2, {
-  stores: [MoonbaseSettingsStore],
-  element: () => {
-    // Require it here because lazy loading SUX
-    const SettingsNotice = spacepack.findByCode(
-      "onSaveButtonColor",
-      "FocusRingScope"
-    )[0].exports.Z;
-    return (
-      <SettingsNotice
-        submitting={MoonbaseSettingsStore.submitting}
-        onReset={() => {
-          MoonbaseSettingsStore.reset();
-        }}
-        onSave={() => {
-          MoonbaseSettingsStore.writeConfig();
-        }}
-      />
-    );
-  }
-});
-
-settings.addSectionMenuItems(
-  "moonbase",
-  ...pages.map((page, i) => (
-    <MenuItem
-      key={page.id}
-      id={`moonbase-${page.id}`}
-      label={page.name}
-      action={() => open("moonbase", i)}
-    />
-  ))
-);

packages/core-extensions/src/moonbase/webpackModules/settings.tsx

···
+import settings from "@moonlight-mod/wp/settings_settings";
+import React from "@moonlight-mod/wp/react";
+import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
+import { Moonbase, pages } from "@moonlight-mod/wp/moonbase_ui";
+
+import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+
+import Update from "./ui/update";
+
+const { MenuItem, Text, Breadcrumbs } = Components;
+
+const Margins = spacepack.require("discord/styles/shared/Margins.css");
+
+const { open } = spacepack.findByExports("setSection", "clearSubsection")[0]
+  .exports.Z;
+
+const notice = {
+  stores: [MoonbaseSettingsStore],
+  element: () => {
+    // Require it here because lazy loading SUX
+    const SettingsNotice = spacepack.findByCode(
+      "onSaveButtonColor",
+      "FocusRingScope"
+    )[0].exports.Z;
+    return (
+      <SettingsNotice
+        submitting={MoonbaseSettingsStore.submitting}
+        onReset={() => {
+          MoonbaseSettingsStore.reset();
+        }}
+        onSave={() => {
+          MoonbaseSettingsStore.writeConfig();
+        }}
+      />
+    );
+  }
+};
+
+function addSection(
+  id: string,
+  name: string,
+  element: React.FunctionComponent
+) {
+  settings.addSection(`moonbase-${id}`, name, element, null, -2, notice);
+}
+
+// FIXME: move to component types
+type Breadcrumb = {
+  id: string;
+  label: string;
+};
+
+function renderBreadcrumb(crumb: Breadcrumb, last: boolean) {
+  return (
+    <Text
+      variant="heading-lg/semibold"
+      tag="h2"
+      color={last ? "header-primary" : "header-secondary"}
+    >
+      {crumb.label}
+    </Text>
+  );
+}
+
+if (
+  MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(
+    "moonbase",
+    "sections",
+    false
+  )
+) {
+  settings.addHeader("Moonbase", -2);
+
+  for (const page of pages) {
+    addSection(page.id, page.name, () => {
+      const breadcrumbs = [
+        { id: "moonbase", label: "Moonbase" },
+        { id: page.id, label: page.name }
+      ];
+      return (
+        <>
+          <Breadcrumbs
+            className={Margins.marginBottom20}
+            renderCustomBreadcrumb={renderBreadcrumb}
+            breadcrumbs={breadcrumbs}
+            activeId={page.id}
+          >
+            {page.name}
+          </Breadcrumbs>
+
+          <Update />
+
+          <page.element />
+        </>
+      );
+    });
+  }
+} else {
+  settings.addSection("moonbase", "Moonbase", Moonbase, null, -2, notice);
+
+  settings.addSectionMenuItems(
+    "moonbase",
+    ...pages.map((page, i) => (
+      <MenuItem
+        key={page.id}
+        id={`moonbase-${page.id}`}
+        label={page.name}
+        action={() => open("moonbase", i)}
+      />
+    ))
+  );
+}

packages/core-extensions/src/moonbase/webpackModules/stores.ts

···
 import { Config, ExtensionLoadSource } from "@moonlight-mod/types";
-import { ExtensionState, MoonbaseExtension, MoonbaseNatives } from "../types";
+import {
+  ExtensionState,
+  MoonbaseExtension,
+  MoonbaseNatives,
+  RepositoryManifest
+} from "../types";
 import { Store } from "@moonlight-mod/wp/discord/packages/flux";
 import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";
+import getNatives from "../native";
+import { mainRepo } from "@moonlight-mod/types/constants";
+import {
+  checkExtensionCompat,
+  ExtensionCompat
+} from "@moonlight-mod/core/extension/loader";
+import { CustomComponent } from "@moonlight-mod/types/coreExtensions/moonbase";
 
-const natives: MoonbaseNatives = moonlight.getNatives("moonbase");
 const logger = moonlight.getLogger("moonbase");
 
+let natives: MoonbaseNatives = moonlight.getNatives("moonbase");
+if (moonlightNode.isBrowser) natives = getNatives();
+
 class MoonbaseSettingsStore extends Store<any> {
   private origConfig: Config;
   private config: Config;
   private extensionIndex: number;
+  private configComponents: Record<string, Record<string, CustomComponent>> =
+    {};
 
   modified: boolean;
   submitting: boolean;
   installing: boolean;
+
+  newVersion: string | null;
+  shouldShowNotice: boolean;
 
   extensions: { [id: number]: MoonbaseExtension };
-  updates: { [id: number]: { version: string; download: string } };
+  updates: {
+    [id: number]: {
+      version: string;
+      download: string;
+      updateManifest: RepositoryManifest;
+    };
+  };
 
   constructor() {
     super(Dispatcher);
···
     this.modified = false;
     this.submitting = false;
     this.installing = false;
+
+    this.newVersion = null;
+    this.shouldShowNotice = false;
 
     this.extensions = {};
     this.updates = {};
···
         uniqueId,
         state: moonlight.enabledExtensions.has(ext.id)
           ? ExtensionState.Enabled
-          : ExtensionState.Disabled
+          : ExtensionState.Disabled,
+        compat: checkExtensionCompat(ext.manifest),
+        hasUpdate: false
       };
     }
 
-    natives.fetchRepositories(this.config.repositories).then((ret) => {
-      for (const [repo, exts] of Object.entries(ret)) {
-        try {
-          for (const ext of exts) {
-            const level = ext.apiLevel ?? 1;
-            if (level !== window.moonlight.apiLevel) continue;
+    natives!
+      .fetchRepositories(this.config.repositories)
+      .then((ret) => {
+        for (const [repo, exts] of Object.entries(ret)) {
+          try {
+            for (const ext of exts) {
+              const uniqueId = this.extensionIndex++;
+              const extensionData = {
+                id: ext.id,
+                uniqueId,
+                manifest: ext,
+                source: { type: ExtensionLoadSource.Normal, url: repo },
+                state: ExtensionState.NotDownloaded,
+                compat: ExtensionCompat.Compatible,
+                hasUpdate: false
+              };
 
-            const uniqueId = this.extensionIndex++;
-            const extensionData = {
-              id: ext.id,
-              uniqueId,
-              manifest: ext,
-              source: { type: ExtensionLoadSource.Normal, url: repo },
-              state: ExtensionState.NotDownloaded
-            };
+              // Don't present incompatible updates
+              if (checkExtensionCompat(ext) !== ExtensionCompat.Compatible)
+                continue;
+
+              const existing = this.getExisting(extensionData);
+              if (existing != null) {
+                // Make sure the download URL is properly updated
+                for (const [id, e] of Object.entries(this.extensions)) {
+                  if (e.id === ext.id && e.source.url === repo) {
+                    this.extensions[parseInt(id)].manifest = {
+                      ...e.manifest,
+                      download: ext.download
+                    };
+                    break;
+                  }
+                }
+
+                if (this.hasUpdate(extensionData)) {
+                  this.updates[existing.uniqueId] = {
+                    version: ext.version!,
+                    download: ext.download,
+                    updateManifest: ext
+                  };
+                  existing.hasUpdate = true;
+                }
 
-            if (this.alreadyExists(extensionData)) {
-              if (this.hasUpdate(extensionData)) {
-                this.updates[uniqueId] = {
-                  version: ext.version!,
-                  download: ext.download
-                };
+                continue;
               }
 
-              continue;
+              this.extensions[uniqueId] = extensionData;
             }
-
-            this.extensions[uniqueId] = extensionData;
+          } catch (e) {
+            logger.error(`Error processing repository ${repo}`, e);
           }
-        } catch (e) {
-          logger.error(`Error processing repository ${repo}`, e);
         }
-      }
 
-      this.emitChange();
-    });
+        this.emitChange();
+      })
+      .then(() =>
+        this.getExtensionConfigRaw("moonbase", "updateChecking", true)
+          ? natives!.checkForMoonlightUpdate()
+          : new Promise<null>((resolve) => resolve(null))
+      )
+      .then((version) => {
+        this.newVersion = version;
+        this.emitChange();
+      })
+      .then(() => {
+        this.shouldShowNotice =
+          this.newVersion != null || Object.keys(this.updates).length > 0;
+        this.emitChange();
+      });
   }
 
-  private alreadyExists(ext: MoonbaseExtension) {
-    return Object.values(this.extensions).some(
+  private getExisting(ext: MoonbaseExtension) {
+    return Object.values(this.extensions).find(
       (e) => e.id === ext.id && e.source.url === ext.source.url
     );
   }
···
     return cfg.config?.[key] ?? clonedDefaultValue;
   }
 
+  getExtensionConfigRaw<T>(
+    id: string,
+    key: string,
+    defaultValue: T | undefined
+  ): T | undefined {
+    const cfg = this.config.extensions[id];
+
+    if (cfg == null || typeof cfg === "boolean") return defaultValue;
+    return cfg.config?.[key] ?? defaultValue;
+  }
+
   getExtensionConfigName(uniqueId: number, key: string) {
     const ext = this.getExtension(uniqueId);
     return ext.manifest.settings?.[key]?.displayName ?? key;
···
     return ext.manifest.settings?.[key]?.description;
   }
 
-  setExtensionConfig(uniqueId: number, key: string, value: any) {
-    const ext = this.getExtension(uniqueId);
-    const oldConfig = this.config.extensions[ext.id];
+  setExtensionConfig(id: string, key: string, value: any) {
+    const oldConfig = this.config.extensions[id];
     const newConfig =
       typeof oldConfig === "boolean"
         ? {
···
             config: { ...(oldConfig?.config ?? {}), [key]: value }
           };
 
-    this.config.extensions[ext.id] = newConfig;
+    this.config.extensions[id] = newConfig;
     this.modified = this.isModified();
     this.emitChange();
   }
···
 
     this.installing = true;
     try {
-      const url = this.updates[uniqueId]?.download ?? ext.manifest.download;
-      await natives.installExtension(ext.manifest, url, ext.source.url!);
+      const update = this.updates[uniqueId];
+      const url = update?.download ?? ext.manifest.download;
+      await natives!.installExtension(ext.manifest, url, ext.source.url!);
       if (ext.state === ExtensionState.NotDownloaded) {
         this.extensions[uniqueId].state = ExtensionState.Disabled;
       }
 
+      if (update != null)
+        this.extensions[uniqueId].compat = checkExtensionCompat(
+          update.updateManifest
+        );
+
       delete this.updates[uniqueId];
     } catch (e) {
       logger.error("Error installing extension:", e);
···
     this.emitChange();
   }
 
+  private getRank(ext: MoonbaseExtension) {
+    if (ext.source.type === ExtensionLoadSource.Developer) return 3;
+    if (ext.source.type === ExtensionLoadSource.Core) return 2;
+    if (ext.source.url === mainRepo) return 1;
+    return 0;
+  }
+
+  async getDependencies(uniqueId: number) {
+    const ext = this.getExtension(uniqueId);
+
+    const missingDeps = [];
+    for (const dep of ext.manifest.dependencies ?? []) {
+      const anyInstalled = Object.values(this.extensions).some(
+        (e) => e.id === dep && e.state !== ExtensionState.NotDownloaded
+      );
+      if (!anyInstalled) missingDeps.push(dep);
+    }
+
+    if (missingDeps.length === 0) return null;
+
+    const deps: Record<string, MoonbaseExtension[]> = {};
+    for (const dep of missingDeps) {
+      const candidates = Object.values(this.extensions).filter(
+        (e) => e.id === dep
+      );
+
+      deps[dep] = candidates.sort((a, b) => {
+        const aRank = this.getRank(a);
+        const bRank = this.getRank(b);
+        if (aRank === bRank) {
+          const repoIndex = this.config.repositories.indexOf(a.source.url!);
+          const otherRepoIndex = this.config.repositories.indexOf(
+            b.source.url!
+          );
+          return repoIndex - otherRepoIndex;
+        } else {
+          return bRank - aRank;
+        }
+      });
+    }
+
+    return deps;
+  }
+
   async deleteExtension(uniqueId: number) {
     const ext = this.getExtension(uniqueId);
     if (ext == null) return;
 
     this.installing = true;
     try {
-      await natives.deleteExtension(ext.id);
+      await natives!.deleteExtension(ext.id);
       this.extensions[uniqueId].state = ExtensionState.NotDownloaded;
     } catch (e) {
       logger.error("Error deleting extension:", e);
···
     this.emitChange();
   }
 
+  async updateMoonlight() {
+    await natives.updateMoonlight();
+  }
+
   getConfigOption<K extends keyof Config>(key: K): Config[K] {
     return this.config[key];
   }
···
     this.emitChange();
   }
 
+  tryGetExtensionName(id: string) {
+    const uniqueId = this.getExtensionUniqueId(id);
+    return (uniqueId != null ? this.getExtensionName(uniqueId) : null) ?? id;
+  }
+
+  registerConfigComponent(
+    ext: string,
+    name: string,
+    component: CustomComponent
+  ) {
+    if (!(ext in this.configComponents)) this.configComponents[ext] = {};
+    this.configComponents[ext][name] = component;
+  }
+
+  getExtensionConfigComponent(ext: string, name: string) {
+    return this.configComponents[ext]?.[name];
+  }
+
   writeConfig() {
     this.submitting = true;
 
-    try {
-      moonlightNode.writeConfig(this.config);
-      this.origConfig = this.clone(this.config);
-    } catch (e) {
-      logger.error("Error writing config", e);
-    }
+    moonlightNode.writeConfig(this.config);
+    this.origConfig = this.clone(this.config);
 
     this.submitting = false;
     this.modified = false;

packages/core-extensions/src/moonbase/webpackModules/ui/config/index.tsx

···
 export default function ConfigPage() {
   return (
     <>
+      <FormSwitch
+        className={Margins.marginTop20}
+        value={MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(
+          "moonbase",
+          "updateChecking",
+          true
+        )}
+        onChange={(value: boolean) => {
+          MoonbaseSettingsStore.setExtensionConfig(
+            "moonbase",
+            "updateChecking",
+            value
+          );
+        }}
+        note="Checks for updates to moonlight"
+      >
+        Automatic update checking
+      </FormSwitch>
       <FormItem title="Repositories">
         <FormText className={Margins.marginBottom4}>
           A list of remote repositories to display extensions from

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/card.tsx

···
 import { ExtensionState } from "../../../types";
 import { ExtensionLoadSource } from "@moonlight-mod/types";
+import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";
 
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
 import * as Components from "@moonlight-mod/wp/discord/components/common/index";
···
 
 import ExtensionInfo from "./info";
 import Settings from "./settings";
+import installWithDependencyPopup from "./popup";
 
 export enum ExtensionPage {
   Info,
···
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
 
-const { DownloadIcon, TrashIcon, CircleWarningIcon } = Components;
+const { BeakerIcon, DownloadIcon, TrashIcon, CircleWarningIcon, Tooltip } =
+  Components;
 
 const PanelButton = spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.Z;
 const TabBarClasses = spacepack.findByExports(
···
   "tabBarItem",
   "headerContentWrapper"
 )[0].exports;
+const MarkupClasses = spacepack.findByExports("markup", "inlineFormat")[0]
+  .exports;
+
+const BuildOverrideClasses = spacepack.findByExports(
+  "disabledButtonOverride"
+)[0].exports;
+
+const COMPAT_TEXT_MAP: Record<ExtensionCompat, string> = {
+  [ExtensionCompat.Compatible]: "huh?",
+  [ExtensionCompat.InvalidApiLevel]: "Incompatible API level",
+  [ExtensionCompat.InvalidEnvironment]: "Incompatible platform"
+};
 
 export default function ExtensionCard({ uniqueId }: { uniqueId: number }) {
   const [tab, setTab] = React.useState(ExtensionPage.Info);
···
   // Why it work like that :sob:
   if (ext == null) return <></>;
 
-  const { Card, Text, Switch, TabBar, Button } = Components;
+  const { Card, Text, FormSwitch, TabBar, Button } = Components;
 
   const tagline = ext.manifest?.meta?.tagline;
   const settings = ext.manifest?.settings;
   const description = ext.manifest?.meta?.description;
+  const enabledDependants = useStateFromStores([MoonbaseSettingsStore], () =>
+    Object.keys(MoonbaseSettingsStore.extensions)
+      .filter((uniqueId) => {
+        const potentialDependant = MoonbaseSettingsStore.getExtension(
+          parseInt(uniqueId)
+        );
+
+        return (
+          potentialDependant.manifest.dependencies?.includes(ext.id) &&
+          MoonbaseSettingsStore.getExtensionEnabled(parseInt(uniqueId))
+        );
+      })
+      .map((a) => MoonbaseSettingsStore.getExtension(parseInt(a)))
+  );
+  const implicitlyEnabled = enabledDependants.length > 0;
 
   return (
     <Card editable={true} className={IntegrationCard.card}>
       <div className={IntegrationCard.cardHeader}>
         <Flex direction={Flex.Direction.VERTICAL}>
-          <Flex direction={Flex.Direction.HORIZONTAL}>
+          <Flex direction={Flex.Direction.HORIZONTAL} align={Flex.Align.CENTER}>
             <Text variant="text-md/semibold">
               {ext.manifest?.meta?.name ?? ext.id}
             </Text>
+            {ext.source.type === ExtensionLoadSource.Developer && (
+              <Tooltip text="This is a local extension" position="top">
+                {(props: any) => (
+                  <BeakerIcon
+                    {...props}
+                    class={BuildOverrideClasses.infoIcon}
+                    size="xs"
+                  />
+                )}
+              </Tooltip>
+            )}
           </Flex>
 
           {tagline != null && (
···
           justify={Flex.Justify.END}
         >
           {ext.state === ExtensionState.NotDownloaded ? (
-            <Button
-              color={Button.Colors.BRAND}
-              submitting={busy}
-              disabled={conflicting}
-              onClick={() => {
-                MoonbaseSettingsStore.installExtension(uniqueId);
-              }}
+            <Tooltip
+              text={COMPAT_TEXT_MAP[ext.compat]}
+              shouldShow={ext.compat !== ExtensionCompat.Compatible}
             >
-              Install
-            </Button>
+              {(props: any) => (
+                <Button
+                  {...props}
+                  color={Button.Colors.BRAND}
+                  submitting={busy}
+                  disabled={
+                    ext.compat !== ExtensionCompat.Compatible || conflicting
+                  }
+                  onClick={async () => {
+                    await installWithDependencyPopup(uniqueId);
+                  }}
+                >
+                  Install
+                </Button>
+              )}
+            </Tooltip>
           ) : (
             <div
               // too lazy to learn how <Flex /> works lmao
···
                 />
               )}
 
-              <Switch
-                checked={enabled}
+              <FormSwitch
+                value={
+                  ext.compat === ExtensionCompat.Compatible &&
+                  (enabled || implicitlyEnabled)
+                }
+                disabled={
+                  implicitlyEnabled || ext.compat !== ExtensionCompat.Compatible
+                }
+                hideBorder={true}
+                style={{ marginBottom: "0px" }}
+                tooltipNote={
+                  ext.compat !== ExtensionCompat.Compatible
+                    ? COMPAT_TEXT_MAP[ext.compat]
+                    : implicitlyEnabled
+                      ? `This extension is a dependency of the following enabled extension${
+                          enabledDependants.length > 1 ? "s" : ""
+                        }: ${enabledDependants
+                          .map((a) => a.manifest.meta?.name ?? a.id)
+                          .join(", ")}`
+                      : undefined
+                }
                 onChange={() => {
                   setRestartNeeded(true);
                   MoonbaseSettingsStore.setExtensionEnabled(uniqueId, !enabled);
···
         >
           {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}
           {tab === ExtensionPage.Description && (
-            <Text variant="text-md/normal">
-              {MarkupUtils.parse(description ?? "*No description*")}
+            <Text
+              variant="text-md/normal"
+              class={MarkupClasses.markup}
+              style={{ width: "100%" }}
+            >
+              {MarkupUtils.parse(description ?? "*No description*", true, {
+                allowHeading: true,
+                allowLinks: true,
+                allowList: true
+              })}
             </Text>
           )}
           {tab === ExtensionPage.Settings && <Settings ext={ext} />}

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/filterBar.tsx

···
   Enabled = 1 << 3,
   Disabled = 1 << 4,
   Installed = 1 << 5,
-  Repository = 1 << 6
+  Repository = 1 << 6,
+  Incompatible = 1 << 7
 }
-export const defaultFilter = ~(~0 << 7);
+export const defaultFilter = 127 as Filter;
 
 const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;
 const SortMenuClasses = spacepack.findByCode("container:", "clearText:")[0]
···
           />
         </MenuGroup>
         <MenuGroup>
+          <MenuCheckboxItem
+            id="l-incompatible"
+            label="Show incompatible"
+            checked={filter & Filter.Incompatible}
+            action={() => toggleFilter(Filter.Incompatible)}
+          />
           <MenuItem
             id="reset-all"
             className={SortMenuClasses.clearText}

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/index.tsx

···
 import { useStateFromStoresObject } from "@moonlight-mod/wp/discord/packages/flux";
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";
 
 const SearchBar: any = Object.values(
   spacepack.findByCode("Messages.SEARCH", "hideSearchIcon")[0].exports
 )[0];
 
 export default function ExtensionsPage() {
-  const moonbaseId = MoonbaseSettingsStore.getExtensionUniqueId("moonbase")!;
   const { extensions, savedFilter } = useStateFromStoresObject(
     [MoonbaseSettingsStore],
     () => {
       return {
         extensions: MoonbaseSettingsStore.extensions,
-        savedFilter: MoonbaseSettingsStore.getExtensionConfig(
-          moonbaseId,
-          "filter"
+        savedFilter: MoonbaseSettingsStore.getExtensionConfigRaw<number>(
+          "moonbase",
+          "filter",
+          defaultFilter
         )
       };
     }
···
   const [query, setQuery] = React.useState("");
 
   let filter: Filter, setFilter: (filter: Filter) => void;
-  if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {
+  if (
+    MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(
+      "moonbase",
+      "saveFilter",
+      false
+    )
+  ) {
     filter = savedFilter ?? defaultFilter;
     setFilter = (filter) =>
-      MoonbaseSettingsStore.setExtensionConfig(moonbaseId, "filter", filter);
+      MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);
   } else {
     const state = React.useState(defaultFilter);
     filter = state[0];
···
 
   const filtered = sorted.filter(
     (ext) =>
-      (ext.manifest.meta?.name?.toLowerCase().includes(query) ||
+      (query === "" ||
+        ext.manifest.id?.toLowerCase().includes(query) ||
+        ext.manifest.meta?.name?.toLowerCase().includes(query) ||
         ext.manifest.meta?.tagline?.toLowerCase().includes(query) ||
         ext.manifest.meta?.description?.toLowerCase().includes(query)) &&
       [...selectedTags.values()].every(
···
           ext.state !== ExtensionState.NotDownloaded) ||
         (!(filter & Filter.Repository) &&
           ext.state === ExtensionState.NotDownloaded)
-      )
+      ) &&
+      (filter & Filter.Incompatible ||
+        ext.compat === ExtensionCompat.Compatible ||
+        (ext.compat === ExtensionCompat.InvalidApiLevel && ext.hasUpdate))
   );
 
   return (
···
         setSelectedTags={setSelectedTags}
       />
       {filtered.map((ext) => (
-        <ExtensionCard uniqueId={ext.uniqueId} key={ext.id} />
+        <ExtensionCard uniqueId={ext.uniqueId} key={ext.uniqueId} />
       ))}
     </>
   );

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/info.tsx

···
               [DependencyType.Incompatible]: "var(--red-400)"
             };
             const color = colors[dep.type];
-            const id = MoonbaseSettingsStore.getExtensionUniqueId(dep.id);
-            const name =
-              (id !== null
-                ? MoonbaseSettingsStore.getExtensionName(id!)
-                : null) ?? dep.id;
+            const name = MoonbaseSettingsStore.tryGetExtensionName(dep.id);
+
             return (
               <Badge color={color} key={dep.id}>
                 {name}

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/popup.tsx

···
+// TODO: clean up the styling here
+import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
+import React from "@moonlight-mod/wp/react";
+import { MoonbaseExtension } from "core-extensions/src/moonbase/types";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import { ExtensionLoadSource } from "@moonlight-mod/types";
+import Flex from "@moonlight-mod/wp/discord/uikit/Flex";
+
+const {
+  openModalLazy,
+  closeModal
+} = require("@moonlight-mod/wp/discord/components/common/index");
+const Popup = spacepack.findByCode(".minorContainer", "secondaryAction")[0]
+  .exports.default;
+
+const presentableLoadSources: Record<ExtensionLoadSource, string> = {
+  [ExtensionLoadSource.Developer]: "Local extension", // should never show up
+  [ExtensionLoadSource.Core]: "Core extension",
+  [ExtensionLoadSource.Normal]: "Extension repository"
+};
+
+function ExtensionSelect({
+  id,
+  candidates,
+  option,
+  setOption
+}: {
+  id: string;
+  candidates: MoonbaseExtension[];
+  option: string | undefined;
+  setOption: (pick: string | undefined) => void;
+}) {
+  const { SingleSelect } = Components;
+
+  return (
+    <SingleSelect
+      key={id}
+      autofocus={false}
+      value={option}
+      options={candidates.map((candidate) => {
+        return {
+          value: candidate.uniqueId.toString(),
+          label:
+            candidate.source.url ??
+            presentableLoadSources[candidate.source.type] ??
+            candidate.manifest.version ??
+            ""
+        };
+      })}
+      onChange={(value: string) => {
+        setOption(value);
+      }}
+      // @ts-expect-error no thanks
+      placeholder="Missing extension"
+    />
+  );
+}
+
+function OurPopup({
+  deps,
+  transitionState,
+  id
+}: {
+  deps: Record<string, MoonbaseExtension[]>;
+  transitionState: number | null;
+  id: string;
+}) {
+  const { Text } = Components;
+
+  const amountNotAvailable = Object.values(deps).filter(
+    (candidates) => candidates.length === 0
+  ).length;
+
+  const [options, setOptions] = React.useState<
+    Record<string, string | undefined>
+  >(
+    Object.fromEntries(
+      Object.entries(deps).map(([id, candidates]) => [
+        id,
+        candidates.length > 0 ? candidates[0].uniqueId.toString() : undefined
+      ])
+    )
+  );
+
+  return (
+    <Popup
+      body={
+        <Flex
+          style={{
+            gap: "20px"
+          }}
+          direction={Flex.Direction.VERTICAL}
+        >
+          <Text variant="text-md/normal">
+            This extension depends on other extensions which are not downloaded.
+            Choose which extensions to download.
+          </Text>
+
+          {amountNotAvailable > 0 && (
+            <Text variant="text-md/normal">
+              {amountNotAvailable} extension
+              {amountNotAvailable > 1 ? "s" : ""} could not be found, and must
+              be installed manually.
+            </Text>
+          )}
+
+          <div
+            style={{
+              display: "grid",
+              gridTemplateColumns: "1fr 2fr",
+              gap: "10px"
+            }}
+          >
+            {Object.entries(deps).map(([id, candidates], i) => (
+              <>
+                <Text
+                  variant="text-md/normal"
+                  style={{
+                    alignSelf: "center",
+                    wordBreak: "break-word"
+                  }}
+                >
+                  {MoonbaseSettingsStore.tryGetExtensionName(id)}
+                </Text>
+
+                <ExtensionSelect
+                  id={id}
+                  candidates={candidates}
+                  option={options[id]}
+                  setOption={(pick) =>
+                    setOptions((prev) => ({
+                      ...prev,
+                      [id]: pick
+                    }))
+                  }
+                />
+              </>
+            ))}
+          </div>
+        </Flex>
+      }
+      cancelText="Cancel"
+      confirmText="Install"
+      onCancel={() => {
+        closeModal(id);
+      }}
+      onConfirm={() => {
+        closeModal(id);
+
+        for (const pick of Object.values(options)) {
+          if (pick != null) {
+            MoonbaseSettingsStore.installExtension(parseInt(pick));
+          }
+        }
+      }}
+      title="Extension dependencies"
+      transitionState={transitionState}
+    />
+  );
+}
+
+export async function doPopup(deps: Record<string, MoonbaseExtension[]>) {
+  const id: string = await openModalLazy(async () => {
+    // eslint-disable-next-line react/display-name
+    return ({ transitionState }: { transitionState: number | null }) => {
+      return <OurPopup transitionState={transitionState} deps={deps} id={id} />;
+    };
+  });
+}
+
+export default async function installWithDependencyPopup(uniqueId: number) {
+  await MoonbaseSettingsStore.installExtension(uniqueId);
+  const deps = await MoonbaseSettingsStore.getDependencies(uniqueId);
+  if (deps != null) {
+    await doPopup(deps);
+  }
+}

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/settings.tsx

···
       hideBorder={true}
       disabled={disabled}
       onChange={(value: boolean) => {
-        MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);
+        MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);
       }}
       note={description}
       className={`${Margins.marginReset} ${Margins.marginTop20}`}
···
         maxValue={castedSetting.max ?? 100}
         onValueChange={(value: number) => {
           const rounded = Math.max(min, Math.min(max, Math.round(value)));
-          MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, rounded);
+          MoonbaseSettingsStore.setExtensionConfig(ext.id, name, rounded);
         }}
       />
     </FormItem>
···
         value={value ?? ""}
         onChange={(value: string) => {
           if (disabled) return;
-          MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);
+          MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);
         }}
       />
     </FormItem>
···
         className={"moonbase-resizeable"}
         onChange={(value: string) => {
           if (disabled) return;
-          MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);
+          MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);
         }}
       />
     </FormItem>
···
         )}
         onChange={(value: string) => {
           if (disabled) return;
-          MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);
+          MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);
         }}
       />
     </FormItem>
···
           onChange: (value: string) => {
             if (disabled) return;
             MoonbaseSettingsStore.setExtensionConfig(
-              ext.uniqueId,
+              ext.id,
               name,
               Array.from(value)
             );
···
 
   const entries = value ?? [];
   const updateConfig = () =>
-    MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, entries);
+    MoonbaseSettingsStore.setExtensionConfig(ext.id, name, entries);
 
   return (
     <FormItem className={Margins.marginTop20} title={displayName}>
···
   const entries = Object.entries(value ?? {});
   const updateConfig = () =>
     MoonbaseSettingsStore.setExtensionConfig(
-      ext.uniqueId,
+      ext.id,
       name,
       Object.fromEntries(entries)
     );
···
   );
 }
 
+function Custom({ ext, name, setting, disabled }: SettingsProps) {
+  const { value, displayName } = useConfigEntry<any>(ext.uniqueId, name);
+
+  const { component: Component } = useStateFromStores(
+    [MoonbaseSettingsStore],
+    () => {
+      return {
+        component: MoonbaseSettingsStore.getExtensionConfigComponent(
+          ext.id,
+          name
+        )
+      };
+    },
+    [ext.uniqueId, name]
+  );
+
+  if (Component == null) {
+    const { Text } = Components;
+    return (
+      <Text variant="text/md/normal">{`Custom setting "${displayName}" is missing a component. Perhaps the extension is not installed?`}</Text>
+    );
+  }
+
+  return (
+    <Component
+      value={value}
+      setValue={(value) =>
+        MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value)
+      }
+    />
+  );
+}
+
 function Setting({ ext, name, setting, disabled }: SettingsProps) {
   const elements: Partial<Record<ExtensionSettingType, SettingsComponent>> = {
     [ExtensionSettingType.Boolean]: Boolean,
···
     [ExtensionSettingType.Select]: Select,
     [ExtensionSettingType.MultiSelect]: MultiSelect,
     [ExtensionSettingType.List]: List,
-    [ExtensionSettingType.Dictionary]: Dictionary
+    [ExtensionSettingType.Dictionary]: Dictionary,
+    [ExtensionSettingType.Custom]: Custom
   };
   const element = elements[setting.type];
   if (element == null) return <></>;

packages/core-extensions/src/moonbase/webpackModules/ui/index.tsx

···
 
 import ExtensionsPage from "./extensions";
 import ConfigPage from "./config";
+import Update from "./update";
 
 const { Divider } = spacepack.findByCode(".forumOrHome]:")[0].exports.Z;
 const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0]
···
           ))}
         </TabBar>
       </div>
+
+      <Update />
 
       {React.createElement(pages[subsection].element)}
     </>

packages/core-extensions/src/moonbase/webpackModules/ui/update.tsx

···
+import { useStateFromStores } from "@moonlight-mod/wp/discord/packages/flux";
+import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+import React from "@moonlight-mod/wp/react";
+import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
+import Flex from "@moonlight-mod/wp/discord/uikit/Flex";
+
+enum UpdateState {
+  Ready,
+  Working,
+  Installed,
+  Failed
+}
+
+const { ThemeDarkIcon, Text, Button } = Components;
+const Margins = spacepack.require("discord/styles/shared/Margins.css");
+const HelpMessageClasses = spacepack.findByExports("positive", "iconDiv")[0]
+  .exports;
+
+const logger = moonlight.getLogger("moonbase/ui/update");
+
+const strings: Record<UpdateState, string> = {
+  [UpdateState.Ready]: "A new version of moonlight is available.",
+  [UpdateState.Working]: "Updating moonlight...",
+  [UpdateState.Installed]: "Updated. Restart Discord to apply changes.",
+  [UpdateState.Failed]:
+    "Failed to update moonlight. Please use the installer instead."
+};
+
+export default function Update() {
+  const [state, setState] = React.useState(UpdateState.Ready);
+  const newVersion = useStateFromStores(
+    [MoonbaseSettingsStore],
+    () => MoonbaseSettingsStore.newVersion
+  );
+
+  if (newVersion == null) return null;
+
+  // reimpl of HelpMessage but with a custom icon
+  return (
+    <div
+      className={`${Margins.marginBottom20} ${HelpMessageClasses.info} ${HelpMessageClasses.container} moonbase-update-section`}
+    >
+      <Flex direction={Flex.Direction.HORIZONTAL}>
+        <div
+          className={HelpMessageClasses.iconDiv}
+          style={{
+            alignItems: "center"
+          }}
+        >
+          <ThemeDarkIcon
+            size="sm"
+            color="currentColor"
+            className={HelpMessageClasses.icon}
+          />
+        </div>
+
+        <Text
+          variant="text-sm/medium"
+          color="currentColor"
+          className={HelpMessageClasses.text}
+        >
+          {strings[state]}
+        </Text>
+      </Flex>
+
+      <Button
+        look={Button.Looks.OUTLINED}
+        color={Button.Colors.CUSTOM}
+        size={Button.Sizes.TINY}
+        disabled={state !== UpdateState.Ready}
+        onClick={() => {
+          setState(UpdateState.Working);
+
+          MoonbaseSettingsStore.updateMoonlight()
+            .then(() => setState(UpdateState.Installed))
+            .catch((e) => {
+              logger.error(e);
+              setState(UpdateState.Failed);
+            });
+        }}
+      >
+        Update
+      </Button>
+    </div>
+  );
+}

packages/core-extensions/src/moonbase/webpackModules/updates.tsx

···
+import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
+import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
+import Notices from "@moonlight-mod/wp/notices_notices";
+import { MoonlightBranch } from "@moonlight-mod/types";
+import React from "@moonlight-mod/wp/react";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+
+// FIXME: not indexed as importable
+const Constants = spacepack.require("discord/Constants");
+const UserSettingsSections = spacepack.findObjectFromKey(
+  Constants,
+  "APPEARANCE_THEME_PICKER"
+);
+
+const { ThemeDarkIcon } = Components;
+
+function plural(str: string, num: number) {
+  return `${str}${num > 1 ? "s" : ""}`;
+}
+
+function listener() {
+  if (
+    MoonbaseSettingsStore.shouldShowNotice &&
+    MoonbaseSettingsStore.getExtensionConfigRaw(
+      "moonbase",
+      "updateBanner",
+      true
+    )
+  ) {
+    // @ts-expect-error epic type fail
+    MoonbaseSettingsStore.removeChangeListener(listener);
+
+    const version = MoonbaseSettingsStore.newVersion;
+    const extensionUpdateCount = Object.keys(
+      MoonbaseSettingsStore.updates
+    ).length;
+    const hasExtensionUpdates = extensionUpdateCount > 0;
+
+    let message;
+
+    if (version != null) {
+      message =
+        moonlightNode.branch === MoonlightBranch.NIGHTLY
+          ? `A new version of moonlight is available`
+          : `moonlight ${version} is available`;
+    }
+
+    if (hasExtensionUpdates) {
+      let concat = false;
+      if (message == null) {
+        message = "";
+      } else {
+        concat = true;
+        message += ", and ";
+      }
+      message += `${extensionUpdateCount} ${concat ? "" : "moonlight "}${plural(
+        "extension",
+        extensionUpdateCount
+      )} can be updated`;
+    }
+
+    if (message != null) message += ".";
+
+    Notices.addNotice({
+      element: (
+        <div className="moonbase-updates-notice_text-wrapper">
+          <ThemeDarkIcon size="sm" color="currentColor" />
+          {message}
+        </div>
+      ),
+      color: "moonbase-updates-notice",
+      buttons: [
+        {
+          name: "Open Moonbase",
+          onClick: () => {
+            const { open } = spacepack.findByExports(
+              "setSection",
+              "clearSubsection"
+            )[0].exports.Z;
+
+            // settings is lazy loaded thus lazily patched
+            // FIXME: figure out a way to detect if settings has been opened
+            //        alreadyjust so the transition isnt as jarring
+            open(UserSettingsSections.ACCOUNT);
+            setTimeout(() => {
+              if (
+                MoonbaseSettingsStore.getExtensionConfigRaw<boolean>(
+                  "moonbase",
+                  "sections",
+                  false
+                )
+              ) {
+                open("moonbase-extensions");
+              } else {
+                open("moonbase", 0);
+              }
+            }, 0);
+            return true;
+          }
+        }
+      ]
+    });
+  }
+}
+
+// @ts-expect-error epic type fail
+MoonbaseSettingsStore.addChangeListener(listener);

packages/core-extensions/src/nativeFixes/host.ts

···
+import { app, nativeTheme } from "electron";
+
+const enabledFeatures = app.commandLine
+  .getSwitchValue("enable-features")
+  .split(",");
+
+moonlightHost.events.on("window-created", function (browserWindow) {
+  if (
+    moonlightHost.getConfigOption<boolean>("nativeFixes", "devtoolsThemeFix") ??
+    true
+  ) {
+    browserWindow.webContents.on("devtools-opened", () => {
+      if (!nativeTheme.shouldUseDarkColors) return;
+      nativeTheme.themeSource = "light";
+      setTimeout(() => {
+        nativeTheme.themeSource = "dark";
+      }, 100);
+    });
+  }
+});
+
+if (
+  moonlightHost.getConfigOption<boolean>(
+    "nativeFixes",
+    "disableRendererBackgrounding"
+  ) ??
+  true
+) {
+  // Discord already disables UseEcoQoSForBackgroundProcess and some other
+  // related features
+  app.commandLine.appendSwitch("disable-renderer-backgrounding");
+  app.commandLine.appendSwitch("disable-backgrounding-occluded-windows");
+
+  // already added on Windows, but not on other operating systems
+  app.commandLine.appendSwitch("disable-background-timer-throttling");
+}
+
+if (process.platform === "linux") {
+  if (
+    moonlightHost.getConfigOption<boolean>("nativeFixes", "linuxAutoscroll") ??
+    false
+  ) {
+    app.commandLine.appendSwitch(
+      "enable-blink-features",
+      "MiddleClickAutoscroll"
+    );
+  }
+
+  if (
+    moonlightHost.getConfigOption<boolean>(
+      "nativeFixes",
+      "linuxSpeechDispatcher"
+    ) ??
+    true
+  ) {
+    app.commandLine.appendSwitch("enable-speech-dispatcher");
+  }
+}
+
+// NOTE: Only tested if this appears on Windows, it should appear on all when
+//       hardware acceleration is disabled
+const noAccel = app.commandLine.hasSwitch("disable-gpu-compositing");
+if (
+  (moonlightHost.getConfigOption<boolean>("nativeFixes", "vaapi") ?? true) &&
+  !noAccel
+) {
+  if (process.platform === "linux")
+    // These will eventually be renamed https://source.chromium.org/chromium/chromium/src/+/5482210941a94d70406b8da962426e4faca7fce4
+    enabledFeatures.push(
+      "VaapiVideoEncoder",
+      "VaapiVideoDecoder",
+      "VaapiVideoDecodeLinuxGL"
+    );
+}
+
+app.commandLine.appendSwitch(
+  "enable-features",
+  [...new Set(enabledFeatures)].join(",")
+);

packages/core-extensions/src/nativeFixes/manifest.json

···
+{
+  "id": "nativeFixes",
+  "meta": {
+    "name": "Native Fixes",
+    "tagline": "Various configurable fixes for Discord and Electron",
+    "authors": ["Cynosphere", "adryd"],
+    "tags": ["fixes"]
+  },
+  "settings": {
+    "devtoolsThemeFix": {
+      "displayName": "Devtools Theme Fix",
+      "description": "Temporary workaround for devtools defaulting to light theme on Electron 32",
+      "type": "boolean",
+      "default": true
+    },
+    "disableRendererBackgrounding": {
+      "displayName": "Disable Renderer Backgrounding",
+      "description": "This is enabled by default as a power saving measure, but it breaks screensharing and websocket connections fairly often",
+      "type": "boolean",
+      "default": true
+    },
+    "linuxAutoscroll": {
+      "displayName": "Enable middle click autoscroll on Linux",
+      "description": "Requires manual configuration of your system to disable middle click paste, has no effect on other operating systems",
+      "type": "boolean",
+      "default": false
+    },
+    "linuxSpeechDispatcher": {
+      "displayName": "Enable speech-dispatcher for TTS on Linux",
+      "description": "Fixes text-to-speech. Has no effect on other operating systems",
+      "type": "boolean",
+      "default": true
+    },
+    "vaapi": {
+      "displayName": "Enable VAAPI features on Linux",
+      "description": "Provides hardware accelerated video encode and decode. Has no effect on other operating systems",
+      "type": "boolean",
+      "default": true
+    }
+  },
+  "apiLevel": 2
+}

packages/core-extensions/src/noHideToken/index.ts

···
-import { Patch } from "types/src";
+import { Patch } from "@moonlight-mod/types";
 
 export const patches: Patch[] = [
   {

packages/core-extensions/src/noHideToken/manifest.json

···
   "apiLevel": 2,
   "meta": {
     "name": "No Hide Token",
-    "tagline": "Disables removal of token from localStorage when opening dev tools",
+    "tagline": "Prevents you from being logged-out on hard-crash",
+    "description": "Prevents you from being logged-out on hard-crash by disabling removal of token from localStorage when opening dev tools",
     "authors": ["adryd"],
     "tags": ["dangerZone", "development"]
   }

packages/core-extensions/src/noTrack/host.ts

···
-import { BrowserWindow } from "electron";
-
-moonlightHost.events.on("window-created", (window: BrowserWindow) => {
-  window.webContents.session.webRequest.onBeforeRequest(
-    {
-      urls: [
-        "https://*.discord.com/api/v*/science",
-        "https://*.discord.com/api/v*/metrics"
-      ]
-    },
-    function (details, callback) {
-      callback({ cancel: true });
-    }
-  );
-});

packages/core-extensions/src/noTrack/manifest.json

···
     "tagline": "Disables /api/science and analytics",
     "authors": ["Cynosphere", "NotNite"],
     "tags": ["privacy"]
-  }
+  },
+  "blocked": [
+    "https://*.discord.com/api/v*/science",
+    "https://*.discord.com/api/v*/metrics"
+  ]
 }

packages/core-extensions/src/notices/index.ts

···
+import type { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";
+
+export const patches: Patch[] = [
+  {
+    find: ".GUILD_RAID_NOTIFICATION:",
+    replace: {
+      match:
+        /(?<=return(\(0,.\.jsx\))\(.+?\);)case .{1,2}\..{1,3}\.GUILD_RAID_NOTIFICATION:/,
+      replacement: (orig, createElement) =>
+        `case "__moonlight_notice":return${createElement}(require("notices_component").default,{});${orig}`
+    }
+  },
+  {
+    find: '"NoticeStore"',
+    replace: [
+      {
+        match: /\[.{1,2}\..{1,3}\.CONNECT_SPOTIFY\]:{/,
+        replacement: (orig: string) =>
+          `__moonlight_notice:{predicate:()=>require("notices_notices").default.shouldShowNotice()},${orig}`
+      },
+      {
+        match: /=\[(.{1,2}\..{1,3}\.QUARANTINED,)/g,
+        replacement: (_, orig) => `=["__moonlight_notice",${orig}`
+      }
+    ]
+  }
+];
+
+export const webpackModules: Record<string, ExtensionWebpackModule> = {
+  notices: {
+    dependencies: [
+      { id: "discord/packages/flux" },
+      { id: "discord/Dispatcher" }
+    ]
+  },
+
+  component: {
+    dependencies: [
+      { id: "react" },
+      { id: "discord/Dispatcher" },
+      { id: "discord/components/common/index" },
+      { id: "discord/packages/flux" },
+      { ext: "notices", id: "notices" }
+    ]
+  }
+};

packages/core-extensions/src/notices/manifest.json

···
+{
+  "id": "notices",
+  "apiLevel": 2,
+  "meta": {
+    "name": "Notices",
+    "tagline": "An API for adding notices at the top of the page",
+    "authors": ["Cynosphere", "NotNite"],
+    "tags": ["library"]
+  }
+}

packages/core-extensions/src/notices/webpackModules/component.tsx

···
+import React from "@moonlight-mod/wp/react";
+import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+import { useStateFromStoresObject } from "@moonlight-mod/wp/discord/packages/flux";
+import NoticesStore from "@moonlight-mod/wp/notices_notices";
+import type { Notice } from "@moonlight-mod/types/coreExtensions/notices";
+
+// FIXME: types
+const { Notice, NoticeCloseButton, PrimaryCTANoticeButton } = Components;
+
+function popAndDismiss(notice: Notice) {
+  NoticesStore.popNotice();
+  if (notice?.onDismiss) {
+    notice.onDismiss();
+  }
+  if (!NoticesStore.shouldShowNotice()) {
+    Dispatcher.dispatch({
+      type: "NOTICE_DISMISS"
+    });
+  }
+}
+
+export default function UpdateNotice() {
+  const { notice } = useStateFromStoresObject([NoticesStore], () => ({
+    notice: NoticesStore.getCurrentNotice()
+  }));
+
+  if (notice == null) return <></>;
+
+  return (
+    <Notice color={notice.color}>
+      {notice.element}
+
+      {(notice.showClose ?? true) && (
+        <NoticeCloseButton
+          onClick={() => popAndDismiss(notice)}
+          noticeType="__moonlight_notice"
+        />
+      )}
+
+      {(notice.buttons ?? []).map((button) => (
+        <PrimaryCTANoticeButton
+          key={button.name}
+          onClick={() => {
+            if (button.onClick()) {
+              popAndDismiss(notice);
+            }
+          }}
+          noticeType="__moonlight_notice"
+        >
+          {button.name}
+        </PrimaryCTANoticeButton>
+      ))}
+    </Notice>
+  );
+}

packages/core-extensions/src/notices/webpackModules/notices.ts

···
+import { Store } from "@moonlight-mod/wp/discord/packages/flux";
+import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";
+import type {
+  Notice,
+  Notices
+} from "@moonlight-mod/types/coreExtensions/notices";
+
+// very lazy way of doing this, FIXME
+let open = false;
+
+class NoticesStore extends Store<any> {
+  private notices: Notice[] = [];
+
+  constructor() {
+    super(Dispatcher);
+  }
+
+  addNotice(notice: Notice) {
+    this.notices.push(notice);
+    if (open && this.notices.length !== 0) {
+      Dispatcher.dispatch({
+        type: "NOTICE_SHOW",
+        notice: { type: "__moonlight_notice" }
+      });
+    }
+    this.emitChange();
+  }
+
+  popNotice() {
+    this.notices.shift();
+    this.emitChange();
+  }
+
+  getCurrentNotice() {
+    return this.notices.length > 0 ? this.notices[0] : null;
+  }
+
+  shouldShowNotice() {
+    return this.notices.length > 0;
+  }
+}
+
+const store: Notices = new NoticesStore();
+
+function showNotice() {
+  open = true;
+  if (store.shouldShowNotice()) {
+    Dispatcher.dispatch({
+      type: "NOTICE_SHOW",
+      notice: { type: "__moonlight_notice" }
+    });
+  }
+}
+
+Dispatcher.subscribe("CONNECTION_OPEN", showNotice);
+Dispatcher.subscribe("CONNECTION_OPEN_SUPPLEMENTAL", showNotice);
+
+export default store;

packages/core-extensions/src/quietLoggers/index.ts

···
 // that end up causing syntax errors by the normal patch
 const loggerFixes: Patch[] = [
   {
-    find: '"./ggsans-800-extrabolditalic.woff2":',
+    find: '"./gg-sans/ggsans-800-extrabolditalic.woff2":',
     replace: {
-      match: /throw .+?,./,
-      replacement: "return{}"
+      match: /var .=Error.+?;throw .+?,./,
+      replacement: ""
     }
   },
   {

packages/core-extensions/src/rocketship/host.ts

···
+import "./host/permissions";
+import "./host/venmic";

packages/core-extensions/src/rocketship/host/permissions.ts

···
+import type { BrowserWindow } from "electron";
+
+type PermissionRequestHandler = (
+  webContents: Electron.WebContents,
+  permission: string,
+  callback: (permissionGranted: boolean) => void,
+  details: Electron.PermissionRequestHandlerHandlerDetails
+) => void;
+
+type PermissionCheckHandler = (
+  webContents: Electron.WebContents | null,
+  permission: string,
+  requestingOrigin: string,
+  details: Electron.PermissionCheckHandlerHandlerDetails
+) => boolean;
+
+moonlightHost.events.on(
+  "window-created",
+  (window: BrowserWindow, isMainWindow: boolean) => {
+    if (!isMainWindow) return;
+    const windowSession = window.webContents.session;
+
+    // setPermissionRequestHandler
+    windowSession.setPermissionRequestHandler(
+      (webcontents, permission, callback, details) => {
+        let cbResult = false;
+        function fakeCallback(result: boolean) {
+          cbResult = result;
+        }
+
+        if (caughtPermissionRequestHandler) {
+          caughtPermissionRequestHandler(
+            webcontents,
+            permission,
+            fakeCallback,
+            details
+          );
+        }
+
+        if (permission === "media" || permission === "display-capture") {
+          cbResult = true;
+        }
+
+        callback(cbResult);
+      }
+    );
+
+    let caughtPermissionRequestHandler: PermissionRequestHandler | undefined;
+
+    windowSession.setPermissionRequestHandler =
+      function catchSetPermissionRequestHandler(
+        handler: (
+          webcontents: Electron.WebContents,
+          permission: string,
+          callback: (permissionGranted: boolean) => void
+        ) => void
+      ) {
+        caughtPermissionRequestHandler = handler;
+      };
+
+    // setPermissionCheckHandler
+    windowSession.setPermissionCheckHandler(
+      (webcontents, permission, requestingOrigin, details) => {
+        return false;
+      }
+    );
+
+    let caughtPermissionCheckHandler: PermissionCheckHandler | undefined;
+
+    windowSession.setPermissionCheckHandler(
+      (webcontents, permission, requestingOrigin, details) => {
+        let result = false;
+
+        if (caughtPermissionCheckHandler) {
+          result = caughtPermissionCheckHandler(
+            webcontents,
+            permission,
+            requestingOrigin,
+            details
+          );
+        }
+
+        if (permission === "media" || permission === "display-capture") {
+          result = true;
+        }
+
+        return result;
+      }
+    );
+
+    windowSession.setPermissionCheckHandler =
+      function catchSetPermissionCheckHandler(handler: PermissionCheckHandler) {
+        caughtPermissionCheckHandler = handler;
+      };
+  }
+);

packages/core-extensions/src/rocketship/host/types.ts

···
+// https://github.com/Vencord/venmic/blob/d737ef33eaae7a73d03ec02673e008cf0243434d/lib/module.d.ts
+type DefaultProps = "node.name" | "application.name";
+
+type LiteralUnion<LiteralType, BaseType extends string> =
+  | LiteralType
+  | (BaseType & Record<never, never>);
+
+type Optional<Type, Key extends keyof Type> = Partial<Pick<Type, Key>> &
+  Omit<Type, Key>;
+
+export type Node<T extends string = never> = Record<
+  LiteralUnion<T, string>,
+  string
+>;
+
+export interface LinkData {
+  include: Node[];
+  exclude: Node[];
+
+  ignore_devices?: boolean;
+
+  only_speakers?: boolean;
+  only_default_speakers?: boolean;
+
+  workaround?: Node[];
+}
+
+export interface PatchBay {
+  unlink(): void;
+
+  list<T extends string = DefaultProps>(props?: T[]): Node<T>[];
+  link(
+    data: Optional<LinkData, "exclude"> | Optional<LinkData, "include">
+  ): boolean;
+}

packages/core-extensions/src/rocketship/host/venmic.ts

···
+import type { BrowserWindow } from "electron";
+import { app, desktopCapturer } from "electron";
+import path from "node:path";
+import { type PatchBay } from "./types";
+
+const logger = moonlightHost.getLogger("rocketship");
+
+function getPatchbay() {
+  try {
+    const venmic = require(
+      path.join(path.dirname(moonlightHost.asarPath), "..", "venmic.node")
+    ) as { PatchBay: new () => PatchBay };
+    const patchbay = new venmic.PatchBay();
+    return patchbay;
+  } catch (error) {
+    logger.error("Failed to load venmic.node:", error);
+    return null;
+  }
+}
+
+const patchbay = getPatchbay();
+
+// TODO: figure out how to map source to window with venmic
+function linkVenmic() {
+  if (patchbay == null) return false;
+
+  try {
+    const pid =
+      app
+        .getAppMetrics()
+        .find((proc) => proc.name === "Audio Service")
+        ?.pid?.toString() ?? "";
+
+    logger.info("Audio Service PID:", pid);
+
+    patchbay.unlink();
+    return patchbay.link({
+      exclude: [
+        { "application.process.id": pid },
+        { "media.class": "Stream/Input/Audio" }
+      ],
+      ignore_devices: true,
+      only_speakers: true,
+      only_default_speakers: true
+    });
+  } catch (error) {
+    logger.error("Failed to link venmic:", error);
+    return false;
+  }
+}
+
+moonlightHost.events.on(
+  "window-created",
+  (window: BrowserWindow, isMainWindow: boolean) => {
+    if (!isMainWindow) return;
+    const windowSession = window.webContents.session;
+
+    // @ts-expect-error these types ancient
+    windowSession.setDisplayMediaRequestHandler(
+      (request: any, callback: any) => {
+        const linked = linkVenmic();
+        desktopCapturer
+          .getSources({ types: ["screen", "window"] })
+          .then((sources) => {
+            //logger.debug("desktopCapturer.getSources", sources);
+            logger.debug("Linked to venmic:", linked);
+
+            callback({
+              video: sources[0],
+              audio: "loopback"
+            });
+          });
+      },
+      { useSystemPicker: true }
+    );
+  }
+);

packages/core-extensions/src/rocketship/index.ts

···
+import { Patch } from "@moonlight-mod/types";
+
+const logger = moonlight.getLogger("rocketship");
+const getDisplayMediaOrig = navigator.mediaDevices.getDisplayMedia;
+
+async function getVenmicStream() {
+  try {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    logger.debug("Devices:", devices);
+
+    // This isn't vencord :(
+    const id = devices.find((device) => device.label === "vencord-screen-share")
+      ?.deviceId;
+    if (!id) return null;
+    logger.debug("Got venmic device ID:", id);
+
+    const stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        deviceId: {
+          exact: id
+        },
+        autoGainControl: false,
+        echoCancellation: false,
+        noiseSuppression: false
+      }
+    });
+
+    return stream.getAudioTracks();
+  } catch (error) {
+    logger.warn("Failed to get venmic stream:", error);
+    return null;
+  }
+}
+
+navigator.mediaDevices.getDisplayMedia = async function getDisplayMediaRedirect(
+  options
+) {
+  const orig = await getDisplayMediaOrig.call(this, options);
+
+  const venmic = await getVenmicStream();
+  logger.debug("venmic", venmic);
+  if (venmic != null) {
+    // venmic will be proxying all audio, so we need to remove the original
+    // tracks to not cause overlap
+    for (const track of orig.getAudioTracks()) {
+      orig.removeTrack(track);
+    }
+
+    for (const track of venmic) {
+      orig.addTrack(track);
+    }
+  }
+
+  return orig;
+};
+
+export const patches: Patch[] = [
+  // "Ensure discord_voice is happy"
+  {
+    find: "RustAudioDeviceModule",
+    replace: [
+      {
+        match: /static supported\(\)\{.+?\}/,
+        replacement: "static supported(){return true}"
+      },
+      {
+        match: "supported(){return!0}",
+        replacement: "supported(){return true}"
+      }
+    ]
+  },
+  // Remove Native media engine from list of choices
+  {
+    find: '.CAMERA_BACKGROUND_LIVE="cameraBackgroundLive"',
+    replace: {
+      match: /.\..{1,2}\.NATIVE,/,
+      replacement: ""
+    }
+  },
+  // Stub out browser checks to allow us to use WebRTC voice on Embedded
+  {
+    find: "Using Unified Plan (",
+    replace: {
+      match: /return .\..{1,2}\?\((.)\.info/,
+      replacement: (_, logger) => `return true?(${logger}.info`
+    }
+  },
+  {
+    find: '"UnifiedConnection("',
+    replace: {
+      match: /this\.videoSupported=.\..{1,2};/,
+      replacement: "this.videoSupported=true;"
+    }
+  },
+  {
+    find: "OculusBrowser",
+    replace: [
+      {
+        match: /"Firefox"===(.)\(\)\.name/g,
+        replacement: (orig, info) => `true||${orig}`
+      }
+    ]
+  },
+  {
+    find: ".getMediaEngine().getDesktopSource",
+    replace: {
+      match: /.\.isPlatformEmbedded/,
+      replacement: "false"
+    }
+  },
+  {
+    // Matching MediaEngineStore
+    find: '"displayName","MediaEngineStore")',
+    replace: [
+      // Prevent loading of krisp native module by stubbing out desktop checks
+      {
+        match:
+          /\(\(0,.\.isWindows\)\(\)\|\|\(0,.\.isLinux\)\(\)\|\|.+?&&!__OVERLAY__/,
+        replacement: (orig, macosPlatformCheck) => `false&&!__OVERLAY__`
+      },
+      // Enable loading of web krisp equivelant by replacing isWeb with true
+      {
+        match:
+          /\(0,.\.isWeb\)\(\)&&(.{1,2}\.supports\(.{1,2}\..{1,2}.NOISE_CANCELLATION)/,
+        replacement: (orig, supportsNoiseCancellation) =>
+          `true&&${supportsNoiseCancellation}`
+      }
+    ]
+  }
+];

packages/core-extensions/src/rocketship/manifest.json

···
+{
+  "id": "rocketship",
+  "apiLevel": 2,
+  "meta": {
+    "name": "Rocketship",
+    "tagline": "Adds new features when using rocketship",
+    "description": "**This extension only works on Linux when using rocketship:**\nhttps://github.com/moonlight-mod/rocketship\n\nAdds new features to the Discord Linux client with rocketship, such as a better screensharing experience.",
+    "authors": ["NotNite", "Cynosphere", "adryd"]
+  }
+}

packages/core-extensions/src/settings/index.ts

···
   {
     find: '"useGenerateUserSettingsSections"',
     replace: {
-      match: /(?<=\.push\(.+?\)}\)\)}\),)./,
-      replacement: (sections: string) =>
-        `require("settings_settings").Settings._mutateSections(${sections})`
+      match: /(?<=\.push\(.+?\)}\)\)}\),)(.+?)}/,
+      replacement: (_, sections: string) =>
+        `require("settings_settings").Settings._mutateSections(${sections})}`
     }
   },
   {

packages/core/src/asar.ts

···
+// https://github.com/electron/asar
+// http://formats.kaitai.io/python_pickle/
+import { BinaryReader } from "./util/binary";
+
+/*
+  The asar format is kinda bad, especially because it uses multiple pickle
+  entries. It spams sizes, expecting us to read small buffers and parse those,
+  but we can just take it all through at once without having to create multiple
+  BinaryReaders. This implementation might be wrong, though.
+
+  This either has size/offset or files but I can't get the type to cooperate,
+  so pretend this is a union.
+*/
+
+type AsarEntry = {
+  size: number;
+  offset: `${number}`; // who designed this
+
+  files?: Record<string, AsarEntry>;
+};
+
+export default function extractAsar(file: ArrayBuffer) {
+  const array = new Uint8Array(file);
+  const br = new BinaryReader(array);
+
+  // two uints, one containing the number '4', to signify that the other uint takes up 4 bytes
+  // bravo, electron, bravo
+  const _payloadSize = br.readUInt32();
+  const _headerSize = br.readInt32();
+
+  const headerStringStart = br.position;
+  const headerStringSize = br.readUInt32(); // How big the block is
+  const actualStringSize = br.readUInt32(); // How big the string in that block is
+
+  const base = headerStringStart + headerStringSize + 4;
+
+  const string = br.readString(actualStringSize);
+  const header: AsarEntry = JSON.parse(string);
+
+  const ret: Record<string, Uint8Array> = {};
+  function addDirectory(dir: AsarEntry, path: string) {
+    for (const [name, data] of Object.entries(dir.files!)) {
+      const fullName = path + "/" + name;
+      if (data.files != null) {
+        addDirectory(data, fullName);
+      } else {
+        br.position = base + parseInt(data.offset);
+        const file = br.read(data.size);
+        ret[fullName] = file;
+      }
+    }
+  }
+
+  addDirectory(header, "");
+
+  return ret;
+}

packages/core/src/config.ts

···
 import { Config } from "@moonlight-mod/types";
-import requireImport from "./util/import";
 import { getConfigPath } from "./util/data";
+import * as constants from "@moonlight-mod/types/constants";
+import Logger from "./util/logger";
+
+const logger = new Logger("core/config");
 
 const defaultConfig: Config = {
   extensions: {
···
     noTrack: true,
     noHideToken: true
   },
-  repositories: ["https://moonlight-mod.github.io/extensions-dist/repo.json"]
+  repositories: [constants.mainRepo]
 };
 
-export function writeConfig(config: Config) {
-  const fs = requireImport("fs");
-  const configPath = getConfigPath();
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-function readConfigNode(): Config {
-  const fs = requireImport("fs");
-  const configPath = getConfigPath();
-
-  if (!fs.existsSync(configPath)) {
-    writeConfig(defaultConfig);
-    return defaultConfig;
+export async function writeConfig(config: Config) {
+  try {
+    const configPath = await getConfigPath();
+    await moonlightFS.writeFileString(
+      configPath,
+      JSON.stringify(config, null, 2)
+    );
+  } catch (e) {
+    logger.error("Failed to write config", e);
   }
-
-  let config: Config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-
-  // Assign the default values if they don't exist (newly added)
-  config = { ...defaultConfig, ...config };
-  writeConfig(config);
-
-  return config;
 }
 
-export function readConfig(): Config {
+export async function readConfig(): Promise<Config> {
   webPreload: {
     return moonlightNode.config;
   }
 
-  nodePreload: {
-    return readConfigNode();
-  }
+  const configPath = await getConfigPath();
+  if (!(await moonlightFS.exists(configPath))) {
+    await writeConfig(defaultConfig);
+    return defaultConfig;
+  } else {
+    try {
+      let config: Config = JSON.parse(
+        await moonlightFS.readFileString(configPath)
+      );
+      // Assign the default values if they don't exist (newly added)
+      config = { ...defaultConfig, ...config };
+      await writeConfig(config);
 
-  injector: {
-    return readConfigNode();
+      return config;
+    } catch (e) {
+      logger.error("Failed to read config, falling back to defaults", e);
+      // We don't want to write the default config here - if a user is manually
+      // editing their config and messes it up, we'll delete it all instead of
+      // letting them fix it
+      return defaultConfig;
+    }
   }
-
-  throw new Error("Called readConfig() in an impossible environment");
 }

packages/core/src/extension.ts

···
   constants
 } from "@moonlight-mod/types";
 import { readConfig } from "./config";
-import requireImport from "./util/import";
 import { getCoreExtensionsPath, getExtensionsPath } from "./util/data";
+import Logger from "./util/logger";
+
+const logger = new Logger("core/extension");
 
-function findManifests(dir: string): string[] {
-  const fs = requireImport("fs");
-  const path = requireImport("path");
+async function findManifests(dir: string): Promise<string[]> {
   const ret = [];
 
-  if (fs.existsSync(dir)) {
-    for (const file of fs.readdirSync(dir)) {
+  if (await moonlightFS.exists(dir)) {
+    for (const file of await moonlightFS.readdir(dir)) {
+      const path = moonlightFS.join(dir, file);
       if (file === "manifest.json") {
-        ret.push(path.join(dir, file));
+        ret.push(path);
       }
 
-      if (fs.statSync(path.join(dir, file)).isDirectory()) {
-        ret.push(...findManifests(path.join(dir, file)));
+      if (!(await moonlightFS.isFile(path))) {
+        ret.push(...(await findManifests(path)));
       }
     }
   }
···
   return ret;
 }
 
-function loadDetectedExtensions(
+async function loadDetectedExtensions(
   dir: string,
   type: ExtensionLoadSource
-): DetectedExtension[] {
-  const fs = requireImport("fs");
-  const path = requireImport("path");
+): Promise<DetectedExtension[]> {
   const ret: DetectedExtension[] = [];
 
-  const manifests = findManifests(dir);
+  const manifests = await findManifests(dir);
   for (const manifestPath of manifests) {
-    if (!fs.existsSync(manifestPath)) continue;
-    const dir = path.dirname(manifestPath);
+    try {
+      if (!(await moonlightFS.exists(manifestPath))) continue;
+      const dir = moonlightFS.dirname(manifestPath);
 
-    const manifest: ExtensionManifest = JSON.parse(
-      fs.readFileSync(manifestPath, "utf8")
-    );
-    const level = manifest.apiLevel ?? 1;
-    if (level !== constants.apiLevel) {
-      continue;
-    }
+      const manifest: ExtensionManifest = JSON.parse(
+        await moonlightFS.readFileString(manifestPath)
+      );
 
-    const webPath = path.join(dir, "index.js");
-    const nodePath = path.join(dir, "node.js");
-    const hostPath = path.join(dir, "host.js");
+      const webPath = moonlightFS.join(dir, "index.js");
+      const nodePath = moonlightFS.join(dir, "node.js");
+      const hostPath = moonlightFS.join(dir, "host.js");
 
-    // if none exist (empty manifest) don't give a shit
-    if (
-      !fs.existsSync(webPath) &&
-      !fs.existsSync(nodePath) &&
-      !fs.existsSync(hostPath)
-    ) {
-      continue;
-    }
+      // if none exist (empty manifest) don't give a shit
+      if (
+        !moonlightFS.exists(webPath) &&
+        !moonlightFS.exists(nodePath) &&
+        !moonlightFS.exists(hostPath)
+      ) {
+        continue;
+      }
 
-    const web = fs.existsSync(webPath)
-      ? fs.readFileSync(webPath, "utf8")
-      : undefined;
+      const web = (await moonlightFS.exists(webPath))
+        ? await moonlightFS.readFileString(webPath)
+        : undefined;
 
-    let url: string | undefined = undefined;
-    const urlPath = path.join(dir, constants.repoUrlFile);
-    if (type === ExtensionLoadSource.Normal && fs.existsSync(urlPath)) {
-      url = fs.readFileSync(urlPath, "utf8");
-    }
+      let url: string | undefined = undefined;
+      const urlPath = moonlightFS.join(dir, constants.repoUrlFile);
+      if (
+        type === ExtensionLoadSource.Normal &&
+        (await moonlightFS.exists(urlPath))
+      ) {
+        url = await moonlightFS.readFileString(urlPath);
+      }
 
-    const wpModules: Record<string, string> = {};
-    const wpModulesPath = path.join(dir, "webpackModules");
-    if (fs.existsSync(wpModulesPath)) {
-      const wpModulesFile = fs.readdirSync(wpModulesPath);
+      const wpModules: Record<string, string> = {};
+      const wpModulesPath = moonlightFS.join(dir, "webpackModules");
+      if (await moonlightFS.exists(wpModulesPath)) {
+        const wpModulesFile = await moonlightFS.readdir(wpModulesPath);
 
-      for (const wpModuleFile of wpModulesFile) {
-        if (wpModuleFile.endsWith(".js")) {
-          wpModules[wpModuleFile.replace(".js", "")] = fs.readFileSync(
-            path.join(wpModulesPath, wpModuleFile),
-            "utf8"
-          );
+        for (const wpModuleFile of wpModulesFile) {
+          if (wpModuleFile.endsWith(".js")) {
+            wpModules[wpModuleFile.replace(".js", "")] =
+              await moonlightFS.readFileString(
+                moonlightFS.join(wpModulesPath, wpModuleFile)
+              );
+          }
         }
       }
-    }
 
-    ret.push({
-      id: manifest.id,
-      manifest,
-      source: {
-        type,
-        url
-      },
-      scripts: {
-        web,
-        webPath: web != null ? webPath : undefined,
-        webpackModules: wpModules,
-        nodePath: fs.existsSync(nodePath) ? nodePath : undefined,
-        hostPath: fs.existsSync(hostPath) ? hostPath : undefined
-      }
-    });
+      ret.push({
+        id: manifest.id,
+        manifest,
+        source: {
+          type,
+          url
+        },
+        scripts: {
+          web,
+          webPath: web != null ? webPath : undefined,
+          webpackModules: wpModules,
+          nodePath: (await moonlightFS.exists(nodePath)) ? nodePath : undefined,
+          hostPath: (await moonlightFS.exists(hostPath)) ? hostPath : undefined
+        }
+      });
+    } catch (e) {
+      logger.error(e, "Failed to load extension");
+    }
   }
 
   return ret;
 }
 
-function getExtensionsNative(): DetectedExtension[] {
-  const config = readConfig();
+async function getExtensionsNative(): Promise<DetectedExtension[]> {
+  const config = await readConfig();
   const res = [];
 
   res.push(
-    ...loadDetectedExtensions(getCoreExtensionsPath(), ExtensionLoadSource.Core)
+    ...(await loadDetectedExtensions(
+      getCoreExtensionsPath(),
+      ExtensionLoadSource.Core
+    ))
   );
 
   res.push(
-    ...loadDetectedExtensions(getExtensionsPath(), ExtensionLoadSource.Normal)
+    ...(await loadDetectedExtensions(
+      await getExtensionsPath(),
+      ExtensionLoadSource.Normal
+    ))
   );
 
   for (const devSearchPath of config.devSearchPaths ?? []) {
     res.push(
-      ...loadDetectedExtensions(devSearchPath, ExtensionLoadSource.Developer)
+      ...(await loadDetectedExtensions(
+        devSearchPath,
+        ExtensionLoadSource.Developer
+      ))
     );
   }
 
   return res;
 }
 
-export function getExtensions(): DetectedExtension[] {
+async function getExtensionsBrowser(): Promise<DetectedExtension[]> {
+  const ret: DetectedExtension[] = [];
+
+  const coreExtensionsFs: Record<string, string> = JSON.parse(
+    // @ts-expect-error shut up
+    _moonlight_coreExtensionsStr
+  );
+  const coreExtensions = Array.from(
+    new Set(Object.keys(coreExtensionsFs).map((x) => x.split("/")[0]))
+  );
+
+  for (const ext of coreExtensions) {
+    if (!coreExtensionsFs[`${ext}/index.js`]) continue;
+    const manifest = JSON.parse(coreExtensionsFs[`${ext}/manifest.json`]);
+    const web = coreExtensionsFs[`${ext}/index.js`];
+
+    const wpModules: Record<string, string> = {};
+    const wpModulesPath = `${ext}/webpackModules`;
+    for (const wpModuleFile of Object.keys(coreExtensionsFs)) {
+      if (wpModuleFile.startsWith(wpModulesPath)) {
+        wpModules[
+          wpModuleFile.replace(wpModulesPath + "/", "").replace(".js", "")
+        ] = coreExtensionsFs[wpModuleFile];
+      }
+    }
+
+    ret.push({
+      id: manifest.id,
+      manifest,
+      source: {
+        type: ExtensionLoadSource.Core
+      },
+      scripts: {
+        web,
+        webpackModules: wpModules
+      }
+    });
+  }
+
+  if (await moonlightFS.exists("/extensions")) {
+    ret.push(
+      ...(await loadDetectedExtensions(
+        "/extensions",
+        ExtensionLoadSource.Normal
+      ))
+    );
+  }
+
+  return ret;
+}
+
+export async function getExtensions(): Promise<DetectedExtension[]> {
   webPreload: {
     return moonlightNode.extensions;
   }
 
-  nodePreload: {
-    return getExtensionsNative();
+  browser: {
+    return await getExtensionsBrowser();
   }
 
-  injector: {
-    return getExtensionsNative();
+  nodeTarget: {
+    return await getExtensionsNative();
   }
 
   throw new Error("Called getExtensions() outside of node-preload/web-preload");

packages/core/src/extension/loader.ts

···
   ExtensionWebExports,
   DetectedExtension,
   ProcessedExtensions,
-  WebpackModuleFunc
+  WebpackModuleFunc,
+  constants,
+  ExtensionManifest,
+  ExtensionEnvironment
 } from "@moonlight-mod/types";
 import { readConfig } from "../config";
 import Logger from "../util/logger";
···
 
 const logger = new Logger("core/extension/loader");
 
-async function loadExt(ext: DetectedExtension) {
-  webPreload: {
-    if (ext.scripts.web != null) {
-      const source = ext.scripts.web;
-      const fn = new Function("require", "module", "exports", source);
+function loadExtWeb(ext: DetectedExtension) {
+  if (ext.scripts.web != null) {
+    const source = ext.scripts.web;
+    const fn = new Function("require", "module", "exports", source);
 
-      const module = { id: ext.id, exports: {} };
-      fn.apply(window, [
-        () => {
-          logger.warn("Attempted to require() from web");
-        },
-        module,
-        module.exports
-      ]);
+    const module = { id: ext.id, exports: {} };
+    fn.apply(window, [
+      () => {
+        logger.warn("Attempted to require() from web");
+      },
+      module,
+      module.exports
+    ]);
 
-      const exports: ExtensionWebExports = module.exports;
-      if (exports.patches != null) {
-        let idx = 0;
-        for (const patch of exports.patches) {
-          if (Array.isArray(patch.replace)) {
-            for (const replacement of patch.replace) {
-              const newPatch = Object.assign({}, patch, {
-                replace: replacement
-              });
+    const exports: ExtensionWebExports = module.exports;
+    if (exports.patches != null) {
+      let idx = 0;
+      for (const patch of exports.patches) {
+        if (Array.isArray(patch.replace)) {
+          for (const replacement of patch.replace) {
+            const newPatch = Object.assign({}, patch, {
+              replace: replacement
+            });
 
-              registerPatch({ ...newPatch, ext: ext.id, id: idx });
-              idx++;
-            }
-          } else {
-            registerPatch({ ...patch, ext: ext.id, id: idx });
+            registerPatch({ ...newPatch, ext: ext.id, id: idx });
             idx++;
           }
+        } else {
+          registerPatch({ ...patch, ext: ext.id, id: idx });
+          idx++;
         }
       }
+    }
 
-      if (exports.webpackModules != null) {
-        for (const [name, wp] of Object.entries(exports.webpackModules)) {
-          if (wp.run == null && ext.scripts.webpackModules?.[name] != null) {
-            const func = new Function(
-              "module",
-              "exports",
-              "require",
-              ext.scripts.webpackModules[name]!
-            ) as WebpackModuleFunc;
-            registerWebpackModule({
-              ...wp,
-              ext: ext.id,
-              id: name,
-              run: func
-            });
-          } else {
-            registerWebpackModule({ ...wp, ext: ext.id, id: name });
-          }
+    if (exports.webpackModules != null) {
+      for (const [name, wp] of Object.entries(exports.webpackModules)) {
+        if (wp.run == null && ext.scripts.webpackModules?.[name] != null) {
+          const func = new Function(
+            "module",
+            "exports",
+            "require",
+            ext.scripts.webpackModules[name]!
+          ) as WebpackModuleFunc;
+          registerWebpackModule({
+            ...wp,
+            ext: ext.id,
+            id: name,
+            run: func
+          });
+        } else {
+          registerWebpackModule({ ...wp, ext: ext.id, id: name });
         }
       }
+    }
 
-      if (exports.styles != null) {
-        registerStyles(
-          exports.styles.map((style, i) => `/* ${ext.id}#${i} */ ${style}`)
-        );
-      }
+    if (exports.styles != null) {
+      registerStyles(
+        exports.styles.map((style, i) => `/* ${ext.id}#${i} */ ${style}`)
+      );
     }
   }
+}
+
+async function loadExt(ext: DetectedExtension) {
+  webTarget: {
+    loadExtWeb(ext);
+  }
 
   nodePreload: {
     if (ext.scripts.nodePath != null) {
···
   }
 }
 
+export enum ExtensionCompat {
+  Compatible,
+  InvalidApiLevel,
+  InvalidEnvironment
+}
+
+export function checkExtensionCompat(
+  manifest: ExtensionManifest
+): ExtensionCompat {
+  let environment;
+  webTarget: {
+    environment = ExtensionEnvironment.Web;
+  }
+  nodeTarget: {
+    environment = ExtensionEnvironment.Desktop;
+  }
+
+  if (manifest.apiLevel !== constants.apiLevel)
+    return ExtensionCompat.InvalidApiLevel;
+  if (
+    (manifest.environment ?? "both") !== "both" &&
+    manifest.environment !== environment
+  )
+    return ExtensionCompat.InvalidEnvironment;
+  return ExtensionCompat.Compatible;
+}
+
 /*
   This function resolves extensions and loads them, split into a few stages:
 
···
 export async function loadExtensions(
   exts: DetectedExtension[]
 ): Promise<ProcessedExtensions> {
-  const config = readConfig();
+  exts = exts.filter(
+    (ext) => checkExtensionCompat(ext.manifest) === ExtensionCompat.Compatible
+  );
+
+  const config = await readConfig();
   const items = exts
     .map((ext) => {
       return {
···
     logger.debug(`Loaded "${ext.id}"`);
   }
 
-  webPreload: {
+  webTarget: {
     for (const ext of extensions) {
       moonlight.enabledExtensions.add(ext.id);
     }

packages/core/src/fs.ts

···
+import type { MoonlightFS } from "@moonlight-mod/types";
+import requireImport from "./util/import";
+
+export default function createFS(): MoonlightFS {
+  const fs = requireImport("fs");
+  const path = requireImport("path");
+
+  return {
+    async readFile(path) {
+      const file = fs.readFileSync(path);
+      return new Uint8Array(file);
+    },
+    async readFileString(path) {
+      return fs.readFileSync(path, "utf8");
+    },
+    async writeFile(path, data) {
+      fs.writeFileSync(path, Buffer.from(data));
+    },
+    async writeFileString(path, data) {
+      fs.writeFileSync(path, data, "utf8");
+    },
+    async unlink(path) {
+      fs.unlinkSync(path);
+    },
+
+    async readdir(path) {
+      return fs.readdirSync(path);
+    },
+    async mkdir(path) {
+      fs.mkdirSync(path, { recursive: true });
+    },
+    async rmdir(path) {
+      fs.rmSync(path, { recursive: true });
+    },
+
+    async exists(path) {
+      return fs.existsSync(path);
+    },
+    async isFile(path) {
+      return fs.statSync(path).isFile();
+    },
+
+    join(...parts) {
+      return path.join(...parts);
+    },
+    dirname(dir) {
+      return path.dirname(dir);
+    }
+  };
+}

packages/core/src/util/binary.ts

···
+// https://github.com/NotNite/brc-save-editor/blob/main/src/lib/binary.ts
+export interface BinaryInterface {
+  data: Uint8Array;
+  view: DataView;
+  length: number;
+  position: number;
+}
+
+export class BinaryReader implements BinaryInterface {
+  data: Uint8Array;
+  view: DataView;
+  length: number;
+  position: number;
+
+  constructor(data: Uint8Array) {
+    this.data = data;
+    this.view = new DataView(data.buffer);
+
+    this.length = data.length;
+    this.position = 0;
+  }
+
+  readByte() {
+    return this._read(this.view.getInt8, 1);
+  }
+
+  readBoolean() {
+    return this.readByte() !== 0;
+  }
+
+  readInt32() {
+    return this._read(this.view.getInt32, 4);
+  }
+
+  readUInt32() {
+    return this._read(this.view.getUint32, 4);
+  }
+
+  readSingle() {
+    return this._read(this.view.getFloat32, 4);
+  }
+
+  readInt64() {
+    return this._read(this.view.getBigInt64, 8);
+  }
+
+  readString(length: number) {
+    const result = this.read(length);
+    return new TextDecoder().decode(result);
+  }
+
+  read(length: number) {
+    const data = this.data.subarray(this.position, this.position + length);
+    this.position += length;
+    return data;
+  }
+
+  private _read<T>(
+    func: (position: number, littleEndian?: boolean) => T,
+    length: number
+  ): T {
+    const result = func.call(this.view, this.position, true);
+    this.position += length;
+    return result;
+  }
+}

packages/core/src/util/data.ts

···
 import { constants } from "@moonlight-mod/types";
-import requireImport from "./import";
+
+export async function getMoonlightDir() {
+  browser: {
+    return "/";
+  }
 
-export function getMoonlightDir(): string {
   const electron = require("electron");
-  const fs = requireImport("fs");
-  const path = requireImport("path");
 
   let appData = "";
   injector: {
···
     appData = electron.ipcRenderer.sendSync(constants.ipcGetAppData);
   }
 
-  const dir = path.join(appData, "moonlight-mod");
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir);
+  const dir = moonlightFS.join(appData, "moonlight-mod");
+  if (!(await moonlightFS.exists(dir))) await moonlightFS.mkdir(dir);
 
   return dir;
 }
···
   version: string;
 };
 
-export function getConfigPath(): string {
-  const dir = getMoonlightDir();
-  const fs = requireImport("fs");
-  const path = requireImport("path");
+export async function getConfigPath() {
+  browser: {
+    return "/config.json";
+  }
+
+  const dir = await getMoonlightDir();
 
   let configPath = "";
 
-  const buildInfoPath = path.join(process.resourcesPath, "build_info.json");
-  if (!fs.existsSync(buildInfoPath)) {
-    configPath = path.join(dir, "desktop.json");
+  const buildInfoPath = moonlightFS.join(
+    process.resourcesPath,
+    "build_info.json"
+  );
+  if (!(await moonlightFS.exists(buildInfoPath))) {
+    configPath = moonlightFS.join(dir, "desktop.json");
   } else {
     const buildInfo: BuildInfo = JSON.parse(
-      fs.readFileSync(buildInfoPath, "utf8")
+      await moonlightFS.readFileString(buildInfoPath)
     );
-    configPath = path.join(dir, buildInfo.releaseChannel + ".json");
+    configPath = moonlightFS.join(dir, buildInfo.releaseChannel + ".json");
   }
 
   return configPath;
 }
 
-function getPathFromMoonlight(...names: string[]): string {
-  const dir = getMoonlightDir();
-  const fs = requireImport("fs");
-  const path = requireImport("path");
+async function getPathFromMoonlight(...names: string[]) {
+  const dir = await getMoonlightDir();
 
-  const target = path.join(dir, ...names);
-  if (!fs.existsSync(target)) fs.mkdirSync(target);
+  const target = moonlightFS.join(dir, ...names);
+  if (!(await moonlightFS.exists(target))) await moonlightFS.mkdir(target);
 
   return target;
 }
 
-export function getExtensionsPath(): string {
-  return getPathFromMoonlight(constants.extensionsDir);
+export async function getExtensionsPath() {
+  return await getPathFromMoonlight(constants.extensionsDir);
 }
 
 export function getCoreExtensionsPath(): string {
-  const path = requireImport("path");
-  const a = path.join(__dirname, constants.coreExtensionsDir);
-  return a;
+  return moonlightFS.join(__dirname, constants.coreExtensionsDir);
 }

packages/core/src/util/event.ts

···
 import { MoonlightEventEmitter } from "@moonlight-mod/types/core/event";
 
-function nodeMethod<
+export function createEventEmitter<
   EventId extends string = string,
   EventData = Record<EventId, any>
 >(): MoonlightEventEmitter<EventId, EventData> {
-  const EventEmitter = require("events");
-  const eventEmitter = new EventEmitter();
-  const listeners = new Map<(data: EventData) => void, (e: Event) => void>();
+  webTarget: {
+    const eventEmitter = new EventTarget();
+    const listeners = new Map<(data: EventData) => void, (e: Event) => void>();
 
-  return {
-    dispatchEvent: <Id extends keyof EventData>(
-      id: Id,
-      data: EventData[Id]
-    ) => {
-      eventEmitter.emit(id as string, data);
-    },
-
-    addEventListener: <Id extends keyof EventData>(
-      id: Id,
-      cb: (data: EventData[Id]) => void
-    ) => {
-      const untyped = cb as (data: EventData) => void;
-      if (listeners.has(untyped)) return;
-
-      function listener(e: Event) {
-        const event = e as CustomEvent<string>;
-        cb(event as EventData[Id]);
-      }
-
-      listeners.set(untyped, listener);
-      eventEmitter.on(id as string, listener);
-    },
-
-    removeEventListener: <Id extends keyof EventData>(
-      id: Id,
-      cb: (data: EventData[Id]) => void
-    ) => {
-      const untyped = cb as (data: EventData) => void;
-      const listener = listeners.get(untyped);
-      if (listener == null) return;
-      listeners.delete(untyped);
-      eventEmitter.off(id as string, listener);
-    }
-  };
-}
+    return {
+      dispatchEvent: <Id extends keyof EventData>(
+        id: Id,
+        data: EventData[Id]
+      ) => {
+        eventEmitter.dispatchEvent(
+          new CustomEvent(id as string, { detail: data })
+        );
+      },
 
-function webMethod<
-  EventId extends string = string,
-  EventData = Record<EventId, any>
->(): MoonlightEventEmitter<EventId, EventData> {
-  const eventEmitter = new EventTarget();
-  const listeners = new Map<(data: EventData) => void, (e: Event) => void>();
+      addEventListener: <Id extends keyof EventData>(
+        id: Id,
+        cb: (data: EventData[Id]) => void
+      ) => {
+        const untyped = cb as (data: EventData) => void;
+        if (listeners.has(untyped)) return;
 
-  return {
-    dispatchEvent: <Id extends keyof EventData>(
-      id: Id,
-      data: EventData[Id]
-    ) => {
-      eventEmitter.dispatchEvent(
-        new CustomEvent(id as string, { detail: data })
-      );
-    },
+        function listener(e: Event) {
+          const event = e as CustomEvent<string>;
+          cb(event.detail as EventData[Id]);
+        }
 
-    addEventListener: <Id extends keyof EventData>(
-      id: Id,
-      cb: (data: EventData[Id]) => void
-    ) => {
-      const untyped = cb as (data: EventData) => void;
-      if (listeners.has(untyped)) return;
+        listeners.set(untyped, listener);
+        eventEmitter.addEventListener(id as string, listener);
+      },
 
-      function listener(e: Event) {
-        const event = e as CustomEvent<string>;
-        cb(event.detail as EventData[Id]);
+      removeEventListener: <Id extends keyof EventData>(
+        id: Id,
+        cb: (data: EventData[Id]) => void
+      ) => {
+        const untyped = cb as (data: EventData) => void;
+        const listener = listeners.get(untyped);
+        if (listener == null) return;
+        listeners.delete(untyped);
+        eventEmitter.removeEventListener(id as string, listener);
       }
+    };
+  }
 
-      listeners.set(untyped, listener);
-      eventEmitter.addEventListener(id as string, listener);
-    },
+  nodeTarget: {
+    const EventEmitter = require("events");
+    const eventEmitter = new EventEmitter();
+    const listeners = new Map<(data: EventData) => void, (e: Event) => void>();
 
-    removeEventListener: <Id extends keyof EventData>(
-      id: Id,
-      cb: (data: EventData[Id]) => void
-    ) => {
-      const untyped = cb as (data: EventData) => void;
-      const listener = listeners.get(untyped);
-      if (listener == null) return;
-      listeners.delete(untyped);
-      eventEmitter.removeEventListener(id as string, listener);
-    }
-  };
-}
+    return {
+      dispatchEvent: <Id extends keyof EventData>(
+        id: Id,
+        data: EventData[Id]
+      ) => {
+        eventEmitter.emit(id as string, data);
+      },
+
+      addEventListener: <Id extends keyof EventData>(
+        id: Id,
+        cb: (data: EventData[Id]) => void
+      ) => {
+        const untyped = cb as (data: EventData) => void;
+        if (listeners.has(untyped)) return;
 
-export function createEventEmitter<
-  EventId extends string = string,
-  EventData = Record<EventId, any>
->(): MoonlightEventEmitter<EventId, EventData> {
-  webPreload: {
-    return webMethod();
-  }
+        function listener(e: Event) {
+          const event = e as CustomEvent<string>;
+          cb(event as EventData[Id]);
+        }
 
-  nodePreload: {
-    return nodeMethod();
-  }
+        listeners.set(untyped, listener);
+        eventEmitter.on(id as string, listener);
+      },
 
-  injector: {
-    return nodeMethod();
+      removeEventListener: <Id extends keyof EventData>(
+        id: Id,
+        cb: (data: EventData[Id]) => void
+      ) => {
+        const untyped = cb as (data: EventData) => void;
+        const listener = listeners.get(untyped);
+        if (listener == null) return;
+        listeners.delete(untyped);
+        eventEmitter.off(id as string, listener);
+      }
+    };
   }
 
   throw new Error("Called createEventEmitter() in an impossible environment");

packages/core/src/util/logger.ts

···
 /* eslint-disable no-console */
 import { LogLevel } from "@moonlight-mod/types/logger";
-import { readConfig } from "../config";
+import { Config } from "@moonlight-mod/types";
 
 const colors = {
   [LogLevel.SILLY]: "#EDD3E9",
···
   [LogLevel.ERROR]: "#FF0000"
 };
 
-const config = readConfig();
 let maxLevel = LogLevel.INFO;
-if (config.loggerLevel != null) {
-  const enumValue =
-    LogLevel[config.loggerLevel.toUpperCase() as keyof typeof LogLevel];
-  if (enumValue != null) {
-    maxLevel = enumValue;
-  }
-}
 
 export default class Logger {
   private name: string;
···
     const logLevel = LogLevel[level].toUpperCase();
     if (maxLevel > level) return;
 
-    if (MOONLIGHT_WEB_PRELOAD) {
+    if (MOONLIGHT_WEB_PRELOAD || MOONLIGHT_BROWSER) {
       args = [
         `%c[${logLevel}]`,
         `background-color: ${colors[level]}; color: #FFFFFF;`,
···
     }
   }
 }
+
+export function initLogger(config: Config) {
+  if (config.loggerLevel != null) {
+    const enumValue =
+      LogLevel[config.loggerLevel.toUpperCase() as keyof typeof LogLevel];
+    if (enumValue != null) {
+      maxLevel = enumValue;
+    }
+  }
+}

packages/injector/src/index.ts

···
   app
 } from "electron";
 import Module from "node:module";
-import { constants } from "@moonlight-mod/types";
+import { constants, MoonlightBranch } from "@moonlight-mod/types";
 import { readConfig } from "@moonlight-mod/core/config";
 import { getExtensions } from "@moonlight-mod/core/extension";
-import Logger from "@moonlight-mod/core/util/logger";
+import Logger, { initLogger } from "@moonlight-mod/core/util/logger";
 import {
   loadExtensions,
   loadProcessedExtensions
···
 import EventEmitter from "node:events";
 import { join, resolve } from "node:path";
 import persist from "@moonlight-mod/core/persist";
+import createFS from "@moonlight-mod/core/fs";
 
 const logger = new Logger("injector");
 
 let oldPreloadPath: string | undefined;
 let corsAllow: string[] = [];
+let blockedUrls: RegExp[] = [];
 let isMoonlightDesktop = false;
 let hasOpenAsar = false;
 let openAsarConfigPreload: string | undefined;
···
   corsAllow = list;
 });
 
+const reEscapeRegExp = /[\\^$.*+?()[\]{}|]/g;
+const reMatchPattern =
+  /^(?<scheme>\*|[a-z][a-z0-9+.-]*):\/\/(?<host>.+?)\/(?<path>.+)?$/;
+
+const escapeRegExp = (s: string) => s.replace(reEscapeRegExp, "\\$&");
+ipcMain.handle(constants.ipcSetBlockedList, (_, list: string[]) => {
+  // We compile the patterns into a RegExp based on a janky match pattern-like syntax
+  const compiled = list
+    .map((pattern) => {
+      const match = pattern.match(reMatchPattern);
+      if (!match?.groups) return;
+
+      let regex = "";
+      if (match.groups.scheme === "*") regex += ".+?";
+      else regex += escapeRegExp(match.groups.scheme);
+      regex += ":\\/\\/";
+
+      const parts = match.groups.host.split(".");
+      if (parts[0] === "*") {
+        parts.shift();
+        regex += "(?:.+?\\.)?";
+      }
+      regex += escapeRegExp(parts.join("."));
+
+      regex += "\\/" + escapeRegExp(match.groups.path).replace("\\*", ".*?");
+
+      return new RegExp("^" + regex + "$");
+    })
+    .filter(Boolean) as RegExp[];
+
+  blockedUrls = compiled;
+});
+
 function patchCsp(headers: Record<string, string[]>) {
   const directives = [
     "style-src",
···
   constructor(opts: BrowserWindowConstructorOptions) {
     oldPreloadPath = opts.webPreferences!.preload;
 
-    // Only overwrite preload if its the actual main client window
-    if (opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1) {
+    const isMainWindow =
+      opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;
+
+    if (isMainWindow)
       opts.webPreferences!.preload = require.resolve("./node-preload.js");
-    }
 
     // Event for modifying window options
-    moonlightHost.events.emit("window-options", opts);
+    moonlightHost.events.emit("window-options", opts, isMainWindow);
 
     super(opts);
 
     // Event for when a window is created
-    moonlightHost.events.emit("window-created", this);
+    moonlightHost.events.emit("window-created", this, isMainWindow);
 
     this.webContents.session.webRequest.onHeadersReceived((details, cb) => {
       if (details.responseHeaders != null) {
···
       }
     });
 
+    // Allow plugins to block some URLs,
+    // this is needed because multiple webRequest handlers cannot be registered at once
+    this.webContents.session.webRequest.onBeforeRequest((details, cb) => {
+      cb({ cancel: blockedUrls.some((u) => u.test(details.url)) });
+    });
+
     if (hasOpenAsar) {
       // Remove DOM injections
       // Settings can still be opened via:
···
 
 export async function inject(asarPath: string) {
   isMoonlightDesktop = asarPath === "moonlightDesktop";
+  global.moonlightFS = createFS();
+
   try {
-    const config = readConfig();
-    const extensions = getExtensions();
+    const config = await readConfig();
+    initLogger(config);
+    const extensions = await getExtensions();
 
     // Duplicated in node-preload... oops
     // eslint-disable-next-line no-inner-declarations
···
         extensions: [],
         dependencyGraph: new Map()
       },
+
+      version: MOONLIGHT_VERSION,
+      branch: MOONLIGHT_BRANCH as MoonlightBranch,
 
       getConfig,
       getConfigOption: <T>(ext: string, name: string) => {

packages/node-preload/src/index.ts

···
 import { webFrame, ipcRenderer, contextBridge } from "electron";
-import fs from "fs";
-import path from "path";
+import fs from "node:fs";
+import path from "node:path";
 
 import { readConfig, writeConfig } from "@moonlight-mod/core/config";
-import { constants } from "@moonlight-mod/types";
+import { constants, MoonlightBranch } from "@moonlight-mod/types";
 import { getExtensions } from "@moonlight-mod/core/extension";
-import { getExtensionsPath } from "@moonlight-mod/core/util/data";
-import Logger from "@moonlight-mod/core/util/logger";
+import {
+  getExtensionsPath,
+  getMoonlightDir
+} from "@moonlight-mod/core/util/data";
+import Logger, { initLogger } from "@moonlight-mod/core/util/logger";
 import {
   loadExtensions,
   loadProcessedExtensions
 } from "@moonlight-mod/core/extension/loader";
+import createFS from "@moonlight-mod/core/fs";
 
 async function injectGlobals() {
-  const config = readConfig();
-  const extensions = getExtensions();
-  const processed = await loadExtensions(extensions);
+  global.moonlightFS = createFS();
+
+  const config = await readConfig();
+  initLogger(config);
+  const extensions = await getExtensions();
+  const processedExtensions = await loadExtensions(extensions);
+  const moonlightDir = await getMoonlightDir();
+  const extensionsPath = await getExtensionsPath();
 
   function getConfig(ext: string) {
     const val = config.extensions[ext];
···
 
   global.moonlightNode = {
     config,
-    extensions: getExtensions(),
-    processedExtensions: processed,
+    extensions,
+    processedExtensions,
     nativesCache: {},
+    isBrowser: false,
+
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH as MoonlightBranch,
+
     getConfig,
     getConfigOption: <T>(ext: string, name: string) => {
       const config = getConfig(ext);
···
       return new Logger(id);
     },
 
+    getMoonlightDir() {
+      return moonlightDir;
+    },
     getExtensionDir: (ext: string) => {
-      const extPath = getExtensionsPath();
-      return path.join(extPath, ext);
+      return path.join(extensionsPath, ext);
     },
     writeConfig
   };
 
-  await loadProcessedExtensions(processed);
+  await loadProcessedExtensions(processedExtensions);
   contextBridge.exposeInMainWorld("moonlightNode", moonlightNode);
 
-  const extCors = moonlightNode.processedExtensions.extensions
-    .map((x) => x.manifest.cors ?? [])
-    .flat();
+  const extCors = moonlightNode.processedExtensions.extensions.flatMap(
+    (x) => x.manifest.cors ?? []
+  );
 
   for (const repo of moonlightNode.config.repositories) {
     const url = new URL(repo);
···
   }
 
   ipcRenderer.invoke(constants.ipcSetCorsList, extCors);
+
+  const extBlocked = moonlightNode.processedExtensions.extensions.flatMap(
+    (e) => e.manifest.blocked ?? []
+  );
+  ipcRenderer.invoke(constants.ipcSetBlockedList, extBlocked);
 }
 
 async function loadPreload() {

packages/types/package.json

···
   },
   "dependencies": {
     "@moonlight-mod/lunast": "^1.0.0",
-    "@moonlight-mod/mappings": "^1.0.0",
+    "@moonlight-mod/mappings": "^1.0.2",
     "@moonlight-mod/moonmap": "^1.0.2",
     "@types/react": "^18.3.10",
     "csstype": "^3.1.2",

packages/types/src/constants.ts

···
 export const distDir = "dist";
 export const coreExtensionsDir = "core-extensions";
 export const repoUrlFile = ".moonlight-repo-url";
+export const installedVersionFile = ".moonlight-installed-version";
 
 export const ipcGetOldPreloadPath = "_moonlight_getOldPreloadPath";
 export const ipcGetAppData = "_moonlight_getAppData";
 export const ipcGetIsMoonlightDesktop = "_moonlight_getIsMoonlightDesktop";
 export const ipcMessageBox = "_moonlight_messageBox";
 export const ipcSetCorsList = "_moonlight_setCorsList";
+export const ipcSetBlockedList = "_moonlight_setBlockedList";
 
 export const apiLevel = 2;
+
+export const mainRepo =
+  "https://moonlight-mod.github.io/extensions-dist/repo.json";

packages/types/src/coreExtensions.ts

···
 export * as Settings from "./coreExtensions/settings";
 export * as Markdown from "./coreExtensions/markdown";
 export * as ContextMenu from "./coreExtensions/contextMenu";
+export * as Notices from "./coreExtensions/notices";
+export * as Moonbase from "./coreExtensions/moonbase";

packages/types/src/coreExtensions/moonbase.ts

···
+export type CustomComponent = React.FC<{
+  value: any;
+  setValue: (value: any) => void;
+}>;
+
+export type Moonbase = {
+  registerConfigComponent: (
+    ext: string,
+    option: string,
+    component: CustomComponent
+  ) => void;
+};

packages/types/src/coreExtensions/notices.ts

···
+import type { Store } from "@moonlight-mod/mappings/discord/packages/flux";
+
+export type NoticeButton = {
+  name: string;
+  onClick: () => boolean; // return true to dismiss the notice after the button is clicked
+};
+
+export type Notice = {
+  element: React.ReactNode;
+  color?: string;
+  showClose?: boolean;
+  buttons?: NoticeButton[];
+  onDismiss?: () => void;
+};
+
+export type Notices = Store<any> & {
+  addNotice: (notice: Notice) => void;
+  popNotice: () => void;
+  getCurrentNotice: () => Notice | null;
+  shouldShowNotice: () => boolean;
+};

packages/types/src/discord/require.ts

···
 import { Markdown } from "../coreExtensions/markdown";
 import { Settings } from "../coreExtensions/settings";
 import { Spacepack } from "../coreExtensions/spacepack";
+import { Notices } from "../coreExtensions/notices";
+import { Moonbase } from "../coreExtensions/moonbase";
 
 declare function WebpackRequire(id: string): any;
 
···
 declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;
 
 declare function WebpackRequire(id: "markdown_markdown"): Markdown;
+
+declare function WebpackRequire(id: "moonbase_moonbase"): Moonbase;
+
+declare function WebpackRequire(id: "notices_notices"): Notices;
 
 declare function WebpackRequire(id: "settings_settings"): {
   Settings: Settings;

packages/types/src/discord/webpack.ts

···
 import WebpackRequire from "./require";
+import { WebpackRequire as MappingsWebpackRequire } from "@moonlight-mod/mappings";
 
-export type WebpackRequireType = typeof WebpackRequire & {
-  c: Record<string, WebpackModule>;
-  m: Record<string, WebpackModuleFunc>;
-  e: (module: number | string) => Promise<void>;
-};
+export type WebpackRequireType = typeof MappingsWebpackRequire &
+  typeof WebpackRequire & {
+    c: Record<string, WebpackModule>;
+    m: Record<string, WebpackModuleFunc>;
+    e: (module: number | string) => Promise<void>;
+  };
 
 export type WebpackModule = {
   id: string | number;

packages/types/src/extension.ts

···
   id: string;
   version?: string;
   apiLevel?: number;
+  environment?: ExtensionEnvironment;
 
   meta?: {
     name?: string;
···
   incompatible?: string[];
 
   settings?: Record<string, ExtensionSettingsManifest>;
+
   cors?: string[];
+  blocked?: string[];
 };
+
+export enum ExtensionEnvironment {
+  Both = "both",
+  Desktop = "desktop",
+  Web = "web"
+}
 
 export enum ExtensionLoadSource {
   Developer,

packages/types/src/fs.ts

···
+export type MoonlightFS = {
+  readFile: (path: string) => Promise<Uint8Array>;
+  readFileString: (path: string) => Promise<string>;
+  writeFile: (path: string, data: Uint8Array) => Promise<void>;
+  writeFileString: (path: string, data: string) => Promise<void>;
+  unlink: (path: string) => Promise<void>;
+
+  readdir: (path: string) => Promise<string[]>;
+  mkdir: (path: string) => Promise<void>;
+  rmdir: (path: string) => Promise<void>;
+
+  exists: (path: string) => Promise<boolean>;
+  isFile: (path: string) => Promise<boolean>;
+
+  join: (...parts: string[]) => string;
+  dirname: (path: string) => string;
+};

packages/types/src/globals.ts

···
 import type EventEmitter from "events";
 import type LunAST from "@moonlight-mod/lunast";
 import type Moonmap from "@moonlight-mod/moonmap";
-import { EventPayloads, EventType, MoonlightEventEmitter } from "./core/event";
+import type {
+  EventPayloads,
+  EventType,
+  MoonlightEventEmitter
+} from "./core/event";
 
 export type MoonlightHost = {
   asarPath: string;
···
   extensions: DetectedExtension[];
   processedExtensions: ProcessedExtensions;
 
+  version: string;
+  branch: MoonlightBranch;
+
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
   getLogger: (id: string) => Logger;
···
   extensions: DetectedExtension[];
   processedExtensions: ProcessedExtensions;
   nativesCache: Record<string, any>;
+  isBrowser: boolean;
+
+  version: string;
+  branch: MoonlightBranch;
 
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
   getNatives: (ext: string) => any | undefined;
   getLogger: (id: string) => Logger;
 
+  getMoonlightDir: () => string;
   getExtensionDir: (ext: string) => string;
-  writeConfig: (config: Config) => void;
+  writeConfig: (config: Config) => Promise<void>;
 };
 
 export type MoonlightWeb = {
···
     registerPatch: (patch: IdentifiedPatch) => void;
     registerWebpackModule: (module: IdentifiedWebpackModule) => void;
   };
+
+  version: string;
+  branch: MoonlightBranch;
 
   getConfig: (ext: string) => ConfigExtension["config"];
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
···
   NodePreload = "node-preload",
   WebPreload = "web-preload"
 }
+
+export enum MoonlightBranch {
+  STABLE = "stable",
+  NIGHTLY = "nightly",
+  DEV = "dev"
+}

packages/types/src/import.d.ts

···
   export = Markdown;
 }
 
+declare module "@moonlight-mod/wp/moonbase_moonbase" {
+  import { CoreExtensions } from "@moonlight-mod/types";
+  const Moonbase: CoreExtensions.Moonbase.Moonbase;
+  export = Moonbase;
+}
+
+declare module "@moonlight-mod/wp/notices_notices" {
+  import { CoreExtensions } from "@moonlight-mod/types";
+  const Notices: CoreExtensions.Notices.Notices;
+  export = Notices;
+}
+
 declare module "@moonlight-mod/wp/settings_settings" {
   import { CoreExtensions } from "@moonlight-mod/types";
   export const Settings: CoreExtensions.Settings.Settings;

packages/types/src/index.ts

···
 /// <reference types="./mappings" />
 /* eslint-disable no-var */
 
+import { MoonlightFS } from "./fs";
 import {
   MoonlightEnv,
   MoonlightHost,
···
 export * from "./globals";
 export * from "./logger";
 export * as constants from "./constants";
+export * from "./fs";
 
 export type { AST } from "@moonlight-mod/lunast";
 export { ModuleExport, ModuleExportType } from "@moonlight-mod/moonmap";
···
   const MOONLIGHT_INJECTOR: boolean;
   const MOONLIGHT_NODE_PRELOAD: boolean;
   const MOONLIGHT_WEB_PRELOAD: boolean;
+  const MOONLIGHT_BROWSER: boolean;
+  const MOONLIGHT_BRANCH: string;
+  const MOONLIGHT_VERSION: string;
 
   var moonlightHost: MoonlightHost;
   var moonlightNode: MoonlightNode;
   var moonlight: MoonlightWeb;
+  var moonlightFS: MoonlightFS;
+
+  var _moonlightBrowserInit: () => Promise<void>;
+  var _moonlightBrowserLoad: () => Promise<void>;
 }

packages/web-preload/package.json

···
 {
   "name": "@moonlight-mod/web-preload",
   "private": true,
+  "main": "src/index.ts",
   "dependencies": {
     "@moonlight-mod/core": "workspace:*",
     "@moonlight-mod/lunast": "^1.0.0",
-    "@moonlight-mod/mappings": "^1.0.0",
+    "@moonlight-mod/mappings": "^1.0.2",
     "@moonlight-mod/moonmap": "^1.0.2",
     "@moonlight-mod/types": "workspace:*"
   }

packages/web-preload/src/index.ts

···
   registerPatch,
   registerWebpackModule
 } from "@moonlight-mod/core/patch";
-import { constants } from "@moonlight-mod/types";
+import { constants, MoonlightBranch } from "@moonlight-mod/types";
 import { installStyles } from "@moonlight-mod/core/styles";
-import Logger from "@moonlight-mod/core/util/logger";
+import Logger, { initLogger } from "@moonlight-mod/core/util/logger";
 import LunAST from "@moonlight-mod/lunast";
 import Moonmap from "@moonlight-mod/moonmap";
 import loadMappings from "@moonlight-mod/mappings";
 import { createEventEmitter } from "@moonlight-mod/core/util/event";
 import { EventPayloads, EventType } from "@moonlight-mod/types/core/event";
 
-(async () => {
+async function load() {
+  initLogger(moonlightNode.config);
   const logger = new Logger("web-preload");
 
   window.moonlight = {
···
       registerWebpackModule
     },
 
+    version: MOONLIGHT_VERSION,
+    branch: MOONLIGHT_BRANCH as MoonlightBranch,
+
     getConfig: moonlightNode.getConfig.bind(moonlightNode),
     getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),
     getNatives: moonlightNode.getNatives.bind(moonlightNode),
···
     logger.error("Error setting up web-preload", e);
   }
 
-  window.addEventListener("DOMContentLoaded", () => {
+  if (MOONLIGHT_ENV === "web-preload") {
+    window.addEventListener("DOMContentLoaded", () => {
+      installStyles();
+    });
+  } else {
     installStyles();
-  });
-})();
+  }
+}
+
+if (MOONLIGHT_ENV === "web-preload") {
+  load();
+} else {
+  window._moonlightBrowserLoad = load;
+}

pnpm-lock.yaml

···
         specifier: ^5.3.2
         version: 5.3.2
 
+  packages/browser:
+    dependencies:
+      '@moonlight-mod/core':
+        specifier: workspace:*
+        version: link:../core
+      '@moonlight-mod/types':
+        specifier: workspace:*
+        version: link:../types
+      '@moonlight-mod/web-preload':
+        specifier: workspace:*
+        version: link:../web-preload
+      '@zenfs/core':
+        specifier: ^1.0.2
+        version: 1.0.2
+      '@zenfs/dom':
+        specifier: ^0.2.16
+        version: 0.2.16(@zenfs/core@1.0.2)
+
   packages/core:
     dependencies:
       '@moonlight-mod/types':
···
 
   packages/core-extensions:
     dependencies:
-      '@electron/asar':
-        specifier: ^3.2.5
-        version: 3.2.5
+      '@moonlight-mod/core':
+        specifier: workspace:*
+        version: link:../core
       '@moonlight-mod/types':
         specifier: workspace:*
         version: link:../types
+      nanotar:
+        specifier: ^0.1.1
+        version: 0.1.1
 
   packages/injector:
     dependencies:
···
         specifier: ^1.0.0
         version: 1.0.0
       '@moonlight-mod/mappings':
-        specifier: ^1.0.0
-        version: 1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
+        specifier: ^1.0.2
+        version: 1.0.2(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
       '@moonlight-mod/moonmap':
         specifier: ^1.0.2
         version: 1.0.2
···
         specifier: ^1.0.0
         version: 1.0.0
       '@moonlight-mod/mappings':
-        specifier: ^1.0.0
-        version: 1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
+        specifier: ^1.0.2
+        version: 1.0.2(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
       '@moonlight-mod/moonmap':
         specifier: ^1.0.2
         version: 1.0.2
···
   '@aashutoshrathi/word-wrap@1.2.6':
     resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==}
     engines: {node: '>=0.10.0'}
-
-  '@electron/asar@3.2.5':
-    resolution: {integrity: sha512-Ypahc2ElTj9YOrFvUHuoXv5Z/V1nPA5enlhmQapc578m/HZBHKTbqhoL5JZQjje2+/6Ti5AHh7Gj1/haeJa63Q==}
-    engines: {node: '>=10.12.0'}
-    hasBin: true
 
   '@esbuild/android-arm64@0.19.3':
     resolution: {integrity: sha512-w+Akc0vv5leog550kjJV9Ru+MXMR2VuMrui3C61mnysim0gkFCPOUTAfzTP0qX+HpN9Syu3YA3p1hf3EPqObRw==}
···
   '@moonlight-mod/lunast@1.0.0':
     resolution: {integrity: sha512-kJgf41K12i6/2LbXK97CNO+pNO7ADGh9N4bCQcOPwosocKMcwKHDEZUgPqeihNshY3c3AEW1LiyXjlsl24PdDw==}
 
-  '@moonlight-mod/mappings@1.0.0':
-    resolution: {integrity: sha512-n6ybbTqFxXVKvTHcIGEtCS9208an6BFnTojK56giWE/bjuqq6DvFrk/0+C3ZRDEjgohGf/DuUKc9f0qe9UH6Rg==}
+  '@moonlight-mod/mappings@1.0.2':
+    resolution: {integrity: sha512-PjIv4LFyt3j4LyGiokUmJ6a0L5JljoLXjUkixCynLLpNLd660qTcLe8f9tbhOovvD8joqejq+f5oqSo2V4/Vfg==}
     peerDependencies:
       '@moonlight-mod/lunast': ^1.0.0
       '@moonlight-mod/moonmap': ^1.0.0
···
   '@types/node@18.17.17':
     resolution: {integrity: sha512-cOxcXsQ2sxiwkykdJqvyFS+MLQPLvIdwh5l6gNg8qF6s+C7XSkEWOZjK+XhUZd+mYvHV/180g2cnCcIl4l06Pw==}
 
+  '@types/node@20.16.10':
+    resolution: {integrity: sha512-vQUKgWTjEIRFCvK6CyriPH3MZYiYlNy0fKiEYHWbcoWLEgs4opurGGKlebrTLqdSMIbXImH6XExNiIyNUv3WpA==}
+
   '@types/prop-types@15.7.13':
     resolution: {integrity: sha512-hCZTSvwbzWGvhqxp/RqVqwU999pBf2vp7hzIjiYOsl8wqOmUxkQ6ddw1cV3l8811+kdUFus/q4d1Y3E3SyEifA==}
 
   '@types/react@18.3.10':
     resolution: {integrity: sha512-02sAAlBnP39JgXwkAq3PeU9DVaaGpZyF3MGcC0MKgQVkZor5IiiDAipVaxQHtDJAmO4GIy/rVBy/LzVj76Cyqg==}
+
+  '@types/readable-stream@4.0.15':
+    resolution: {integrity: sha512-oAZ3kw+kJFkEqyh7xORZOku1YAKvsFTogRY8kVl4vHpEKiDkfnSA/My8haRE7fvmix5Zyy+1pwzOi7yycGLBJw==}
 
   '@types/semver@7.5.6':
     resolution: {integrity: sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==}
···
   '@ungap/structured-clone@1.2.0':
     resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==}
 
+  '@zenfs/core@1.0.2':
+    resolution: {integrity: sha512-LMTD4ntn6Ag1y+IeOSVykDDvYC12dsGFtsX8M/54OQrLs7v+YnX4bpo0o2osbm8XFmU2MTNMX/G3PLsvzgWzrg==}
+    engines: {node: '>= 16'}
+    hasBin: true
+
+  '@zenfs/dom@0.2.16':
+    resolution: {integrity: sha512-6Ev+ol9hZIgQECNZR+xxjQ/a99EhhrWeiQttm/+U7YJK3HdTjiKfU39DsfGeH64vSqhpa5Vj+LWRx75SHkjw0Q==}
+    engines: {node: '>= 18'}
+    peerDependencies:
+      '@zenfs/core': ^1.0.0
+
+  abort-controller@3.0.0:
+    resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
+    engines: {node: '>=6.5'}
+
   acorn-jsx@5.3.2:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
···
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
   big-integer@1.6.52:
     resolution: {integrity: sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==}
     engines: {node: '>=0.6'}
···
   brace-expansion@1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
 
+  brace-expansion@2.0.1:
+    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+
   braces@3.0.2:
     resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
     engines: {node: '>=8'}
 
+  buffer@6.0.3:
+    resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
+
   bundle-name@3.0.0:
     resolution: {integrity: sha512-PKA4BeSvBpQKQ8iPOGCSiell+N8P+Tf1DlwqmYhpe2gAhKPHn8EYOxVT+ShuGmhg8lN8XiSlS80yiExKXrURlw==}
     engines: {node: '>=12'}
···
 
   color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
-
-  commander@5.1.0:
-    resolution: {integrity: sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==}
-    engines: {node: '>= 6'}
 
   concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
···
   eslint@8.55.0:
     resolution: {integrity: sha512-iyUUAM0PCKj5QpwGfmCAG9XXbZCWsqP/eWAWrG/W0umvjuLRBECwSFdt+rCntju0xEH7teIABPwXpahftIaTdA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
 
   espree@9.6.1:
···
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
 
+  event-target-shim@5.0.1:
+    resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
+    engines: {node: '>=6'}
+
+  eventemitter3@5.0.1:
+    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
+
+  events@3.3.0:
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
+
   execa@5.1.1:
     resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
     engines: {node: '>=10'}
···
     engines: {node: '>=14'}
     hasBin: true
 
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
   ignore@5.3.0:
     resolution: {integrity: sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg==}
     engines: {node: '>= 4'}
···
   minimatch@3.1.2:
     resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
 
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
   ms@2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
+  nanotar@0.1.1:
+    resolution: {integrity: sha512-AiJsGsSF3O0havL1BydvI4+wR76sKT+okKRwWIaK96cZUnXqH0uNBOsHlbwZq3+m2BR1VKqHDVudl3gO4mYjpQ==}
 
   natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
···
     engines: {node: '>=14'}
     hasBin: true
 
+  process@0.11.10:
+    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
+    engines: {node: '>= 0.6.0'}
+
   prop-types@15.8.1:
     resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
 
···
   react-is@16.13.1:
     resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
 
+  readable-stream@4.5.2:
+    resolution: {integrity: sha512-yjavECdqeZ3GLXNgRXgeQEdz9fvDDkNKyHnbHRFtOr7/LcfgBcmct7t/ET+HaCTqfh06OzoAxrkN/IfjJBVe+g==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
   reflect.getprototypeof@1.0.4:
     resolution: {integrity: sha512-ECkTw8TmJwW60lOTR+ZkODISW6RQ8+2CL3COqtiJKLd6MmB45hN51HprHFziKLGkAuTGQhBb91V8cy+KHlaCjw==}
     engines: {node: '>= 0.4'}
···
     resolution: {integrity: sha512-6XbUAseYE2KtOuGueyeobCySj9L4+66Tn6KQMOPQJrAJEowYKW/YR/MGJZl7FdydUdaFu4LYyDZjxf4/Nmo23Q==}
     engines: {node: '>=0.4'}
 
+  safe-buffer@5.1.2:
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
   safe-regex-test@1.0.0:
     resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==}
 
···
 
   string.prototype.trimstart@1.0.7:
     resolution: {integrity: sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
 
   strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
···
   unbox-primitive@1.0.2:
     resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==}
 
+  undici-types@6.19.8:
+    resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==}
+
   untildify@4.0.0:
     resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
     engines: {node: '>=8'}
 
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  utilium@0.7.1:
+    resolution: {integrity: sha512-2ocvTkI7U8LERmwxL0LhFUvEfN66UqcjF6tMiURvUwSyU7U1QC9gST+3iSUSiGccFfnP3f2EXwHNXOnOzx+lAg==}
 
   which-boxed-primitive@1.0.2:
     resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==}
···
 snapshots:
 
   '@aashutoshrathi/word-wrap@1.2.6': {}
-
-  '@electron/asar@3.2.5':
-    dependencies:
-      commander: 5.1.0
-      glob: 7.2.3
-      minimatch: 3.1.2
 
   '@esbuild/android-arm64@0.19.3':
     optional: true
···
       estree-toolkit: 1.7.8
       meriyah: 6.0.1
 
-  '@moonlight-mod/mappings@1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)':
+  '@moonlight-mod/mappings@1.0.2(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)':
     dependencies:
       '@moonlight-mod/lunast': 1.0.0
       '@moonlight-mod/moonmap': 1.0.2
···
 
   '@types/node@18.17.17': {}
 
+  '@types/node@20.16.10':
+    dependencies:
+      undici-types: 6.19.8
+
   '@types/prop-types@15.7.13': {}
 
   '@types/react@18.3.10':
     dependencies:
       '@types/prop-types': 15.7.13
       csstype: 3.1.3
+
+  '@types/readable-stream@4.0.15':
+    dependencies:
+      '@types/node': 20.16.10
+      safe-buffer: 5.1.2
 
   '@types/semver@7.5.6': {}
 
···
 
   '@ungap/structured-clone@1.2.0': {}
 
+  '@zenfs/core@1.0.2':
+    dependencies:
+      '@types/node': 20.16.10
+      '@types/readable-stream': 4.0.15
+      buffer: 6.0.3
+      eventemitter3: 5.0.1
+      minimatch: 9.0.5
+      readable-stream: 4.5.2
+      utilium: 0.7.1
+
+  '@zenfs/dom@0.2.16(@zenfs/core@1.0.2)':
+    dependencies:
+      '@zenfs/core': 1.0.2
+
+  abort-controller@3.0.0:
+    dependencies:
+      event-target-shim: 5.0.1
+
   acorn-jsx@5.3.2(acorn@8.12.1):
     dependencies:
       acorn: 8.12.1
···
 
   balanced-match@1.0.2: {}
 
+  base64-js@1.5.1: {}
+
   big-integer@1.6.52: {}
 
   bplist-parser@0.2.0:
···
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
+
+  brace-expansion@2.0.1:
+    dependencies:
+      balanced-match: 1.0.2
 
   braces@3.0.2:
     dependencies:
       fill-range: 7.0.1
 
+  buffer@6.0.3:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
   bundle-name@3.0.0:
     dependencies:
       run-applescript: 5.0.0
···
 
   color-name@1.1.4: {}
 
-  commander@5.1.0: {}
-
   concat-map@0.0.1: {}
 
   cross-spawn@7.0.3:
···
       '@types/estree-jsx': 1.0.5
 
   esutils@2.0.3: {}
+
+  event-target-shim@5.0.1: {}
+
+  eventemitter3@5.0.1: {}
+
+  events@3.3.0: {}
 
   execa@5.1.1:
     dependencies:
···
 
   husky@8.0.3: {}
 
+  ieee754@1.2.1: {}
+
   ignore@5.3.0: {}
 
   import-fresh@3.3.0:
···
   minimatch@3.1.2:
     dependencies:
       brace-expansion: 1.1.11
+
+  minimatch@9.0.5:
+    dependencies:
+      brace-expansion: 2.0.1
 
   ms@2.1.2: {}
 
+  nanotar@0.1.1: {}
+
   natural-compare@1.4.0: {}
 
   npm-run-path@4.0.1:
···
 
   prettier@3.1.0: {}
 
+  process@0.11.10: {}
+
   prop-types@15.8.1:
     dependencies:
       loose-envify: 1.4.0
···
   queue-microtask@1.2.3: {}
 
   react-is@16.13.1: {}
+
+  readable-stream@4.5.2:
+    dependencies:
+      abort-controller: 3.0.0
+      buffer: 6.0.3
+      events: 3.3.0
+      process: 0.11.10
+      string_decoder: 1.3.0
 
   reflect.getprototypeof@1.0.4:
     dependencies:
···
       has-symbols: 1.0.3
       isarray: 2.0.5
 
+  safe-buffer@5.1.2: {}
+
+  safe-buffer@5.2.1: {}
+
   safe-regex-test@1.0.0:
     dependencies:
       call-bind: 1.0.5
···
       call-bind: 1.0.5
       define-properties: 1.2.1
       es-abstract: 1.22.3
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
 
   strip-ansi@6.0.1:
     dependencies:
···
       has-symbols: 1.0.3
       which-boxed-primitive: 1.0.2
 
+  undici-types@6.19.8: {}
+
   untildify@4.0.0: {}
 
   uri-js@4.4.1:
     dependencies:
       punycode: 2.3.1
+
+  utilium@0.7.1:
+    dependencies:
+      eventemitter3: 5.0.1
 
   which-boxed-primitive@1.0.2:
     dependencies:

scripts/link.js

···
+// Janky script to get around pnpm link issues
+// Probably don't use this. Probably
+/* eslint-disable no-console */
+const fs = require("fs");
+const path = require("path");
+const child_process = require("child_process");
+
+const onDisk = {
+  "@moonlight-mod/lunast": "../lunast",
+  "@moonlight-mod/moonmap": "../moonmap",
+  "@moonlight-mod/mappings": "../mappings"
+};
+
+function exec(cmd, dir) {
+  child_process.execSync(cmd, { cwd: dir, stdio: "inherit" });
+}
+
+function getDeps(packageJSON) {
+  const ret = {};
+  Object.assign(ret, packageJSON.dependencies || {});
+  Object.assign(ret, packageJSON.devDependencies || {});
+  Object.assign(ret, packageJSON.peerDependencies || {});
+  return ret;
+}
+
+function link(dir) {
+  const packageJSON = JSON.parse(
+    fs.readFileSync(path.join(dir, "package.json"), "utf8")
+  );
+  const deps = getDeps(packageJSON);
+
+  for (const [dep, path] of Object.entries(onDisk)) {
+    if (deps[dep]) {
+      exec(`pnpm link ${path}`, dir);
+    }
+  }
+}
+
+function undo(dir) {
+  exec("pnpm unlink", dir);
+  try {
+    exec("git restore pnpm-lock.yaml", dir);
+  } catch {
+    // ignored
+  }
+}
+
+const shouldUndo = process.argv.includes("--undo");
+const packages = fs.readdirSync("./packages");
+
+for (const path of Object.values(onDisk)) {
+  console.log(path);
+  if (shouldUndo) {
+    undo(path);
+  } else {
+    link(path);
+  }
+}
+
+if (shouldUndo) {
+  const dir = __dirname;
+  console.log(dir);
+  undo(dir);
+} else {
+  for (const pkg of packages) {
+    const dir = path.join(__dirname, "packages", pkg);
+    console.log(dir);
+    link(dir);
+  }
+}

scripts/update.js

···
+// Update dependencies in all packages
+/* eslint-disable no-console */
+const fs = require("fs");
+const path = require("path");
+const child_process = require("child_process");
+
+const packageToUpdate = process.argv[2];
+
+function getDeps(packageJSON) {
+  const ret = {};
+  Object.assign(ret, packageJSON.dependencies || {});
+  Object.assign(ret, packageJSON.devDependencies || {});
+  Object.assign(ret, packageJSON.peerDependencies || {});
+  return ret;
+}
+
+function exec(cmd, dir) {
+  child_process.execSync(cmd, { cwd: dir, stdio: "inherit" });
+}
+
+for (const package of fs.readdirSync("./packages")) {
+  const packageJSON = JSON.parse(
+    fs.readFileSync(path.join("./packages", package, "package.json"), "utf8")
+  );
+
+  const deps = getDeps(packageJSON);
+  if (Object.keys(deps).includes(packageToUpdate)) {
+    console.log(`Updating ${packageToUpdate} in ${package}`);
+    exec(`pnpm update ${packageToUpdate}`, path.join("./packages", package));
+  }
+}