@bleedingdev/modern-js-server-utils 3.9.0-ultramodern.17 → 3.9.0-ultramodern.19

package/dist/esm/compilers/rslib.mjs

@@ -0,0 +1,257 @@
+import { fs, logger, mergeAlias } from "@modern-js/utils";
+import path from "path";
+import { createResolvedTsgoConfig, getTsgoBinPath, getTsgoModulePath, runTsgo } from "./tsgo.mjs";
+const SCRIPT_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/u;
+const DECLARATION_RE = /\.d\.[cm]?ts$/u;
+const TS_RE = /\.[cm]?tsx?$/u;
+const toPosix = (file)=>file.split(path.sep).join(path.posix.sep);
+const escapeGlob = (file)=>file.replace(/[()[\]{}*?!+@]/gu, '\\$&');
+const walk = async (dir)=>{
+    if (!await fs.pathExists(dir)) return [];
+    const entries = await fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map((entry)=>{
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory()) return 'node_modules' === entry.name ? [] : walk(file);
+        return [
+            file
+        ];
+    }));
+    return files.flat();
+};
+const outputExtension = (file)=>/\.m[jt]s$/u.test(file) ? '.mjs' : /\.c[jt]s$/u.test(file) ? '.cjs' : '.js';
+const collectSources = async (sourceDirs, excludeFiles)=>{
+    const excluded = new Set(excludeFiles.map((file)=>path.normalize(file)));
+    return (await Promise.all(sourceDirs.map(walk))).flat().filter((file)=>SCRIPT_RE.test(file) && !DECLARATION_RE.test(file) && !excluded.has(path.normalize(file)));
+};
+const groupEntries = (appDirectory, files)=>{
+    const outputs = new Map();
+    const entries = {
+        '.js': [],
+        '.mjs': [],
+        '.cjs': []
+    };
+    for (const file of files){
+        const extension = outputExtension(file);
+        const output = `${file.replace(SCRIPT_RE, '')}${extension}`;
+        const existing = outputs.get(output);
+        if (existing) throw new Error(`"${existing}" and "${file}" both compile to "${toPosix(path.relative(appDirectory, output))}". Rename one of them.`);
+        outputs.set(output, file);
+        entries[extension].push(escapeGlob(toPosix(path.relative(appDirectory, file))));
+    }
+    return entries;
+};
+const resolveAlias = (appDirectory, alias)=>Object.fromEntries(Object.entries(mergeAlias(alias)).map(([key, target])=>[
+            key,
+            [].concat(target).map((value)=>value.startsWith('.') ? path.resolve(appDirectory, value) : value)
+        ]));
+const copyAssets = async (sourceDir, appDirectory, distDir)=>{
+    if (!await fs.pathExists(sourceDir)) return;
+    await fs.copy(sourceDir, path.join(distDir, path.relative(appDirectory, sourceDir)), {
+        filter: (src)=>!SCRIPT_RE.test(src) && !src.endsWith('tsconfig.json')
+    });
+};
+const matchAlias = (alias, request)=>{
+    for (const [key, targets] of Object.entries(alias)){
+        const exact = key.endsWith('$');
+        const name = exact ? key.slice(0, -1) : key;
+        if (request === name || !exact && request.startsWith(`${name}/`)) return {
+            targets,
+            rest: request.slice(name.length)
+        };
+    }
+};
+const isBareSpecifier = (specifier)=>!/^[./]/u.test(specifier) && !path.isAbsolute(specifier);
+const relativeSpecifier = (from, to)=>{
+    const relative = toPosix(path.relative(from, to));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+};
+const importEmittedFile = ({ appDirectory, distDir, alias, sources, reached, assets })=>async ({ request, context, contextInfo, getResolve })=>{
+        if (!request || !context || !contextInfo?.issuer || !getResolve) return;
+        const resolve = getResolve();
+        const resolved = await resolve(context, request).catch(()=>'');
+        if (!resolved) return /^[./]/u.test(request) ? void 0 : request;
+        const fromApp = path.relative(appDirectory, resolved);
+        if (fromApp.startsWith('..') || path.isAbsolute(fromApp) || resolved.includes(`${path.sep}node_modules${path.sep}`)) {
+            const aliased = matchAlias(alias, request);
+            if (!aliased) return request;
+            for (const target of aliased.targets.filter(isBareSpecifier)){
+                const specifier = `${target}${aliased.rest}`;
+                if (await resolve(context, specifier).catch(()=>'') === resolved) return specifier;
+            }
+            const outputDir = path.join(distDir, path.relative(appDirectory, path.dirname(contextInfo.issuer)));
+            return relativeSpecifier(outputDir, resolved);
+        }
+        const script = SCRIPT_RE.test(resolved) && !DECLARATION_RE.test(resolved);
+        if (script && !sources.has(resolved)) reached.add(resolved);
+        if (!script) assets.add(resolved);
+        const emitted = script ? `${resolved.replace(SCRIPT_RE, '')}${outputExtension(resolved)}` : resolved;
+        return relativeSpecifier(path.dirname(contextInfo.issuer), emitted);
+    };
+const compileServerSources = async (appDirectory, config, options)=>{
+    const { sourceDirs, distDir, tsconfigPath, moduleType, excludeFiles = [] } = options;
+    const sources = new Set(await collectSources(sourceDirs, excludeFiles));
+    const copyAllAssets = async ()=>{
+        for (const sourceDir of sourceDirs)await copyAssets(sourceDir, appDirectory, distDir);
+    };
+    const tsgoBinPath = getTsgoBinPath(appDirectory);
+    const { config: tsconfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles);
+    const compilerOptions = tsconfig.compilerOptions ?? {};
+    const tsconfigDir = path.dirname(tsconfigPath);
+    const roots = new Set((tsconfig.files ?? []).map((file)=>path.resolve(tsconfigDir, file)));
+    for (const file of sources){
+        const checked = true === compilerOptions.allowJs || TS_RE.test(file);
+        if (checked && !roots.has(path.resolve(file))) sources.delete(file);
+    }
+    const failOnTypeError = false !== compilerOptions.noEmitOnError;
+    const declaration = true === compilerOptions.declaration;
+    const formats = {
+        '.js': 'module' === moduleType ? 'esm' : 'cjs',
+        '.mjs': 'esm',
+        '.cjs': 'cjs'
+    };
+    const createLibs = (entries)=>{
+        const libs = Object.keys(entries).filter((extension)=>entries[extension].length > 0).map((extension)=>({
+                format: formats[extension],
+                bundle: false,
+                autoExtension: false,
+                outBase: appDirectory,
+                source: {
+                    entry: {
+                        index: entries[extension]
+                    }
+                },
+                output: {
+                    filename: {
+                        js: `[name]${extension}`
+                    }
+                }
+            }));
+        if (declaration) {
+            libs[0].redirect = {
+                dts: {
+                    extension: 'module' === moduleType
+                }
+            };
+            libs[0].dts = {
+                bundle: false,
+                distPath: distDir,
+                tsgo: true,
+                typescriptPath: getTsgoModulePath(appDirectory),
+                abortOnError: failOnTypeError
+            };
+        }
+        return libs;
+    };
+    const alias = resolveAlias(appDirectory, config.alias);
+    const assets = new Set();
+    const build = async ()=>{
+        if (0 === sources.size) return;
+        const { createRslib } = await import("@rslib/core");
+        for(;;){
+            const reached = new Set();
+            const rslib = await createRslib({
+                cwd: appDirectory,
+                config: {
+                    lib: createLibs(groupEntries(appDirectory, sources)),
+                    source: {
+                        tsconfigPath: resolvedConfigPath,
+                        ...compilerOptions.experimentalDecorators ? {
+                            decorators: {
+                                version: 'legacy'
+                            }
+                        } : {}
+                    },
+                    resolve: {
+                        alias
+                    },
+                    output: {
+                        target: 'node',
+                        distPath: {
+                            root: distDir
+                        },
+                        cleanDistPath: false,
+                        sourceMap: {
+                            js: 'source-map'
+                        }
+                    },
+                    performance: {
+                        buildCache: false
+                    },
+                    tools: {
+                        rspack: (rspackConfig)=>{
+                            rspackConfig.externals = [
+                                importEmittedFile({
+                                    appDirectory,
+                                    distDir,
+                                    alias,
+                                    sources,
+                                    reached,
+                                    assets
+                                }),
+                                ...[
+                                    rspackConfig.externals ?? []
+                                ].flat()
+                            ];
+                        }
+                    }
+                }
+            });
+            await rslib.build();
+            if (0 === reached.size) return;
+            for (const file of reached)sources.add(file);
+        }
+    };
+    const typeCheck = async ()=>{
+        if (0 === roots.size) return;
+        const result = await runTsgo(tsgoBinPath, [
+            '-p',
+            resolvedConfigPath,
+            '--noEmit'
+        ], {
+            cwd: appDirectory,
+            reject: false
+        });
+        if (0 === result.code) return;
+        const diagnostics = result.stdout.trim() || result.stderr.trim();
+        if (!failOnTypeError) return void logger.warn(`TS-Go type check found errors:\n${diagnostics}`);
+        throw new Error([
+            `TS-Go type check failed with exit code ${result.code}.`,
+            diagnostics
+        ].filter(Boolean).join('\n'));
+    };
+    const checkReachedSources = async ()=>{
+        const reachedRoots = [
+            ...sources
+        ].filter((file)=>!roots.has(path.resolve(file)) && (true === compilerOptions.allowJs || TS_RE.test(file)));
+        if (0 === reachedRoots.length) return typeCheck();
+        for (const file of reachedRoots)roots.add(path.resolve(file));
+        tsconfig.files = [
+            ...tsconfig.files ?? [],
+            ...reachedRoots.map((file)=>toPosix(path.relative(tsconfigDir, file)))
+        ];
+        await fs.writeFile(resolvedConfigPath, JSON.stringify(tsconfig, null, 2));
+        return typeCheck();
+    };
+    let results;
+    try {
+        const built = await Promise.allSettled([
+            build()
+        ]);
+        results = [
+            ...await Promise.allSettled([
+                checkReachedSources()
+            ]),
+            ...built
+        ];
+    } finally{
+        await fs.remove(resolvedConfigPath);
+    }
+    const failure = results.find((result)=>'rejected' === result.status);
+    if (failure) throw failure.reason;
+    await copyAllAssets();
+    for (const asset of assets)await fs.copy(asset, path.join(distDir, path.relative(appDirectory, asset)));
+    logger.info('Server sources compiled');
+};
+export { compileServerSources };

