@lynx-js/rspeedy-canary 0.13.0-canary-20260105-ec1caf1a → 0.13.0-canary-20260105-03ea61ec

package/dist/src_cli_main_ts.js

@@ -0,0 +1,149 @@
+import * as __rspack_external_node_process_786449bf from "node:process";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { debug, logger } from "./src_debug_ts.js";
+__webpack_require__.add({
+    "node:process" (module) {
+        module.exports = __rspack_external_node_process_786449bf;
+    }
+});
+const external_node_process_ = __webpack_require__("node:process");
+const asyncCallbacks = new Set();
+const callbacks = new Set();
+let isCalled = false;
+let isRegistered = false;
+async function exit(shouldManuallyExit, isSynchronous, signal) {
+    if (isCalled) return;
+    isCalled = true;
+    if (asyncCallbacks.size > 0 && isSynchronous) console.error("SYNCHRONOUS TERMINATION NOTICE: When explicitly exiting the process via process.exit or via a parent process, asynchronous tasks in your exitHooks will not run. Either remove these tasks, use gracefulExit() instead of process.exit(), or ensure your parent process sends a SIGINT to the process running this code.");
+    const exitCode = 128 + signal;
+    const done = (force = false)=>{
+        if (true === force || true === shouldManuallyExit) external_node_process_["default"].exit(exitCode);
+    };
+    for (const callback of callbacks)callback(exitCode);
+    if (isSynchronous) return void done();
+    const promises = [];
+    let forceAfter = 0;
+    for (const [callback, wait] of asyncCallbacks){
+        forceAfter = Math.max(forceAfter, wait);
+        promises.push(Promise.resolve(callback(exitCode)));
+    }
+    const asyncTimer = setTimeout(()=>{
+        done(true);
+    }, forceAfter);
+    await Promise.all(promises);
+    clearTimeout(asyncTimer);
+    done();
+}
+function addHook(options) {
+    const { onExit, wait, isSynchronous } = options;
+    const asyncCallbackConfig = [
+        onExit,
+        wait
+    ];
+    if (isSynchronous) callbacks.add(onExit);
+    else asyncCallbacks.add(asyncCallbackConfig);
+    if (!isRegistered) {
+        isRegistered = true;
+        external_node_process_["default"].once('beforeExit', exit.bind(void 0, true, false, -128));
+        external_node_process_["default"].once('SIGINT', exit.bind(void 0, true, false, 2));
+        external_node_process_["default"].once('SIGTERM', exit.bind(void 0, true, false, 15));
+        external_node_process_["default"].once('exit', exit.bind(void 0, false, true, 0));
+        external_node_process_["default"].on('message', (message)=>{
+            if ('shutdown' === message) exit(true, true, -128);
+        });
+    }
+    return ()=>{
+        if (isSynchronous) callbacks.delete(onExit);
+        else asyncCallbacks.delete(asyncCallbackConfig);
+    };
+}
+function asyncExitHook(onExit, options = {}) {
+    if ('function' != typeof onExit) throw new TypeError('onExit must be a function');
+    if (!('number' == typeof options.wait && options.wait > 0)) throw new TypeError('wait must be set to a positive numeric value');
+    return addHook({
+        onExit,
+        wait: options.wait,
+        isSynchronous: false
+    });
+}
+function gracefulExit(signal = 0) {
+    exit(true, false, -128 + signal);
+}
+const picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+const start = Date.now();
+const exitPromises = [];
+const unsubscribe = asyncExitHook(exit_onExit, {
+    wait: 1000
+});
+process.on('unhandledRejection', async (reason)=>{
+    logger.error('Unhandled Rejection with reason:', reason instanceof Error ? reason : new Error(JSON.stringify(reason)));
+    unsubscribe();
+    await exit_onExit(1);
+    process.exit(1);
+});
+let interrupted = false;
+process.on('SIGINT', ()=>{
+    if (interrupted) {
+        logger.info("Force exiting Rspeedy.");
+        return process.exit(130);
+    }
+    interrupted = true;
+    logger.info(`Gracefully shutting down. Please wait... (Press ${picocolors_default().cyan('Ctrl+C')} again to force exit)`);
+    exit_exit(130);
+});
+let previousSignal = null;
+const exit_exit = (signal = 0)=>{
+    if (null !== previousSignal) debug(`graceful exit called multiple times, current: ${signal}, previous: ${previousSignal}`);
+    previousSignal = signal;
+    debug(`graceful exit process with signal: ${signal}`);
+    gracefulExit(signal);
+};
+async function exit_onExit(signal) {
+    const duration = Date.now() - start;
+    debug(`exit hook fired with signal: ${signal}, duration: ${duration}`);
+    debug(`awaiting exit promises(length: ${exitPromises.length})...`);
+    await Promise.allSettled(exitPromises);
+}
+function initNodeEnv(argv) {
+    if (!process.env['NODE_ENV']) {
+        const NODE_ENV = argv.includes('dev') || argv.includes('preview') ? 'development' : 'production';
+        process.env['NODE_ENV'] = NODE_ENV;
+        debug(`No NODE_ENV found, set to ${NODE_ENV}`);
+    }
+}
+async function main(argv) {
+    initNodeEnv(argv);
+    const { npm_execpath } = process.env;
+    if (!npm_execpath || npm_execpath.includes('npm-cli.js') || npm_execpath.includes('npx-cli.js')) console.log();
+    const { version, rsbuildVersion, rspackVersion } = await import("./1~src_version_ts.js").then((mod)=>({
+            version: mod.version,
+            rsbuildVersion: mod.version,
+            rspackVersion: mod.rspackVersion
+        }));
+    logger.greet(`  Rspeedy v${version} (Rsbuild v${rsbuildVersion}, Rspack v${rspackVersion})\n`);
+    try {
+        const [{ Command }, { apply }] = await Promise.all([
+            import("./1~node_modules_pnpm_commander_13_1_0_node_modules_commander_esm_mjs.js").then((mod)=>({
+                    Argument: mod.Argument,
+                    Command: mod.Command,
+                    CommanderError: mod.CommanderError,
+                    Help: mod.Help,
+                    InvalidArgumentError: mod.InvalidArgumentError,
+                    InvalidOptionArgumentError: mod.InvalidOptionArgumentError,
+                    Option: mod.Option,
+                    createArgument: mod.createArgument,
+                    createCommand: mod.createCommand,
+                    createOption: mod.createOption,
+                    program: mod.program
+                })),
+            import("./1~src_cli_commands_ts.js").then((mod)=>({
+                    apply: mod.apply
+                }))
+        ]);
+        apply(new Command('rspeedy')).parse(argv);
+    } catch  {
+        return exit_exit(1);
+    }
+}
+export { exit_exit, main };

