@steambrew/ttc 2.8.7 → 3.0.1

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import chalk from 'chalk';
+import fs, { readFileSync, existsSync, readFile as readFile$1 } from 'fs';
 import path, { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { readFile } from 'fs/promises';
-import fs, { existsSync, readFile as readFile$1 } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { readFile, access } from 'fs/promises';
 import babel from '@rollup/plugin-babel';
 import commonjs from '@rollup/plugin-commonjs';
 import json from '@rollup/plugin-json';
@@ -12,8 +12,8 @@ import replace from '@rollup/plugin-replace';
 import terser from '@rollup/plugin-terser';
 import typescript from '@rollup/plugin-typescript';
 import url from '@rollup/plugin-url';
-import { rollup } from 'rollup';
 import nodePolyfills from 'rollup-plugin-polyfill-node';
+import { rollup } from 'rollup';
 import { minify_sync } from 'terser';
 import scss from 'rollup-plugin-scss';
 import * as sass from 'sass';
@@ -26,57 +26,53 @@ import MagicString from 'magic-string';
 import _traverse from '@babel/traverse';
 import { performance as performance$1 } from 'perf_hooks';
 
+const version = JSON.parse(readFileSync(path.resolve(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf8')).version;
 const Logger = {
-    Info: (name, ...LogMessage) => {
-        console.log(chalk.magenta.bold(name), ...LogMessage);
+    warn(message, loc) {
+        if (loc) {
+            console.warn(`${chalk.dim(loc + ':')} ${message}`);
+        }
+        else {
+            console.warn(`${chalk.yellow('warning:')} ${message}`);
+        }
     },
-    Warn: (...LogMessage) => {
-        console.log(chalk.yellow.bold('**'), ...LogMessage);
+    error(message, loc) {
+        if (loc) {
+            console.error(`${chalk.red(loc + ':')} ${message}`);
+        }
+        else {
+            console.error(`${chalk.red('error:')} ${message}`);
+        }
     },
-    Error: (...LogMessage) => {
-        console.error(chalk.red.bold('!!'), ...LogMessage);
+    update(current, latest, installCmd) {
+        console.log(`\n${chalk.yellow('update available')} ${chalk.dim(current)} → ${chalk.green(latest)}`);
+        console.log(`${chalk.dim('run:')} ${installCmd}\n`);
     },
-    Tree: (name, strTitle, LogObject) => {
-        const fixedPadding = 15; // <-- always pad keys to 15 characters
-        console.log(chalk.greenBright.bold(name).padEnd(fixedPadding), strTitle);
-        const isLocalPath = (strTestPath) => {
-            const filePathRegex = /^(\/|\.\/|\.\.\/|\w:\/)?([\w-.]+\/)*[\w-.]+\.\w+$/;
-            return filePathRegex.test(strTestPath);
-        };
-        for (const [key, value] of Object.entries(LogObject)) {
-            let color = chalk.white;
-            switch (typeof value) {
-                case 'string':
-                    color = isLocalPath(value) ? chalk.blueBright : chalk.white;
-                    break;
-                case 'boolean':
-                    color = chalk.green;
-                    break;
-                case 'number':
-                    color = chalk.yellow;
-                    break;
-            }
-            console.log(chalk.greenBright.bold(`${key}:        `).padEnd(fixedPadding), color(String(value)));
-        }
+    done({ elapsedMs, buildType, sysfsCount, envCount }) {
+        const elapsed = `${(elapsedMs / 1000).toFixed(2)}s`;
+        const meta = [`ttc v${version}`];
+        if (buildType === 'dev')
+            meta.push('no type checking');
+        if (sysfsCount)
+            meta.push(`${sysfsCount} constSysfsExpr`);
+        if (envCount)
+            meta.push(`${envCount} env var${envCount > 1 ? 's' : ''}`);
+        console.log(`${chalk.green('Finished')} ${buildType} in ${elapsed} ` + chalk.dim('(' + meta.join(', ') + ')'));
     },
 };
 
-/***
- * @brief print the parameter list to the stdout
- */
 const PrintParamHelp = () => {
-    console.log('millennium-ttc parameter list:' +
-        '\n\t' +
-        chalk.magenta('--help') +
-        ': display parameter list' +
-        '\n\t' +
-        chalk.bold.red('--build') +
-        ': ' +
-        chalk.bold.red('(required)') +
-        ': build type [dev, prod] (prod minifies code)' +
-        '\n\t' +
-        chalk.magenta('--target') +
-        ': path to plugin, default to cwd');
+    console.log([
+        '',
+        'usage: millennium-ttc --build <dev|prod> [options]',
+        '',
+        'options:',
+        '  --build <dev|prod>   build type (prod enables minification)',
+        '  --target <path>      plugin directory (default: current directory)',
+        '  --no-update          skip update check',
+        '  --help               show this message',
+        '',
+    ].join('\n'));
 };
 var BuildType;
 (function (BuildType) {
@@ -89,9 +85,8 @@ const ValidateParameters = (args) => {
         PrintParamHelp();
         process.exit();
     }
-    // startup args are invalid
     if (!args.includes('--build')) {
-        Logger.Error('Received invalid arguments...');
+        Logger.error('missing required argument: --build');
         PrintParamHelp();
         process.exit();
     }
@@ -106,14 +101,14 @@ const ValidateParameters = (args) => {
                     typeProp = BuildType.ProdBuild;
                     break;
                 default: {
-                    Logger.Error('--build parameter must be preceded by build type [dev, prod]');
+                    Logger.error('--build must be one of: dev, prod');
                     process.exit();
                 }
             }
         }
         if (args[i] == '--target') {
             if (args[i + 1] === undefined) {
-                Logger.Error('--target parameter must be preceded by system path');
+                Logger.error('--target requires a path argument');
                 process.exit();
             }
             targetProp = args[i + 1];
@@ -129,40 +124,61 @@ const ValidateParameters = (args) => {
     };
 };
 
+async function fileExists(filePath) {
+    return access(filePath).then(() => true).catch(() => false);
+}
+async function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent ?? '';
+    if (userAgent.startsWith('bun'))
+        return 'bun';
+    if (userAgent.startsWith('pnpm'))
+        return 'pnpm';
+    if (userAgent.startsWith('yarn'))
+        return 'yarn';
+    const cwd = process.cwd();
+    if (await fileExists(path.join(cwd, 'bun.lock')) || await fileExists(path.join(cwd, 'bun.lockb')))
+        return 'bun';
+    if (await fileExists(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (await fileExists(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function installCommand(pm, pkg) {
+    switch (pm) {
+        case 'bun': return `bun add -d ${pkg}`;
+        case 'pnpm': return `pnpm add -D ${pkg}`;
+        case 'yarn': return `yarn add -D ${pkg}`;
+        default: return `npm i -D ${pkg}`;
+    }
+}
 const CheckForUpdates = async () => {
-    return new Promise(async (resolve) => {
+    try {
         const packageJsonPath = path.resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
         const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
-        fetch('https://registry.npmjs.org/@steambrew/ttc')
-            .then((response) => response.json())
-            .then((json) => {
-            if (json?.['dist-tags']?.latest != packageJson.version) {
-                Logger.Tree('versionMon', `@steambrew/ttc@${packageJson.version} requires update to ${json?.['dist-tags']?.latest}`, {
-                    cmd: `run "npm install @steambrew/ttc@${json?.['dist-tags']?.latest}" to get latest updates!`,
-                });
-                resolve(true);
-            }
-            else {
-                Logger.Info('versionMon', `@steambrew/ttc@${packageJson.version} is up-to-date!`);
-                resolve(false);
-            }
-        })
-            .catch((exception) => {
-            Logger.Error('Failed to check for updates: ' + exception);
-            resolve(false);
-        });
-    });
+        const response = await fetch('https://registry.npmjs.org/@steambrew/ttc');
+        const json = await response.json();
+        const latest = json?.['dist-tags']?.latest;
+        if (latest && latest !== packageJson.version) {
+            const pm = await detectPackageManager();
+            Logger.update(packageJson.version, latest, installCommand(pm, `@steambrew/ttc@${latest}`));
+            return true;
+        }
+    }
+    catch {
+        // network or parse failure — silently skip
+    }
+    return false;
 };
 
 const ValidatePlugin = (bIsMillennium, target) => {
     return new Promise((resolve, reject) => {
         if (!existsSync(target)) {
-            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red('is not a valid system path'));
+            Logger.error(`target path does not exist: ${target}`);
             reject();
             return;
         }
         if (bIsMillennium) {
-            console.log(chalk.green.bold('\n[+] Using Millennium internal build configuration'));
             resolve({
                 name: 'core',
                 common_name: 'Millennium',
@@ -174,27 +190,28 @@ const ValidatePlugin = (bIsMillennium, target) => {
         }
         const pluginModule = path.join(target, 'plugin.json');
         if (!existsSync(pluginModule)) {
-            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red('is not a valid plugin (missing plugin.json)'));
+            Logger.error(`plugin.json not found: ${pluginModule}`);
             reject();
             return;
         }
         readFile$1(pluginModule, 'utf8', (err, data) => {
             if (err) {
-                console.error(chalk.red.bold(`\n[-] couldn't read plugin.json from [${pluginModule}]`));
+                Logger.error(`could not read plugin.json: ${pluginModule}`);
                 reject();
                 return;
             }
             try {
-                if (!('name' in JSON.parse(data))) {
-                    console.error(chalk.red.bold(`\n[-] target plugin doesn't contain "name" in plugin.json [${pluginModule}]`));
+                const parsed = JSON.parse(data);
+                if (!('name' in parsed)) {
+                    Logger.error('plugin.json is missing required "name" field');
                     reject();
                 }
                 else {
-                    resolve(JSON.parse(data));
+                    resolve(parsed);
                 }
             }
             catch (parseError) {
-                console.error(chalk.red.bold(`\n[-] couldn't parse JSON in plugin.json from [${pluginModule}]`));
+                Logger.error('plugin.json contains invalid JSON:', pluginModule);
                 reject();
             }
         });
@@ -205,178 +222,42 @@ const ValidatePlugin = (bIsMillennium, target) => {
  * @description Append the active plugin to the global plugin
  * list and notify that the frontend Loaded.
  */
-function ExecutePluginModule() {
-    let MillenniumStore = window.MILLENNIUM_PLUGIN_SETTINGS_STORE[pluginName];
-    function OnPluginConfigChange(key, __, value) {
-        if (key in MillenniumStore.settingsStore) {
-            MillenniumStore.ignoreProxyFlag = true;
-            MillenniumStore.settingsStore[key] = value;
-            MillenniumStore.ignoreProxyFlag = false;
-        }
-    }
-    /** Expose the OnPluginConfigChange so it can be called externally */
-    MillenniumStore.OnPluginConfigChange = OnPluginConfigChange;
-    MILLENNIUM_BACKEND_IPC.postMessage(0, { pluginName: pluginName, methodName: '__builtins__.__millennium_plugin_settings_parser__' }).then(async (response) => {
-        /**
-         * __millennium_plugin_settings_parser__ will return false if the plugin has no settings.
-         * If the plugin has settings, it will return a base64 encoded string.
-         * The string is then decoded and parsed into an object.
-         */
-        if (typeof response.returnValue === 'string') {
-            MillenniumStore.ignoreProxyFlag = true;
-            /** Initialize the settings store from the settings returned from the backend. */
-            MillenniumStore.settingsStore = MillenniumStore.DefinePluginSetting(Object.fromEntries(JSON.parse(atob(response.returnValue)).map((item) => [item.functionName, item])));
-            MillenniumStore.ignoreProxyFlag = false;
-        }
-        /** @ts-ignore: call the plugin main after the settings have been parsed. This prevent plugin settings from being undefined at top level. */
-        let PluginModule = PluginEntryPointMain();
-        /** Assign the plugin on plugin list. */
-        Object.assign(window.PLUGIN_LIST[pluginName], {
-            ...PluginModule,
-            __millennium_internal_plugin_name_do_not_use_or_change__: pluginName,
-        });
-        /** Run the rolled up plugins default exported function */
-        let pluginProps = await PluginModule.default();
-        function isValidSidebarNavComponent(obj) {
-            return obj && obj.title !== undefined && obj.icon !== undefined && obj.content !== undefined;
-        }
-        if (pluginProps && isValidSidebarNavComponent(pluginProps)) {
-            window.MILLENNIUM_SIDEBAR_NAVIGATION_PANELS[pluginName] = pluginProps;
-        }
-        else {
-            console.warn(`Plugin ${pluginName} does not contain proper SidebarNavigation props and therefor can't be mounted by Millennium. Please ensure it has a title, icon, and content.`);
-            return;
-        }
-        /** If the current module is a client module, post message id=1 which calls the front_end_loaded method on the backend. */
-        if (MILLENNIUM_IS_CLIENT_MODULE) {
-            MILLENNIUM_BACKEND_IPC.postMessage(1, { pluginName: pluginName });
-        }
+async function ExecutePluginModule() {
+    let PluginModule = PluginEntryPointMain();
+    /** Assign the plugin on plugin list. */
+    Object.assign(window.PLUGIN_LIST[pluginName], {
+        ...PluginModule,
+        __millennium_internal_plugin_name_do_not_use_or_change__: pluginName,
     });
+    /** Run the rolled up plugins default exported function */
+    let pluginProps = await PluginModule.default();
+    function isValidSidebarNavComponent(obj) {
+        return obj && obj.title !== undefined && obj.icon !== undefined && obj.content !== undefined;
+    }
+    if (pluginProps && isValidSidebarNavComponent(pluginProps)) {
+        window.MILLENNIUM_SIDEBAR_NAVIGATION_PANELS[pluginName] = pluginProps;
+    }
+    /** If the current module is a client module, post message id=1 which calls the front_end_loaded method on the backend. */
+    if (MILLENNIUM_IS_CLIENT_MODULE) {
+        MILLENNIUM_BACKEND_IPC.postMessage(1, { pluginName: pluginName });
+    }
 }
 /**
  * @description Initialize the plugins settings store and the plugin list.
  * This function is called once per plugin and is used to store the plugin settings and the plugin list.
  */
 function InitializePlugins() {
-    var _a, _b;
-    /**
-     * This function is called n times depending on n plugin count,
-     * Create the plugin list if it wasn't already created
-     */
+    var _a;
     (_a = (window.PLUGIN_LIST || (window.PLUGIN_LIST = {})))[pluginName] || (_a[pluginName] = {});
-    (_b = (window.MILLENNIUM_PLUGIN_SETTINGS_STORE || (window.MILLENNIUM_PLUGIN_SETTINGS_STORE = {})))[pluginName] || (_b[pluginName] = {});
     window.MILLENNIUM_SIDEBAR_NAVIGATION_PANELS || (window.MILLENNIUM_SIDEBAR_NAVIGATION_PANELS = {});
-    /**
-     * Accepted IPC message types from Millennium backend.
-     */
-    let IPCType;
-    (function (IPCType) {
-        IPCType[IPCType["CallServerMethod"] = 0] = "CallServerMethod";
-    })(IPCType || (IPCType = {}));
-    let MillenniumStore = window.MILLENNIUM_PLUGIN_SETTINGS_STORE[pluginName];
-    let IPCMessageId = `Millennium.Internal.IPC.[${pluginName}]`;
-    let isClientModule = MILLENNIUM_IS_CLIENT_MODULE;
-    const ComponentTypeMap = {
-        DropDown: ['string', 'number', 'boolean'],
-        NumberTextInput: ['number'],
-        StringTextInput: ['string'],
-        FloatTextInput: ['number'],
-        CheckBox: ['boolean'],
-        NumberSlider: ['number'],
-        FloatSlider: ['number'],
-    };
-    MillenniumStore.ignoreProxyFlag = false;
-    function DelegateToBackend(pluginName, name, value) {
-        return MILLENNIUM_BACKEND_IPC.postMessage(IPCType.CallServerMethod, {
-            pluginName,
-            methodName: '__builtins__.__update_settings_value__',
-            argumentList: { name, value },
-        });
-    }
-    async function ClientInitializeIPC() {
-        /** Wait for the MainWindowBrowser to not be undefined */
-        while (typeof MainWindowBrowserManager === 'undefined') {
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        }
-        MainWindowBrowserManager?.m_browser?.on('message', (messageId, data) => {
-            if (messageId !== IPCMessageId) {
-                return;
-            }
-            const { name, value } = JSON.parse(data);
-            MillenniumStore.ignoreProxyFlag = true;
-            MillenniumStore.settingsStore[name] = value;
-            DelegateToBackend(pluginName, name, value);
-            MillenniumStore.ignoreProxyFlag = false;
-        });
-    }
-    if (isClientModule) {
-        ClientInitializeIPC();
-    }
-    const StartSettingPropagation = (name, value) => {
-        if (MillenniumStore.ignoreProxyFlag) {
-            return;
-        }
-        if (isClientModule) {
-            DelegateToBackend(pluginName, name, value);
-            /** If the browser doesn't exist yet, no use sending anything to it. */
-            if (typeof MainWindowBrowserManager !== 'undefined') {
-                MainWindowBrowserManager?.m_browser?.PostMessage(IPCMessageId, JSON.stringify({ name, value }));
-            }
-        }
-        else {
-            /** Send the message to the SharedJSContext */
-            SteamClient.BrowserView.PostMessageToParent(IPCMessageId, JSON.stringify({ name, value }));
-        }
-    };
-    function clamp(value, min, max) {
-        return Math.max(min, Math.min(max, value));
-    }
-    const DefinePluginSetting = (obj) => {
-        return new Proxy(obj, {
-            set(target, property, value) {
-                if (!(property in target)) {
-                    throw new TypeError(`Property ${String(property)} does not exist on plugin settings`);
-                }
-                const settingType = ComponentTypeMap[target[property].type];
-                const range = target[property]?.range;
-                /** Clamp the value between the given range */
-                if (settingType.includes('number') && typeof value === 'number') {
-                    if (range) {
-                        value = clamp(value, range[0], range[1]);
-                    }
-                    value || (value = 0); // Fallback to 0 if the value is undefined or null
-                }
-                /** Check if the value is of the proper type */
-                if (!settingType.includes(typeof value)) {
-                    throw new TypeError(`Expected ${settingType.join(' or ')}, got ${typeof value}`);
-                }
-                target[property].value = value;
-                StartSettingPropagation(String(property), value);
-                return true;
-            },
-            get(target, property) {
-                if (property === '__raw_get_internals__') {
-                    return target;
-                }
-                if (property in target) {
-                    return target[property].value;
-                }
-                return undefined;
-            },
-        });
-    };
-    MillenniumStore.DefinePluginSetting = DefinePluginSetting;
-    MillenniumStore.settingsStore = DefinePluginSetting({});
 }
 
 const traverse = _traverse.default;
-const Log = (...message) => {
-    console.log(chalk.blueBright.bold('constSysfsExpr'), ...message);
-};
 function constSysfsExpr(options = {}) {
     const filter = createFilter(options.include, options.exclude);
     const pluginName = 'millennium-const-sysfs-expr';
-    return {
+    let count = 0;
+    const plugin = {
         name: pluginName,
         transform(code, id) {
             if (!filter(id))
@@ -512,7 +393,6 @@ function constSysfsExpr(options = {}) {
                                 return;
                             }
                             try {
-                                const currentLocString = node.loc?.start ? ` at ${id}:${node.loc.start.line}:${node.loc.start.column}` : ` in ${id}`;
                                 const searchBasePath = callOptions.basePath
                                     ? path.isAbsolute(callOptions.basePath)
                                         ? callOptions.basePath
@@ -521,13 +401,11 @@ function constSysfsExpr(options = {}) {
                                         ? path.dirname(pathOrPattern)
                                         : path.resolve(path.dirname(id), path.dirname(pathOrPattern));
                                 let embeddedContent;
-                                let embeddedCount = 0;
                                 const isPotentialPattern = /[?*+!@()[\]{}]/.test(pathOrPattern);
                                 if (!isPotentialPattern &&
                                     fs.existsSync(path.resolve(searchBasePath, pathOrPattern)) &&
                                     fs.statSync(path.resolve(searchBasePath, pathOrPattern)).isFile()) {
                                     const singleFilePath = path.resolve(searchBasePath, pathOrPattern);
-                                    Log(`Mode: Single file (first argument "${pathOrPattern}" resolved to "${singleFilePath}" relative to "${searchBasePath}")`);
                                     try {
                                         const rawContent = fs.readFileSync(singleFilePath, callOptions.encoding);
                                         const contentString = rawContent.toString();
@@ -537,8 +415,6 @@ function constSysfsExpr(options = {}) {
                                             fileName: path.relative(searchBasePath, singleFilePath),
                                         };
                                         embeddedContent = JSON.stringify(fileInfo);
-                                        embeddedCount = 1;
-                                        Log(`Embedded 1 specific file for call${currentLocString}`);
                                     }
                                     catch (fileError) {
                                         let message = String(fileError instanceof Error ? fileError.message : fileError ?? 'Unknown file read error');
@@ -547,8 +423,6 @@ function constSysfsExpr(options = {}) {
                                     }
                                 }
                                 else {
-                                    Log(`Mode: Multi-file (first argument "${pathOrPattern}" is pattern or not a single file)`);
-                                    Log(`Searching with pattern "${pathOrPattern}" in directory "${searchBasePath}" (encoding: ${callOptions.encoding})`);
                                     const matchingFiles = glob.sync(pathOrPattern, {
                                         cwd: searchBasePath,
                                         nodir: true,
@@ -571,15 +445,13 @@ function constSysfsExpr(options = {}) {
                                         }
                                     }
                                     embeddedContent = JSON.stringify(fileInfoArray);
-                                    embeddedCount = fileInfoArray.length;
-                                    Log(`Embedded ${embeddedCount} file(s) matching pattern for call${currentLocString}`);
                                 }
                                 // Replace the call expression with the generated content string
                                 magicString.overwrite(node.start, node.end, embeddedContent);
                                 hasReplaced = true;
+                                count++;
                             }
                             catch (error) {
-                                console.error(`Failed to process files for constSysfsExpr call in ${id}:`, error);
                                 const message = String(error instanceof Error ? error.message : error ?? 'Unknown error during file processing');
                                 this.error(`Could not process files for constSysfsExpr: ${message}`, node.loc?.start.index);
                                 return;
@@ -589,7 +461,6 @@ function constSysfsExpr(options = {}) {
                 });
             }
             catch (error) {
-                console.error(`Error parsing or traversing ${id}:`, error);
                 const message = String(error instanceof Error ? error.message : error ?? 'Unknown parsing error');
                 this.error(`Failed to parse ${id}: ${message}`);
                 return null;
@@ -606,207 +477,155 @@ function constSysfsExpr(options = {}) {
             return result;
         },
     };
+    return { plugin, getCount: () => count };
 }
 
-const envConfig = dotenv.config().parsed || {};
-if (envConfig) {
-    Logger.Info('envVars', 'Processing ' + Object.keys(envConfig).length + ' environment variables... ' + chalk.green.bold('okay'));
-}
-const envVars = Object.keys(envConfig).reduce((acc, key) => {
-    acc[key] = envConfig[key];
-    return acc;
-}, {});
-var ComponentType;
-(function (ComponentType) {
-    ComponentType[ComponentType["Plugin"] = 0] = "Plugin";
-    ComponentType[ComponentType["Webkit"] = 1] = "Webkit";
-})(ComponentType || (ComponentType = {}));
-const WrappedCallServerMethod = 'const __call_server_method__ = (methodName, kwargs) => Millennium.callServerMethod(pluginName, methodName, kwargs)';
+const env = dotenv.config().parsed ?? {};
+var BuildTarget;
+(function (BuildTarget) {
+    BuildTarget[BuildTarget["Plugin"] = 0] = "Plugin";
+    BuildTarget[BuildTarget["Webkit"] = 1] = "Webkit";
+})(BuildTarget || (BuildTarget = {}));
+const kCallServerMethod = 'const __call_server_method__ = (methodName, kwargs) => Millennium.callServerMethod(pluginName, methodName, kwargs)';
 function __wrapped_callable__(route) {
     if (route.startsWith('webkit:')) {
         return MILLENNIUM_API.callable((methodName, kwargs) => MILLENNIUM_API.__INTERNAL_CALL_WEBKIT_METHOD__(pluginName, methodName, kwargs), route.replace(/^webkit:/, ''));
     }
     return MILLENNIUM_API.callable(__call_server_method__, route);
 }
-const ConstructFunctions = (parts) => {
-    return parts.join('\n');
-};
-function generate(code) {
-    /** Wrap it in a proxy */
+function wrapEntryPoint(code) {
     return `let PluginEntryPointMain = function() { ${code} return millennium_main; };`;
 }
-function InsertMillennium(type, props) {
-    const generateBundle = (_, bundle) => {
-        for (const fileName in bundle) {
-            if (bundle[fileName].type != 'chunk') {
-                continue;
-            }
-            Logger.Info('millenniumAPI', 'Bundling into ' + ComponentType[type] + ' module... ' + chalk.green.bold('okay'));
-            let code = ConstructFunctions([
-                `const MILLENNIUM_IS_CLIENT_MODULE = ${type === ComponentType.Plugin ? 'true' : 'false'};`,
-                `const pluginName = "${props.strPluginInternalName}";`,
-                InitializePlugins.toString(),
-                InitializePlugins.name + '()',
-                WrappedCallServerMethod,
-                __wrapped_callable__.toString(),
-                generate(bundle[fileName].code),
-                ExecutePluginModule.toString(),
-                ExecutePluginModule.name + '()',
-            ]);
-            if (props.bTersePlugin) {
-                code = minify_sync(code).code ?? code;
+function insertMillennium(target, props) {
+    return {
+        name: '',
+        generateBundle(_, bundle) {
+            for (const fileName in bundle) {
+                const chunk = bundle[fileName];
+                if (chunk.type !== 'chunk')
+                    continue;
+                let code = `\
+const MILLENNIUM_IS_CLIENT_MODULE = ${target === BuildTarget.Plugin};
+const pluginName = "${props.pluginName}";
+${InitializePlugins.toString()}
+${InitializePlugins.name}()
+${kCallServerMethod}
+${__wrapped_callable__.toString()}
+${wrapEntryPoint(chunk.code)}
+${ExecutePluginModule.toString()}
+${ExecutePluginModule.name}()`;
+                if (props.minify) {
+                    code = minify_sync(code).code ?? code;
+                }
+                chunk.code = code;
             }
-            bundle[fileName].code = code;
-        }
+        },
     };
-    return { name: String(), generateBundle };
 }
-async function GetCustomUserPlugins() {
-    const ttcConfigPath = new URL(`file://${process.cwd().replace(/\\/g, '/')}/ttc.config.mjs`).href;
-    if (fs.existsSync('./ttc.config.mjs')) {
-        const { MillenniumCompilerPlugins } = await import(ttcConfigPath);
-        Logger.Info('millenniumAPI', 'Loading custom plugins from ttc.config.mjs... ' + chalk.green.bold('okay'));
-        return MillenniumCompilerPlugins;
-    }
-    return [];
+function getFrontendDir(pluginJson) {
+    return pluginJson?.frontend ?? 'frontend';
 }
-async function MergePluginList(plugins) {
-    const customPlugins = await GetCustomUserPlugins();
-    // Filter out custom plugins that have the same name as input plugins
-    const filteredCustomPlugins = customPlugins.filter((customPlugin) => !plugins.some((plugin) => plugin.name === customPlugin.name));
-    // Merge input plugins with the filtered custom plugins
-    return [...plugins, ...filteredCustomPlugins];
+function resolveEntryFile(frontendDir) {
+    return frontendDir === '.' || frontendDir === './' || frontendDir === '' ? './index.tsx' : `./${frontendDir}/index.tsx`;
 }
-async function GetPluginComponents(pluginJson, props) {
-    let tsConfigPath = '';
-    const frontendDir = GetFrontEndDirectory(pluginJson);
-    if (frontendDir === '.' || frontendDir === './') {
-        tsConfigPath = './tsconfig.json';
-    }
-    else {
-        tsConfigPath = `./${frontendDir}/tsconfig.json`;
-    }
-    if (!fs.existsSync(tsConfigPath)) {
-        tsConfigPath = './tsconfig.json';
-    }
-    Logger.Info('millenniumAPI', 'Loading tsconfig from ' + chalk.cyan.bold(tsConfigPath) + '... ' + chalk.green.bold('okay'));
-    let pluginList = [
-        typescript({
-            tsconfig: tsConfigPath,
-            compilerOptions: {
-                outDir: undefined,
-            },
-        }),
-        url({
-            include: ['**/*.gif', '**/*.webm', '**/*.svg'], // Add all non-JS assets you use
-            limit: 0, // Set to 0 to always copy the file instead of inlining as base64
-            fileName: '[hash][extname]', // Optional: custom output naming
-        }),
-        InsertMillennium(ComponentType.Plugin, props),
-        nodeResolve({
-            browser: true,
-        }),
-        commonjs(),
-        nodePolyfills(),
-        scss({
-            output: false,
-            outputStyle: 'compressed',
-            sourceMap: false,
-            watch: 'src/styles',
-            sass: sass,
-        }),
-        json(),
-        constSysfsExpr(),
-        replace({
-            delimiters: ['', ''],
-            preventAssignment: true,
-            'process.env.NODE_ENV': JSON.stringify('production'),
-            'Millennium.callServerMethod': `__call_server_method__`,
-            'client.callable': `__wrapped_callable__`,
-            'client.pluginSelf': 'window.PLUGIN_LIST[pluginName]',
-            'client.Millennium.exposeObj(': 'client.Millennium.exposeObj(exports, ',
-            'client.BindPluginSettings()': 'client.BindPluginSettings(pluginName)',
-        }),
-    ];
-    if (envVars.length > 0) {
-        pluginList.push(injectProcessEnv(envVars));
-    }
-    if (props.bTersePlugin) {
-        pluginList.push(terser());
-    }
-    return pluginList;
+function resolveTsConfig(frontendDir) {
+    if (frontendDir === '.' || frontendDir === './')
+        return './tsconfig.json';
+    const candidate = `./${frontendDir}/tsconfig.json`;
+    return fs.existsSync(candidate) ? candidate : './tsconfig.json';
 }
-async function GetWebkitPluginComponents(props) {
-    let pluginList = [
-        InsertMillennium(ComponentType.Webkit, props),
-        typescript({
-            tsconfig: './webkit/tsconfig.json',
-        }),
-        url({
-            include: ['**/*.mp4', '**/*.webm', '**/*.ogg'],
-            limit: 0, // do NOT inline
-            fileName: '[name][extname]',
-            destDir: 'dist/assets', // or adjust as needed
-        }),
-        resolve(),
-        commonjs(),
-        json(),
-        constSysfsExpr(),
-        replace({
-            delimiters: ['', ''],
-            preventAssignment: true,
-            'Millennium.callServerMethod': `__call_server_method__`,
-            'webkit.callable': `__wrapped_callable__`,
-            'webkit.Millennium.exposeObj(': 'webkit.Millennium.exposeObj(exports, ',
-            'client.BindPluginSettings()': 'client.BindPluginSettings(pluginName)',
-        }),
-        babel({
-            presets: ['@babel/preset-env', '@babel/preset-react'],
-            babelHelpers: 'bundled',
-        }),
-    ];
-    if (envVars.length > 0) {
-        pluginList.push(injectProcessEnv(envVars));
-    }
-    pluginList = await MergePluginList(pluginList);
-    props.bTersePlugin && pluginList.push(terser());
-    return pluginList;
+async function withUserPlugins(plugins) {
+    if (!fs.existsSync('./ttc.config.mjs'))
+        return plugins;
+    const configUrl = pathToFileURL(path.resolve('./ttc.config.mjs')).href;
+    const { MillenniumCompilerPlugins } = await import(configUrl);
+    const deduped = MillenniumCompilerPlugins.filter((custom) => !plugins.some((p) => p?.name === custom?.name));
+    return [...plugins, ...deduped];
 }
-const GetFrontEndDirectory = (pluginJson) => {
-    try {
-        return pluginJson?.frontend ?? 'frontend';
+function logLocation(log) {
+    const file = log.loc?.file ?? log.id;
+    if (!file || !log.loc)
+        return undefined;
+    return `${path.relative(process.cwd(), file)}:${log.loc.line}:${log.loc.column}`;
+}
+function stripPluginPrefix(message) {
+    message = message.replace(/^\[plugin [^\]]+\]\s*/, '');
+    message = message.replace(/^\S[^(]*\(\d+:\d+\):\s*/, '');
+    message = message.replace(/^@?[\w-]+\/[\w-]+\s+/, '');
+    return message;
+}
+class MillenniumBuild {
+    isExternal(id) {
+        const hint = this.forbidden.get(id);
+        if (hint) {
+            Logger.error(`${id} cannot be used here; ${hint}`);
+            process.exit(1);
+        }
+        return this.externals.has(id);
     }
-    catch (error) {
-        return 'frontend';
+    async build(input, sysfsPlugin, isMillennium) {
+        let hasErrors = false;
+        const config = {
+            input,
+            plugins: await this.plugins(sysfsPlugin),
+            onwarn: (warning) => {
+                const msg = stripPluginPrefix(warning.message);
+                const loc = logLocation(warning);
+                if (warning.plugin === 'typescript') {
+                    Logger.error(msg, loc);
+                    hasErrors = true;
+                }
+                else {
+                    Logger.warn(msg, loc);
+                }
+            },
+            context: 'window',
+            external: (id) => this.isExternal(id),
+            output: this.output(isMillennium),
+        };
+        await (await rollup(config)).write(config.output);
+        if (hasErrors)
+            process.exit(1);
     }
-};
-const TranspilerPluginComponent = async (bIsMillennium, pluginJson, props) => {
-    const frontendDir = GetFrontEndDirectory(pluginJson);
-    console.log(chalk.greenBright.bold('config'), 'Frontend directory set to:', chalk.cyan.bold(frontendDir));
-    const frontendPlugins = await GetPluginComponents(pluginJson, props);
-    // Fix entry file path construction
-    let entryFile = '';
-    if (frontendDir === '.' || frontendDir === './' || frontendDir === '') {
-        entryFile = './index.tsx';
+}
+class FrontendBuild extends MillenniumBuild {
+    constructor(frontendDir, props) {
+        super();
+        this.frontendDir = frontendDir;
+        this.props = props;
+        this.externals = new Set(['@steambrew/client', 'react', 'react-dom', 'react-dom/client', 'react/jsx-runtime']);
+        this.forbidden = new Map([['@steambrew/webkit', 'use @steambrew/client in the frontend module']]);
     }
-    else {
-        entryFile = `./${frontendDir}/index.tsx`;
+    plugins(sysfsPlugin) {
+        const tsPlugin = typescript({ tsconfig: resolveTsConfig(this.frontendDir), compilerOptions: { noCheck: !this.props.minify, outDir: undefined } });
+        return [
+            tsPlugin,
+            url({ include: ['**/*.gif', '**/*.webm', '**/*.svg'], limit: 0, fileName: '[hash][extname]' }),
+            insertMillennium(BuildTarget.Plugin, this.props),
+            nodeResolve({ browser: true }),
+            commonjs(),
+            nodePolyfills(),
+            scss({ output: false, outputStyle: 'compressed', sourceMap: false, watch: 'src/styles', sass }),
+            json(),
+            sysfsPlugin,
+            replace({
+                delimiters: ['', ''],
+                preventAssignment: true,
+                'process.env.NODE_ENV': JSON.stringify('production'),
+                'Millennium.callServerMethod': '__call_server_method__',
+                'client.callable': '__wrapped_callable__',
+                'client.pluginSelf': 'window.PLUGIN_LIST[pluginName]',
+                'client.Millennium.exposeObj(': 'client.Millennium.exposeObj(exports, ',
+                'client.BindPluginSettings()': 'client.BindPluginSettings(pluginName)',
+            }),
+            ...(Object.keys(env).length > 0 ? [injectProcessEnv(env)] : []),
+            ...(this.props.minify ? [terser()] : []),
+        ];
     }
-    console.log(chalk.greenBright.bold('config'), 'Entry file set to:', chalk.cyan.bold(entryFile));
-    const frontendRollupConfig = {
-        input: entryFile,
-        plugins: frontendPlugins,
-        context: 'window',
-        external: (id) => {
-            if (id === '@steambrew/webkit') {
-                Logger.Error('The @steambrew/webkit module should not be included in the frontend module, use @steambrew/client instead. Please remove it from the frontend module and try again.');
-                process.exit(1);
-            }
-            return id === '@steambrew/client' || id === 'react' || id === 'react-dom' || id === 'react-dom/client' || id === 'react/jsx-runtime';
-        },
-        output: {
+    output(isMillennium) {
+        return {
             name: 'millennium_main',
-            file: bIsMillennium ? '../../build/frontend.bin' : '.millennium/Dist/index.js',
+            file: isMillennium ? '../../build/frontend.bin' : '.millennium/Dist/index.js',
             globals: {
                 react: 'window.SP_REACT',
                 'react-dom': 'window.SP_REACTDOM',
@@ -816,38 +635,68 @@ const TranspilerPluginComponent = async (bIsMillennium, pluginJson, props) => {
             },
             exports: 'named',
             format: 'iife',
-        },
-    };
+        };
+    }
+}
+class WebkitBuild extends MillenniumBuild {
+    constructor(props) {
+        super();
+        this.props = props;
+        this.externals = new Set(['@steambrew/webkit']);
+        this.forbidden = new Map([['@steambrew/client', 'use @steambrew/webkit in the webkit module']]);
+    }
+    async plugins(sysfsPlugin) {
+        const tsPlugin = typescript({ tsconfig: './webkit/tsconfig.json', compilerOptions: { noCheck: !this.props.minify } });
+        const base = [
+            insertMillennium(BuildTarget.Webkit, this.props),
+            tsPlugin,
+            url({ include: ['**/*.mp4', '**/*.webm', '**/*.ogg'], limit: 0, fileName: '[name][extname]', destDir: 'dist/assets' }),
+            resolve(),
+            commonjs(),
+            json(),
+            sysfsPlugin,
+            replace({
+                delimiters: ['', ''],
+                preventAssignment: true,
+                'Millennium.callServerMethod': '__call_server_method__',
+                'webkit.callable': '__wrapped_callable__',
+                'webkit.Millennium.exposeObj(': 'webkit.Millennium.exposeObj(exports, ',
+                'client.BindPluginSettings()': 'client.BindPluginSettings(pluginName)',
+            }),
+            babel({ presets: ['@babel/preset-env', '@babel/preset-react'], babelHelpers: 'bundled' }),
+            ...(Object.keys(env).length > 0 ? [injectProcessEnv(env)] : []),
+        ];
+        const merged = await withUserPlugins(base);
+        return this.props.minify ? [...merged, terser()] : merged;
+    }
+    output(_isMillennium) {
+        return {
+            name: 'millennium_main',
+            file: '.millennium/Dist/webkit.js',
+            exports: 'named',
+            format: 'iife',
+            globals: { '@steambrew/webkit': 'window.MILLENNIUM_API' },
+        };
+    }
+}
+const TranspilerPluginComponent = async (isMillennium, pluginJson, props) => {
+    const webkitDir = './webkit/index.tsx';
+    const frontendDir = getFrontendDir(pluginJson);
+    const sysfs = constSysfsExpr();
     try {
-        await (await rollup(frontendRollupConfig)).write(frontendRollupConfig.output);
-        if (fs.existsSync(`./webkit/index.tsx`)) {
-            const webkitRollupConfig = {
-                input: `./webkit/index.tsx`,
-                plugins: await GetWebkitPluginComponents(props),
-                context: 'window',
-                external: (id) => {
-                    if (id === '@steambrew/client') {
-                        Logger.Error('The @steambrew/client module should not be included in the webkit module, use @steambrew/webkit instead. Please remove it from the webkit module and try again.');
-                        process.exit(1);
-                    }
-                    return id === '@steambrew/webkit';
-                },
-                output: {
-                    name: 'millennium_main',
-                    file: '.millennium/Dist/webkit.js',
-                    exports: 'named',
-                    format: 'iife',
-                    globals: {
-                        '@steambrew/webkit': 'window.MILLENNIUM_API',
-                    },
-                },
-            };
-            await (await rollup(webkitRollupConfig)).write(webkitRollupConfig.output);
+        await new FrontendBuild(frontendDir, props).build(resolveEntryFile(frontendDir), sysfs.plugin, isMillennium);
+        if (fs.existsSync(webkitDir)) {
+            await new WebkitBuild(props).build(webkitDir, sysfs.plugin, isMillennium);
         }
-        Logger.Info('build', 'Succeeded passing all tests in', Number((performance.now() - global.PerfStartTime).toFixed(3)), 'ms elapsed.');
+        Logger.done({
+            elapsedMs: performance.now() - global.PerfStartTime,
+            buildType: props.minify ? 'prod' : 'dev',
+            sysfsCount: sysfs.getCount() || undefined,
+            envCount: Object.keys(env).length || undefined,
+        });
     }
     catch (exception) {
-        Logger.Error('error', 'Build failed!', exception);
+        Logger.error(stripPluginPrefix(exception?.message ?? String(exception)), logLocation(exception));
         process.exit(1);
     }
 };
@@ -864,18 +713,14 @@ const StartCompilerModule = () => {
     const parameters = ValidateParameters(process.argv.slice(2));
     const bIsMillennium = parameters.isMillennium || false;
     const bTersePlugin = parameters.type == BuildType.ProdBuild;
-    console.log(chalk.greenBright.bold('config'), 'Building target:', parameters.targetPlugin, 'with type:', BuildType[parameters.type], 'minify:', bTersePlugin, '...');
     ValidatePlugin(bIsMillennium, parameters.targetPlugin)
         .then((json) => {
         const props = {
-            bTersePlugin: bTersePlugin,
-            strPluginInternalName: json?.name,
+            minify: bTersePlugin,
+            pluginName: json?.name,
         };
         TranspilerPluginComponent(bIsMillennium, json, props);
     })
-        /**
-         * plugin is invalid, we close the proccess as it has already been handled
-         */
         .catch(() => {
         process.exit();
     });