package/dist/esm/compilers/tsgo.mjs

@@ -0,0 +1,135 @@
+import { fs } from "@modern-js/utils";
+import { spawn } from "child_process";
+import path from "path";
+let resolvedConfigCount = 0;
+const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles = [])=>{
+    const tsconfigDir = path.dirname(tsconfigPath);
+    const output = await runTsgo(tsgoBinPath, [
+        '--showConfig',
+        '-p',
+        tsconfigPath
+    ], {
+        cwd: tsconfigDir
+    });
+    const config = JSON.parse(output.stdout);
+    config.compilerOptions ??= {};
+    const options = config.compilerOptions;
+    options.rootDir = appDirectory;
+    options.composite = false;
+    options.declarationMap = false;
+    options.incremental = false;
+    options.noEmit = true !== options.declaration;
+    options.jsx ??= 'react-jsx';
+    delete options.emitDeclarationOnly;
+    delete options.outDir;
+    delete options.tsBuildInfoFile;
+    config.files = filterSourceFiles(tsconfigDir, sourceDirs, config.files, excludeFiles);
+    delete config.include;
+    delete config.references;
+    if (void 0 !== options.baseUrl) {
+        const baseUrl = path.resolve(tsconfigDir, options.baseUrl);
+        if (options.paths) options.paths = Object.fromEntries(Object.entries(options.paths).map(([key, targets])=>[
+                key,
+                targets.map((target)=>{
+                    const relative = path.relative(tsconfigDir, path.resolve(baseUrl, target)).split(path.sep).join(path.posix.sep);
+                    return relative.startsWith('.') ? relative : `./${relative}`;
+                })
+            ]));
+        delete options.baseUrl;
+    }
+    if ([
+        'node',
+        'node10'
+    ].includes(String(options.moduleResolution).toLowerCase())) delete options.moduleResolution;
+    const resolvedConfigPath = path.join(tsconfigDir, `.tsgo.${process.pid}.${resolvedConfigCount++}.resolved.json`);
+    await fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
+    return {
+        config,
+        resolvedConfigPath
+    };
+};
+const toPosix = (file)=>file.split(path.sep).join(path.posix.sep);
+const filterSourceFiles = (tsconfigDir, sourceDirs, files = [], excludeFiles = [])=>{
+    const sourcePosixPaths = sourceDirs.map(toPosix);
+    const excludedPaths = new Set(excludeFiles.map((file)=>toPosix(path.normalize(file))));
+    return files.filter((fileName)=>{
+        const absoluteFileName = toPosix(path.resolve(tsconfigDir, fileName));
+        if (excludedPaths.has(absoluteFileName)) return false;
+        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
+    });
+};
+const runTsgo = (tsgoBinPath, args, options)=>new Promise((resolve, reject)=>{
+        const child = spawn(process.execPath, [
+            tsgoBinPath,
+            ...args
+        ], {
+            cwd: options.cwd,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data)=>{
+            stdout += data;
+        });
+        child.stderr.on('data', (data)=>{
+            stderr += data;
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            const result = {
+                stdout,
+                stderr,
+                code: code ?? 1
+            };
+            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
+            resolve(result);
+        });
+    });
+const getTsgoBinEntry = (pkg)=>{
+    if ('string' == typeof pkg.bin) return pkg.bin;
+    return pkg.bin?.tsc ?? pkg.bin?.tsgo;
+};
+const TSGO_PACKAGES = [
+    "@typescript/native",
+    "@typescript/native-preview"
+];
+const resolveTsgoPackage = (resolvePaths)=>{
+    for (const name of TSGO_PACKAGES)try {
+        const pkgPath = require.resolve(`${name}/package.json`, {
+            paths: resolvePaths
+        });
+        return {
+            name,
+            pkgPath
+        };
+    } catch  {}
+    throw new Error('tsgo could not be found! Please install "@typescript/native" (or legacy "@typescript/native-preview") in your project to type-check BFF/server code.');
+};
+const getTsgoBinPath = (appDirectory, resolvePaths = [
+    appDirectory,
+    __dirname
+])=>{
+    const { pkgPath } = resolveTsgoPackage(resolvePaths);
+    const pkgDir = path.dirname(pkgPath);
+    const pkg = require(pkgPath);
+    const declaredBinEntry = getTsgoBinEntry(pkg);
+    const candidates = [
+        declaredBinEntry ? path.resolve(pkgDir, declaredBinEntry) : void 0,
+        path.join(pkgDir, 'bin/tsgo.js')
+    ].filter((candidate)=>Boolean(candidate));
+    return candidates.find((candidate)=>fs.existsSync(candidate)) ?? candidates[0];
+};
+const getTsgoModulePath = (appDirectory, resolvePaths = [
+    appDirectory,
+    __dirname
+])=>{
+    const { name } = resolveTsgoPackage(resolvePaths);
+    return require.resolve(name, {
+        paths: resolvePaths
+    });
+};
+export { createResolvedTsgoConfig, getTsgoBinPath, getTsgoModulePath, runTsgo };