package/dist/src_debug_ts.js

@@ -0,0 +1,93 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { createRsbuild, logger, mergeRsbuildConfig, rspack, version } from "@rsbuild/core";
+__webpack_require__.add({
+    "../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
+        let p = process || {}, argv = p.argv || [], env = p.env || {};
+        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
+        let formatter = (open, close, replace = open)=>(input)=>{
+                let string = "" + input, index = string.indexOf(close, open.length);
+                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+            };
+        let replaceClose = (string, close, replace, index)=>{
+            let result = "", cursor = 0;
+            do {
+                result += string.substring(cursor, index) + replace;
+                cursor = index + close.length;
+                index = string.indexOf(close, cursor);
+            }while (~index);
+            return result + string.substring(cursor);
+        };
+        let createColors = (enabled = isColorSupported)=>{
+            let f = enabled ? formatter : ()=>String;
+            return {
+                isColorSupported: enabled,
+                reset: f("\x1b[0m", "\x1b[0m"),
+                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+                italic: f("\x1b[3m", "\x1b[23m"),
+                underline: f("\x1b[4m", "\x1b[24m"),
+                inverse: f("\x1b[7m", "\x1b[27m"),
+                hidden: f("\x1b[8m", "\x1b[28m"),
+                strikethrough: f("\x1b[9m", "\x1b[29m"),
+                black: f("\x1b[30m", "\x1b[39m"),
+                red: f("\x1b[31m", "\x1b[39m"),
+                green: f("\x1b[32m", "\x1b[39m"),
+                yellow: f("\x1b[33m", "\x1b[39m"),
+                blue: f("\x1b[34m", "\x1b[39m"),
+                magenta: f("\x1b[35m", "\x1b[39m"),
+                cyan: f("\x1b[36m", "\x1b[39m"),
+                white: f("\x1b[37m", "\x1b[39m"),
+                gray: f("\x1b[90m", "\x1b[39m"),
+                bgBlack: f("\x1b[40m", "\x1b[49m"),
+                bgRed: f("\x1b[41m", "\x1b[49m"),
+                bgGreen: f("\x1b[42m", "\x1b[49m"),
+                bgYellow: f("\x1b[43m", "\x1b[49m"),
+                bgBlue: f("\x1b[44m", "\x1b[49m"),
+                bgMagenta: f("\x1b[45m", "\x1b[49m"),
+                bgCyan: f("\x1b[46m", "\x1b[49m"),
+                bgWhite: f("\x1b[47m", "\x1b[49m"),
+                blackBright: f("\x1b[90m", "\x1b[39m"),
+                redBright: f("\x1b[91m", "\x1b[39m"),
+                greenBright: f("\x1b[92m", "\x1b[39m"),
+                yellowBright: f("\x1b[93m", "\x1b[39m"),
+                blueBright: f("\x1b[94m", "\x1b[39m"),
+                magentaBright: f("\x1b[95m", "\x1b[39m"),
+                cyanBright: f("\x1b[96m", "\x1b[39m"),
+                whiteBright: f("\x1b[97m", "\x1b[39m"),
+                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+                bgRedBright: f("\x1b[101m", "\x1b[49m"),
+                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+            };
+        };
+        module.exports = createColors();
+        module.exports.createColors = createColors;
+    }
+});
+const picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+const isDebug = ()=>{
+    if (!process.env['DEBUG']) return false;
+    const values = process.env['DEBUG'].toLocaleLowerCase().split(',');
+    return [
+        'rsbuild',
+        'rspeedy',
+        '*'
+    ].some((key)=>values.includes(key));
+};
+const label = picocolors_default().bgCyan('lynx');
+const debug = (message)=>{
+    if (isDebug()) {
+        const result = 'string' == typeof message ? message : message();
+        logger.level = 'verbose';
+        logger.debug(`${label} ${result}`);
+    }
+};
+const debugList = (prefix, messages)=>debug(()=>`${prefix} ${[
+            ''
+        ].concat(messages).join('\n    - ')}`);
+export { createRsbuild, debug, debugList, isDebug, logger, mergeRsbuildConfig, rspack, version };

