feat: dynamic pp calculator switching

packages/common/utils/config.ts

@@ -33,6 +33,10 @@ const defaultSchema: ConfigSchema = {
         binding: 'CALCULATE_PP',
         default: true
     },
+    ppChannel: {
+        binding: 'PP_CHANNEL',
+        default: 'latest'
+    },
     enableKeyOverlay: {
         binding: 'ENABLE_KEY_OVERLAY',
         default: true

packages/common/utils/config.types.ts

@@ -23,6 +23,12 @@ export interface Config {
         binding: 'CALCULATE_PP';
     };
 
+    // The channel to use for calculating performance points data.
+    ppChannel: {
+        type: string;
+        binding: 'PP_CHANNEL';
+    };
+
     // Whether tosu should read osu!'s built-in key overlay data.
     enableKeyOverlay: {
         type: boolean;

packages/pp-module-loader/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "@tosu/pp-module-loader",
+    "version": "0.1.0",
+    "type": "module",
+    "description": "Load and manage pp calculators",
+    "main": "src/index.ts",
+    "scripts": {},
+    "dependencies": {
+        "@tosu/common": "workspace:*",
+        "@tosuapp/lazer-calculator-prebuilt": "0.5.0-20260715-main.0",
+        "semver": "catalog:",
+        "tar": "^7.5.16"
+    },
+    "devDependencies": {
+        "@types/node": "^24.10.4",
+        "@types/semver": "^7.7.1"
+    }
+}

packages/pp-module-loader/src/downloader.ts

@@ -0,0 +1,58 @@
+import { downloadFile, getCachePath, verifyDownload } from '@tosu/common';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as tar from 'tar';
+
+import { getPrebuiltPackageName } from './package';
+import type { NpmPackageDist } from './registry/types';
+
+export async function downloadCalculator(
+    version: string,
+    fetchDist: () => Promise<NpmPackageDist> | NpmPackageDist
+): Promise<string> {
+    const packageName = getPrebuiltPackageName();
+
+    const calculatorRootPath = getCalculatorPath();
+    const folderPath = path.join(
+        calculatorRootPath,
+        `${packageName}-${version}`
+    );
+    const archivePath = path.join(
+        calculatorRootPath,
+        `${packageName}-${version}.tgz`
+    );
+
+    if (await fs.stat(folderPath).catch(() => false)) {
+        return folderPath;
+    }
+
+    const dist = await fetchDist();
+    await fs.mkdir(calculatorRootPath, { recursive: true });
+    try {
+        await downloadFile(dist.tarball, archivePath);
+
+        if (!(await verifyDownload(`sha1:${dist.shasum}`, archivePath))) {
+            await fs.rm(archivePath);
+            throw new Error('Download verification failed.');
+        }
+
+        await fs.mkdir(folderPath, { recursive: true });
+        await tar.x({
+            file: archivePath,
+            cwd: folderPath,
+            strip: 1
+        });
+    } catch (err) {
+        await fs.rm(folderPath, { recursive: true, force: true });
+
+        throw err;
+    } finally {
+        await fs.rm(archivePath, { force: true });
+    }
+
+    return folderPath;
+}
+
+function getCalculatorPath(): string {
+    return path.join(getCachePath(), 'calculators');
+}

packages/pp-module-loader/src/index.ts

@@ -0,0 +1,101 @@
+import { wLogger } from '@tosu/common';
+import * as internalCalculator from '@tosuapp/lazer-calculator-prebuilt';
+import EventEmitter from 'node:events';
+import { resolve } from 'node:path';
+
+import { downloadCalculator } from './downloader';
+import { isCompatibleVersion } from './package';
+import { onlinePpRegistry } from './registry';
+
+export type LazerCalculator =
+    typeof import('@tosuapp/lazer-calculator-prebuilt');
+
+export type PpModule =
+    | { type: 'internal' }
+    | { type: 'dist-tag'; tag: string }
+    | { type: 'release'; version: string }
+    | { type: 'local'; path: string };
+
+let currentCalculator = internalCalculator;
+
+const ppModuleManager = {
+    events: new EventEmitter<{ changed: [] }>(),
+
+    get current(): LazerCalculator {
+        return currentCalculator;
+    },
+
+    async load(module: PpModule): Promise<void> {
+        try {
+            currentCalculator = await resolveCalculator(module);
+            wLogger.info('Successfully loaded external pp calculator.');
+        } catch (err) {
+            wLogger.error(
+                'Failed to load external pp calculator. Falling back to internal pp calculator.'
+            );
+            wLogger.debug('Failed to load pp calculator:', err);
+            currentCalculator = internalCalculator;
+        }
+
+        this.events.emit('changed');
+    }
+};
+
+async function resolveCalculator(module: PpModule): Promise<LazerCalculator> {
+    switch (module.type) {
+        case 'internal': {
+            wLogger.info('Using internal pp calculator');
+            return internalCalculator;
+        }
+
+        case 'dist-tag': {
+            wLogger.info(
+                `Loading external pp calculator. channel: ${module.tag}`
+            );
+
+            const pkg = await onlinePpRegistry.fetch(module.tag);
+            if (!isCompatibleVersion(pkg.version)) {
+                const msg = `Incompatible pp calculator. channel: ${module.tag}`;
+                wLogger.error(msg);
+
+                throw new Error(msg);
+            }
+
+            return loadCalculator(
+                await downloadCalculator(pkg.version, () => pkg.dist)
+            );
+        }
+
+        case 'release': {
+            wLogger.info(
+                `Loading external pp calculator. version: ${module.version}`
+            );
+
+            if (!isCompatibleVersion(module.version)) {
+                const msg = `Incompatible pp calculator. version: ${module.version}`;
+                wLogger.error(msg);
+
+                throw new Error(msg);
+            }
+
+            return loadCalculator(
+                await downloadCalculator(module.version, async () => {
+                    const pkg = await onlinePpRegistry.fetch(module.version);
+                    return pkg.dist;
+                })
+            );
+        }
+
+        case 'local': {
+            wLogger.info(`Loading local pp calculator. path: ${module.path}`);
+
+            return loadCalculator(module.path);
+        }
+    }
+}
+
+function loadCalculator(path: string): LazerCalculator {
+    return require(resolve(process.cwd(), path)) as LazerCalculator;
+}
+
+export { ppModuleManager, onlinePpRegistry };

packages/pp-module-loader/src/package.ts

@@ -0,0 +1,33 @@
+import * as semver from 'semver';
+
+import { dependencies } from '../package.json';
+
+const CALCULATOR_VERSION = new semver.SemVer(
+    dependencies['@tosuapp/lazer-calculator-prebuilt']
+);
+
+const PLATFORM_KEY = `${process.platform}-${process.arch}`;
+const VERSION_RANGE = `^${CALCULATOR_VERSION.version}`;
+
+export function getFullPrebuiltPackageName() {
+    return `@tosuapp/${getPrebuiltPackageName()}`;
+}
+
+export function isCompatibleVersion(version: string): boolean {
+    return semver.satisfies(version, VERSION_RANGE, {
+        includePrerelease: true
+    });
+}
+
+export function getPrebuiltPackageName() {
+    switch (PLATFORM_KEY) {
+        case 'win32-x64':
+            return 'lazer-calculator-win32-x64';
+
+        case 'linux-x64':
+            return 'lazer-calculator-linux-x64';
+
+        default:
+            throw new Error(`Unsupported platform: ${PLATFORM_KEY}`);
+    }
+}

packages/pp-module-loader/src/registry/index.ts

@@ -0,0 +1,39 @@
+import type { PpModule } from '..';
+import { getFullPrebuiltPackageName, isCompatibleVersion } from '../package';
+import type { NpmPackage, NpmPackageVersion } from './types';
+
+export const onlinePpRegistry = {
+    async fetchAll(): Promise<PpModule[]> {
+        const pkg = await npmFetch<NpmPackage>(getFullPrebuiltPackageName());
+
+        const list: PpModule[] = [];
+
+        for (const version in pkg.versions) {
+            if (!isCompatibleVersion(version)) continue;
+
+            list.push({ type: 'release', version });
+        }
+
+        for (const tag in pkg['dist-tags']) {
+            const version = pkg['dist-tags'][tag];
+            if (!isCompatibleVersion(version)) continue;
+
+            list.push({ type: 'dist-tag', tag });
+        }
+
+        return list;
+    },
+
+    fetch(specifier: string): Promise<NpmPackageVersion> {
+        return npmFetch<NpmPackageVersion>(
+            `${getFullPrebuiltPackageName()}/${specifier}`
+        );
+    }
+};
+
+async function npmFetch<T>(path: string): Promise<T> {
+    const res = await fetch(new URL(path, 'https://registry.npmjs.org/'));
+    const json = await res.json();
+
+    return json as T;
+}

packages/pp-module-loader/src/registry/types.ts

@@ -0,0 +1,15 @@
+export interface NpmPackage {
+    'dist-tags': Record<string, string>;
+    versions: Record<string, NpmPackageVersion>;
+}
+
+export interface NpmPackageVersion {
+    name: string;
+    version: string;
+    dist: NpmPackageDist;
+}
+
+export interface NpmPackageDist {
+    shasum: string;
+    tarball: string;
+}

packages/pp-module-loader/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": [
+    "./src",
+    "types.ts"
+  ]
+}