package/dist/esm-node/common/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import { logger } from "@modern-js/utils";
 import * as __rspack_external_path from "path";
 const FILE_EXTENSIONS = [
     '.js',
@@ -17,7 +18,17 @@ const compile = async (appDirectory, modernConfig, compileOptions)=>{
     validateAbsolutePaths(sourceDirs, (dir)=>`source dir ${dir} is not an absolute path.`);
     validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
     validateAbsolutePaths(excludeFiles, (file)=>`excluded file ${file} is not an absolute path.`);
-    const { compileByTs } = await import("../compilers/typescript/index.mjs");
-    await compileByTs(appDirectory, modernConfig, compileOptions);
+    if (!tsconfigPath) return;
+    const { compileServerSources } = await import("../compilers/rslib.mjs");
+    try {
+        await compileServerSources(appDirectory, modernConfig, {
+            ...compileOptions,
+            tsconfigPath
+        });
+    } catch (error) {
+        if (compileOptions.throwErrorInsteadOfExit) throw error;
+        logger.error(error);
+        process.exit(1);
+    }
 };
 export { FILE_EXTENSIONS, compile };

package/dist/esm-node/compilers/rslib.mjs

@@ -0,0 +1,258 @@
+import "node:module";
+import { fs, logger, mergeAlias } from "@modern-js/utils";
+import path from "path";
+import { createResolvedTsgoConfig, getTsgoBinPath, getTsgoModulePath, runTsgo } from "./tsgo.mjs";
+const SCRIPT_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/u;
+const DECLARATION_RE = /\.d\.[cm]?ts$/u;
+const TS_RE = /\.[cm]?tsx?$/u;
+const toPosix = (file)=>file.split(path.sep).join(path.posix.sep);
+const escapeGlob = (file)=>file.replace(/[()[\]{}*?!+@]/gu, '\\$&');
+const walk = async (dir)=>{
+    if (!await fs.pathExists(dir)) return [];
+    const entries = await fs.readdir(dir, {
+        withFileTypes: true
+    });
+    const files = await Promise.all(entries.map((entry)=>{
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory()) return 'node_modules' === entry.name ? [] : walk(file);
+        return [
+            file
+        ];
+    }));
+    return files.flat();
+};
+const outputExtension = (file)=>/\.m[jt]s$/u.test(file) ? '.mjs' : /\.c[jt]s$/u.test(file) ? '.cjs' : '.js';
+const collectSources = async (sourceDirs, excludeFiles)=>{
+    const excluded = new Set(excludeFiles.map((file)=>path.normalize(file)));
+    return (await Promise.all(sourceDirs.map(walk))).flat().filter((file)=>SCRIPT_RE.test(file) && !DECLARATION_RE.test(file) && !excluded.has(path.normalize(file)));
+};
+const groupEntries = (appDirectory, files)=>{
+    const outputs = new Map();
+    const entries = {
+        '.js': [],
+        '.mjs': [],
+        '.cjs': []
+    };
+    for (const file of files){
+        const extension = outputExtension(file);
+        const output = `${file.replace(SCRIPT_RE, '')}${extension}`;
+        const existing = outputs.get(output);
+        if (existing) throw new Error(`"${existing}" and "${file}" both compile to "${toPosix(path.relative(appDirectory, output))}". Rename one of them.`);
+        outputs.set(output, file);
+        entries[extension].push(escapeGlob(toPosix(path.relative(appDirectory, file))));
+    }
+    return entries;
+};
+const resolveAlias = (appDirectory, alias)=>Object.fromEntries(Object.entries(mergeAlias(alias)).map(([key, target])=>[
+            key,
+            [].concat(target).map((value)=>value.startsWith('.') ? path.resolve(appDirectory, value) : value)
+        ]));
+const copyAssets = async (sourceDir, appDirectory, distDir)=>{
+    if (!await fs.pathExists(sourceDir)) return;
+    await fs.copy(sourceDir, path.join(distDir, path.relative(appDirectory, sourceDir)), {
+        filter: (src)=>!SCRIPT_RE.test(src) && !src.endsWith('tsconfig.json')
+    });
+};
+const matchAlias = (alias, request)=>{
+    for (const [key, targets] of Object.entries(alias)){
+        const exact = key.endsWith('$');
+        const name = exact ? key.slice(0, -1) : key;
+        if (request === name || !exact && request.startsWith(`${name}/`)) return {
+            targets,
+            rest: request.slice(name.length)
+        };
+    }
+};
+const isBareSpecifier = (specifier)=>!/^[./]/u.test(specifier) && !path.isAbsolute(specifier);
+const relativeSpecifier = (from, to)=>{
+    const relative = toPosix(path.relative(from, to));
+    return relative.startsWith('.') ? relative : `./${relative}`;
+};
+const importEmittedFile = ({ appDirectory, distDir, alias, sources, reached, assets })=>async ({ request, context, contextInfo, getResolve })=>{
+        if (!request || !context || !contextInfo?.issuer || !getResolve) return;
+        const resolve = getResolve();
+        const resolved = await resolve(context, request).catch(()=>'');
+        if (!resolved) return /^[./]/u.test(request) ? void 0 : request;
+        const fromApp = path.relative(appDirectory, resolved);
+        if (fromApp.startsWith('..') || path.isAbsolute(fromApp) || resolved.includes(`${path.sep}node_modules${path.sep}`)) {
+            const aliased = matchAlias(alias, request);
+            if (!aliased) return request;
+            for (const target of aliased.targets.filter(isBareSpecifier)){
+                const specifier = `${target}${aliased.rest}`;
+                if (await resolve(context, specifier).catch(()=>'') === resolved) return specifier;
+            }
+            const outputDir = path.join(distDir, path.relative(appDirectory, path.dirname(contextInfo.issuer)));
+            return relativeSpecifier(outputDir, resolved);
+        }
+        const script = SCRIPT_RE.test(resolved) && !DECLARATION_RE.test(resolved);
+        if (script && !sources.has(resolved)) reached.add(resolved);
+        if (!script) assets.add(resolved);
+        const emitted = script ? `${resolved.replace(SCRIPT_RE, '')}${outputExtension(resolved)}` : resolved;
+        return relativeSpecifier(path.dirname(contextInfo.issuer), emitted);
+    };
+const compileServerSources = async (appDirectory, config, options)=>{
+    const { sourceDirs, distDir, tsconfigPath, moduleType, excludeFiles = [] } = options;
+    const sources = new Set(await collectSources(sourceDirs, excludeFiles));
+    const copyAllAssets = async ()=>{
+        for (const sourceDir of sourceDirs)await copyAssets(sourceDir, appDirectory, distDir);
+    };
+    const tsgoBinPath = getTsgoBinPath(appDirectory);
+    const { config: tsconfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, sourceDirs, tsgoBinPath, excludeFiles);
+    const compilerOptions = tsconfig.compilerOptions ?? {};
+    const tsconfigDir = path.dirname(tsconfigPath);
+    const roots = new Set((tsconfig.files ?? []).map((file)=>path.resolve(tsconfigDir, file)));
+    for (const file of sources){
+        const checked = true === compilerOptions.allowJs || TS_RE.test(file);
+        if (checked && !roots.has(path.resolve(file))) sources.delete(file);
+    }
+    const failOnTypeError = false !== compilerOptions.noEmitOnError;
+    const declaration = true === compilerOptions.declaration;
+    const formats = {
+        '.js': 'module' === moduleType ? 'esm' : 'cjs',
+        '.mjs': 'esm',
+        '.cjs': 'cjs'
+    };
+    const createLibs = (entries)=>{
+        const libs = Object.keys(entries).filter((extension)=>entries[extension].length > 0).map((extension)=>({
+                format: formats[extension],
+                bundle: false,
+                autoExtension: false,
+                outBase: appDirectory,
+                source: {
+                    entry: {
+                        index: entries[extension]
+                    }
+                },
+                output: {
+                    filename: {
+                        js: `[name]${extension}`
+                    }
+                }
+            }));
+        if (declaration) {
+            libs[0].redirect = {
+                dts: {
+                    extension: 'module' === moduleType
+                }
+            };
+            libs[0].dts = {
+                bundle: false,
+                distPath: distDir,
+                tsgo: true,
+                typescriptPath: getTsgoModulePath(appDirectory),
+                abortOnError: failOnTypeError
+            };
+        }
+        return libs;
+    };
+    const alias = resolveAlias(appDirectory, config.alias);
+    const assets = new Set();
+    const build = async ()=>{
+        if (0 === sources.size) return;
+        const { createRslib } = await import("@rslib/core");
+        for(;;){
+            const reached = new Set();
+            const rslib = await createRslib({
+                cwd: appDirectory,
+                config: {
+                    lib: createLibs(groupEntries(appDirectory, sources)),
+                    source: {
+                        tsconfigPath: resolvedConfigPath,
+                        ...compilerOptions.experimentalDecorators ? {
+                            decorators: {
+                                version: 'legacy'
+                            }
+                        } : {}
+                    },
+                    resolve: {
+                        alias
+                    },
+                    output: {
+                        target: 'node',
+                        distPath: {
+                            root: distDir
+                        },
+                        cleanDistPath: false,
+                        sourceMap: {
+                            js: 'source-map'
+                        }
+                    },
+                    performance: {
+                        buildCache: false
+                    },
+                    tools: {
+                        rspack: (rspackConfig)=>{
+                            rspackConfig.externals = [
+                                importEmittedFile({
+                                    appDirectory,
+                                    distDir,
+                                    alias,
+                                    sources,
+                                    reached,
+                                    assets
+                                }),
+                                ...[
+                                    rspackConfig.externals ?? []
+                                ].flat()
+                            ];
+                        }
+                    }
+                }
+            });
+            await rslib.build();
+            if (0 === reached.size) return;
+            for (const file of reached)sources.add(file);
+        }
+    };
+    const typeCheck = async ()=>{
+        if (0 === roots.size) return;
+        const result = await runTsgo(tsgoBinPath, [
+            '-p',
+            resolvedConfigPath,
+            '--noEmit'
+        ], {
+            cwd: appDirectory,
+            reject: false
+        });
+        if (0 === result.code) return;
+        const diagnostics = result.stdout.trim() || result.stderr.trim();
+        if (!failOnTypeError) return void logger.warn(`TS-Go type check found errors:\n${diagnostics}`);
+        throw new Error([
+            `TS-Go type check failed with exit code ${result.code}.`,
+            diagnostics
+        ].filter(Boolean).join('\n'));
+    };
+    const checkReachedSources = async ()=>{
+        const reachedRoots = [
+            ...sources
+        ].filter((file)=>!roots.has(path.resolve(file)) && (true === compilerOptions.allowJs || TS_RE.test(file)));
+        if (0 === reachedRoots.length) return typeCheck();
+        for (const file of reachedRoots)roots.add(path.resolve(file));
+        tsconfig.files = [
+            ...tsconfig.files ?? [],
+            ...reachedRoots.map((file)=>toPosix(path.relative(tsconfigDir, file)))
+        ];
+        await fs.writeFile(resolvedConfigPath, JSON.stringify(tsconfig, null, 2));
+        return typeCheck();
+    };
+    let results;
+    try {
+        const built = await Promise.allSettled([
+            build()
+        ]);
+        results = [
+            ...await Promise.allSettled([
+                checkReachedSources()
+            ]),
+            ...built
+        ];
+    } finally{
+        await fs.remove(resolvedConfigPath);
+    }
+    const failure = results.find((result)=>'rejected' === result.status);
+    if (failure) throw failure.reason;
+    await copyAllAssets();
+    for (const asset of assets)await fs.copy(asset, path.join(distDir, path.relative(appDirectory, asset)));
+    logger.info('Server sources compiled');
+};
+export { compileServerSources };