package/dist/src_index_ts.js

@@ -0,0 +1,381 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import node_path, { dirname, extname, isAbsolute, join } from "node:path";
+import { createRsbuild, logger, mergeRsbuildConfig, rspack, version } from "@rsbuild/core";
+import node_fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { register } from "#register";
+__webpack_require__.add({
+    "../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
+        let p = process || {}, argv = p.argv || [], env = p.env || {};
+        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
+        let formatter = (open, close, replace = open)=>(input)=>{
+                let string = "" + input, index = string.indexOf(close, open.length);
+                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+            };
+        let replaceClose = (string, close, replace, index)=>{
+            let result = "", cursor = 0;
+            do {
+                result += string.substring(cursor, index) + replace;
+                cursor = index + close.length;
+                index = string.indexOf(close, cursor);
+            }while (~index);
+            return result + string.substring(cursor);
+        };
+        let createColors = (enabled = isColorSupported)=>{
+            let f = enabled ? formatter : ()=>String;
+            return {
+                isColorSupported: enabled,
+                reset: f("\x1b[0m", "\x1b[0m"),
+                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+                italic: f("\x1b[3m", "\x1b[23m"),
+                underline: f("\x1b[4m", "\x1b[24m"),
+                inverse: f("\x1b[7m", "\x1b[27m"),
+                hidden: f("\x1b[8m", "\x1b[28m"),
+                strikethrough: f("\x1b[9m", "\x1b[29m"),
+                black: f("\x1b[30m", "\x1b[39m"),
+                red: f("\x1b[31m", "\x1b[39m"),
+                green: f("\x1b[32m", "\x1b[39m"),
+                yellow: f("\x1b[33m", "\x1b[39m"),
+                blue: f("\x1b[34m", "\x1b[39m"),
+                magenta: f("\x1b[35m", "\x1b[39m"),
+                cyan: f("\x1b[36m", "\x1b[39m"),
+                white: f("\x1b[37m", "\x1b[39m"),
+                gray: f("\x1b[90m", "\x1b[39m"),
+                bgBlack: f("\x1b[40m", "\x1b[49m"),
+                bgRed: f("\x1b[41m", "\x1b[49m"),
+                bgGreen: f("\x1b[42m", "\x1b[49m"),
+                bgYellow: f("\x1b[43m", "\x1b[49m"),
+                bgBlue: f("\x1b[44m", "\x1b[49m"),
+                bgMagenta: f("\x1b[45m", "\x1b[49m"),
+                bgCyan: f("\x1b[46m", "\x1b[49m"),
+                bgWhite: f("\x1b[47m", "\x1b[49m"),
+                blackBright: f("\x1b[90m", "\x1b[39m"),
+                redBright: f("\x1b[91m", "\x1b[39m"),
+                greenBright: f("\x1b[92m", "\x1b[39m"),
+                yellowBright: f("\x1b[93m", "\x1b[39m"),
+                blueBright: f("\x1b[94m", "\x1b[39m"),
+                magentaBright: f("\x1b[95m", "\x1b[39m"),
+                cyanBright: f("\x1b[96m", "\x1b[39m"),
+                whiteBright: f("\x1b[97m", "\x1b[39m"),
+                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+                bgRedBright: f("\x1b[101m", "\x1b[49m"),
+                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+            };
+        };
+        module.exports = createColors();
+        module.exports.createColors = createColors;
+    }
+});
+const picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+const isDebug = ()=>{
+    if (!process.env['DEBUG']) return false;
+    const values = process.env['DEBUG'].toLocaleLowerCase().split(',');
+    return [
+        'rsbuild',
+        'rspeedy',
+        '*'
+    ].some((key)=>values.includes(key));
+};
+const label = picocolors_default().bgCyan('lynx');
+const debug = (message)=>{
+    if (isDebug()) {
+        const result = 'string' == typeof message ? message : message();
+        logger.level = 'verbose';
+        logger.debug(`${label} ${result}`);
+    }
+};
+const debugList = (prefix, messages)=>debug(()=>`${prefix} ${[
+            ''
+        ].concat(messages).join('\n    - ')}`);
+function applyDefaultRspeedyConfig(config) {
+    const enableChunkSplitting = config.performance?.chunkSplit?.strategy && config.performance?.chunkSplit?.strategy !== 'all-in-one';
+    return mergeRsbuildConfig({
+        mode: (()=>{
+            if (config.mode) return config.mode;
+            const nodeEnv = process.env['NODE_ENV'];
+            return 'production' === nodeEnv || 'development' === nodeEnv ? nodeEnv : 'none';
+        })(),
+        output: {
+            filename: getFilename(config.output?.filename),
+            inlineScripts: !enableChunkSplitting,
+            cssModules: {
+                localIdentName: '[local]-[hash:base64:6]'
+            }
+        },
+        performance: {
+            profile: isDebug() ? true : void 0
+        },
+        tools: {
+            rsdoctor: {
+                experiments: {
+                    enableNativePlugin: true
+                }
+            }
+        }
+    }, config);
+}
+const DEFAULT_FILENAME = '[name].[platform].bundle';
+function getFilename(filename) {
+    if ('string' == typeof filename) return {
+        bundle: filename,
+        template: filename
+    };
+    const finalFilename = filename?.bundle ?? filename?.template ?? DEFAULT_FILENAME;
+    return {
+        bundle: finalFilename,
+        template: finalFilename
+    };
+}
+const DEFAULT_ENTRY = './src/index.js';
+function toRsbuildEntry(entry) {
+    if (void 0 === entry) {
+        debug(`Using default entry ${DEFAULT_ENTRY}`);
+        return {
+            main: DEFAULT_ENTRY
+        };
+    }
+    if (Array.isArray(entry) || 'string' == typeof entry) {
+        debug(()=>`Using single entry ${[
+                ''
+            ].concat(entry).join('\n    - ')}`);
+        return {
+            main: entry
+        };
+    }
+    return Object.fromEntries(Object.entries(entry).map(([key, value])=>{
+        if (Array.isArray(value) || 'string' == typeof value) {
+            debugList(`Using multiple entries - ${key}`, value);
+            return [
+                key,
+                {
+                    import: value
+                }
+            ];
+        }
+        debugList(`Using multiple entries - ${key}`, value.import ?? DEFAULT_ENTRY);
+        if (void 0 === value.import) return [
+            key,
+            {
+                ...value,
+                import: DEFAULT_ENTRY
+            }
+        ];
+        return [
+            key,
+            value
+        ];
+    }));
+}
+const defaultDataUriLimit = 2048;
+function toRsbuildConfig(config) {
+    return {
+        dev: {
+            hmr: config.dev?.hmr ?? true,
+            lazyCompilation: false,
+            liveReload: config.dev?.liveReload ?? true,
+            watchFiles: config.dev?.watchFiles,
+            writeToDisk: config.dev?.writeToDisk ?? true,
+            progressBar: config.dev?.progressBar ?? true
+        },
+        environments: config.environments ?? {
+            lynx: {}
+        },
+        mode: config.mode,
+        output: {
+            assetPrefix: config.output?.assetPrefix,
+            charset: 'utf8',
+            cleanDistPath: config.output?.cleanDistPath,
+            copy: config.output?.copy,
+            cssModules: config.output?.cssModules,
+            dataUriLimit: config.output?.dataUriLimit ?? defaultDataUriLimit,
+            distPath: config.output?.distPath,
+            filenameHash: config.output?.filenameHash,
+            inlineScripts: config.output?.inlineScripts,
+            legalComments: config.output?.legalComments ?? 'none',
+            polyfill: 'off',
+            sourceMap: config.output?.sourceMap
+        },
+        resolve: {
+            alias: config.resolve?.alias,
+            aliasStrategy: config.resolve?.aliasStrategy,
+            dedupe: config.resolve?.dedupe,
+            extensions: config.resolve?.extensions
+        },
+        source: {
+            alias: config.source?.alias,
+            assetsInclude: config.source?.assetsInclude,
+            decorators: config.source?.decorators,
+            define: config.source?.define,
+            entry: toRsbuildEntry(config.source?.entry),
+            exclude: config.source?.exclude,
+            include: config.source?.include,
+            preEntry: config.source?.preEntry,
+            transformImport: config.source?.transformImport,
+            tsconfigPath: config.source?.tsconfigPath
+        },
+        server: {
+            base: config.server?.base,
+            compress: config.server?.compress,
+            cors: config.server?.cors,
+            headers: config.server?.headers,
+            host: config.server?.host,
+            port: config.server?.port,
+            proxy: config.server?.proxy,
+            strictPort: config.server?.strictPort
+        },
+        plugins: config.plugins,
+        performance: {
+            buildCache: config.performance?.buildCache,
+            chunkSplit: config.performance?.chunkSplit,
+            profile: config.performance?.profile,
+            removeConsole: toRsbuildRemoveConsole(config),
+            printFileSize: config.performance?.printFileSize ?? true
+        },
+        tools: {
+            bundlerChain: config.tools?.bundlerChain,
+            cssExtract: config.tools?.cssExtract,
+            cssLoader: config.tools?.cssLoader,
+            htmlPlugin: false,
+            rspack: config.tools?.rspack,
+            swc: config.tools?.swc
+        }
+    };
+}
+function toRsbuildRemoveConsole(config) {
+    if (config.performance?.removeConsole === true) return [
+        'log',
+        'warn',
+        'error',
+        'info',
+        'debug',
+        'profile',
+        'profileEnd'
+    ];
+    return config.performance?.removeConsole;
+}
+async function createRspeedy({ cwd = process.cwd(), rspeedyConfig = {}, loadEnv = true, environment = [], callerName = 'rspeedy' }) {
+    const config = applyDefaultRspeedyConfig(rspeedyConfig);
+    const [rspeedy, { applyDefaultPlugins }] = await Promise.all([
+        createRsbuild({
+            cwd,
+            loadEnv,
+            rsbuildConfig: toRsbuildConfig(config),
+            environment,
+            callerName
+        }),
+        import("./0~src_plugins_index_ts.js").then((mod)=>({
+                applyDefaultPlugins: mod.applyDefaultPlugins
+            }))
+    ]);
+    await applyDefaultPlugins(rspeedy, config);
+    const inspectConfig = rspeedy.inspectConfig.bind(rspeedy);
+    return Object.assign(rspeedy, {
+        getRspeedyConfig: ()=>config,
+        async inspectConfig (options) {
+            const result = await inspectConfig(options);
+            const { inspectRspeedyConfig } = await import("./0~src_plugins_inspect_plugin_ts.js").then((mod)=>({
+                    inspectRspeedyConfig: mod.inspectRspeedyConfig
+                }));
+            await inspectRspeedyConfig(rspeedyConfig, node_path.resolve(options.outputPath ?? rspeedy.context.distPath, '.rsbuild/rspeedy.config.js'), options.verbose ?? false);
+            return result;
+        }
+    });
+}
+function mergeRspeedyConfig(...configs) {
+    return mergeRsbuildConfig(...configs);
+}
+function defineConfig(config) {
+    return config;
+}
+const resolveConfigPath = (root, customConfig)=>{
+    if (customConfig) {
+        debug(`load custom config file ${customConfig} from ${root}`);
+        const customConfigPath = isAbsolute(customConfig) ? customConfig : join(root, customConfig);
+        if (node_fs.existsSync(customConfigPath)) return customConfigPath;
+        throw new Error(`Cannot find config file: ${picocolors_default().dim(customConfigPath)}`);
+    }
+    const CONFIG_FILES = [
+        'lynx.config.ts',
+        'lynx.config.js',
+        'lynx.config.mts',
+        'lynx.config.mjs'
+    ];
+    for (const file of CONFIG_FILES){
+        debug(`load default config file ${file} from ${root}`);
+        const configFile = join(root, file);
+        if (node_fs.existsSync(configFile)) {
+            debug(`default config ${configFile} found`);
+            return configFile;
+        }
+    }
+    throw new Error([
+        `Cannot find the default config file: ${picocolors_default().dim(join(root, CONFIG_FILES[0]))}.`,
+        `Use custom config with ${picocolors_default().green('`--config <config>`')} options.`
+    ].join(' '));
+};
+async function loadConfig(loadConfigOptions) {
+    let { configPath } = loadConfigOptions;
+    if (!configPath || !isAbsolute(configPath)) configPath = resolveConfigPath(loadConfigOptions.cwd ?? process.cwd(), configPath);
+    const specifier = pathToFileURL(configPath).toString();
+    let unregister;
+    unregister = shouldUseNativeImport(configPath) ? ()=>{} : register({
+        load: !hasNativeTSSupport(),
+        resolve: true
+    });
+    try {
+        const [exports, { validate }] = await Promise.all([
+            import(`${specifier}?t=${Date.now()}`),
+            import("./0~src_config_validate_ts.js").then((mod)=>({
+                    validate: mod.validate,
+                    validateConfig: mod.validateConfig
+                }))
+        ]);
+        const configExport = 'default' in exports ? exports.default : exports;
+        const rawContent = 'function' == typeof configExport ? await configExport({
+            command: process.argv[2] ?? 'build',
+            env: process.env['NODE_ENV'] ?? 'production'
+        }) : await configExport;
+        return {
+            configPath,
+            content: validate(rawContent, configPath)
+        };
+    } finally{
+        unregister();
+    }
+}
+function shouldUseNativeImport(configPath) {
+    return isJavaScriptPath(configPath) || isDeno();
+}
+function hasNativeTSSupport() {
+    if (isDeno()) return true;
+    if (process.features.typescript) return true;
+    if (false === process.features.typescript) return false;
+    const { NODE_OPTIONS } = process.env;
+    if (!NODE_OPTIONS) return false;
+    return NODE_OPTIONS.includes('--experimental-transform-types') || NODE_OPTIONS.includes('--experimental-strip-types');
+}
+function isJavaScriptPath(configPath) {
+    const ext = extname(configPath);
+    return [
+        '.js',
+        '.mjs',
+        '.cjs'
+    ].includes(ext);
+}
+function isDeno() {
+    if ("u" > typeof Deno || process.versions?.deno) return true;
+    return false;
+}
+var package_namespaceObject = {
+    rE: "0.12.5"
+};
+const version_version = package_namespaceObject.rE;
+const rspackVersion = rspack.rspackVersion;
+export { createRspeedy, debug, defineConfig, dirname, isDebug, loadConfig, logger, mergeRsbuildConfig, mergeRspeedyConfig, node_path, rspack, rspackVersion, version as rsbuildVersion, version_version as version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/rspeedy-canary",
-  "version": "0.13.0-canary-20260105-ec1caf1a",
+  "version": "0.13.0-canary-20260105-03ea61ec",
   "description": "A webpack/rspack-based frontend toolchain for Lynx",
   "keywords": [
     "webpack",