packages/pp-module-loader/types.ts

@@ -0,0 +1 @@
+export type * from '@tosuapp/lazer-calculator-prebuilt';

packages/server/assets/homepage.js

@@ -953,7 +953,8 @@ document.querySelectorAll('.text-input input').forEach((i) =>
 document.querySelectorAll('.textarea-input textarea')
   .forEach((i) => i.addEventListener('change', () => checkSettingsChanges()));
 
-
+document.querySelectorAll('.select-input select')
+  .forEach((i) => i.addEventListener('change', () => checkSettingsChanges()));
 
 const isNumberValid = (num) => {
   if (typeof num === 'number') return num - num === 0;
@@ -963,7 +964,7 @@ const isNumberValid = (num) => {
 };
 
 const checkSettingsChanges = () => {
-  const settings = document.querySelectorAll('.settings input, .settings textarea');
+  const settings = document.querySelectorAll('.settings input, .settings textarea, .settings select');
 
   const hasChanges = Array.from(settings).some((s) => {
     const currentValue = s.type === 'checkbox' ? s.checked : s.value;
@@ -1333,7 +1334,7 @@ async function saveSettings() {
     let settings = {};
 
     document.querySelectorAll('.settings *[data-id]').forEach((s) => {
-        const input = s.querySelector('input, textarea');
+        const input = s.querySelector('input, textarea, select');
         if (!input) return;
 
           const value = input.type == 'checkbox' ? input.checked : input.value;

packages/server/assets/homepage.scss

@@ -981,6 +981,60 @@ a {
     }
   }
 
+  .select-input {
+    display: flex;
+    align-items: center;
+    background-color: #242d37;
+    border-radius: 0.3em;
+    width: fit-content;
+    height: fit-content;
+
+    select {
+      display: flex;
+      padding: 0 0.6em;
+      border: 0;
+      outline: 0;
+      font-size: 1rem;
+      width: fit-content;
+      min-width: 5rem;
+      max-width: 40rem;
+      height: fit-content;
+      min-height: 2rem;
+      max-height: 10rem;
+      field-sizing: content;
+      line-height: 1.7rem;
+      font-family: monospace;
+      text-align: center;
+      font-weight: bold;
+      background: transparent;
+      color: var(--block-color-1);
+
+      option {
+        background-color: var(--background-1)
+      }
+    }
+
+    &:hover,
+    &:focus-within {
+      select {
+        color: #6593c5;
+      }
+    }
+  }
+
+  .settings-item-v2:has(div > .select-input) {
+    & div>p {
+      color: #6593c5;
+      font-weight: bold;
+      opacity: 100%;
+      margin-right: 0.4rem;
+    }
+
+    & p {
+      opacity: 70%;
+    }
+  }
+
   .settings-save-button {
     position: sticky;
     bottom: 2rem;