@module-federation/treeshake-server 2.6.0 → 2.8.0

package/dist/server.mjs

@@ -1,965 +1,37 @@
 #!/usr/bin/env node
 import node_fs from "node:fs";
 import node_path from "node:path";
-import pino from "pino";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import node_os from "node:os";
-import { zValidator } from "@hono/zod-validator";
-import { nanoid } from "nanoid";
-import p_limit from "p-limit";
-import { z } from "zod";
-import { createHash } from "node:crypto";
-import promises from "node:fs/promises";
-import { spawn } from "node:child_process";
-import json_stable_stringify from "json-stable-stringify";
-import { timeout } from "hono/timeout";
-import { serve } from "@hono/node-server";
-const SERVER_VERSION = 'v0-0205';
-const UPLOADED_DIR = '_shared-tree-shaking';
-const createLogger = (opts)=>pino({
-        level: (null == opts ? void 0 : opts.level) ?? 'info',
-        formatters: {
-            level (label) {
-                return {
-                    level: label
-                };
-            }
-        }
-    });
-let logger_logger = createLogger();
-const setLogger = (next)=>{
-    logger_logger = next;
-};
-async function createAdapterDeps(params) {
-    const adapterId = params.adapterId;
-    const adapter = params.registry.getAdapterById(adapterId);
-    return adapter.create(params.adapterConfig ?? {}, {
-        logger: params.logger ?? logger_logger,
-        uploadedDir: params.uploadedDir ?? UPLOADED_DIR
-    });
-}
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-class LocalObjectStore {
-    async exists(key) {
-        const filePath = node_path.join(this.rootDir, key.replace(/^\//, ''));
-        try {
-            const stat = await node_fs.promises.stat(filePath);
-            return stat.isFile();
-        } catch  {
-            return false;
-        }
-    }
-    async uploadFile(localPath, key) {
-        const rel = key.replace(/^\//, '');
-        const dest = node_path.join(this.rootDir, rel);
-        await node_fs.promises.mkdir(node_path.dirname(dest), {
-            recursive: true
-        });
-        await node_fs.promises.copyFile(localPath, dest);
-    }
-    publicUrl(key) {
-        return `${this.publicBaseUrl}${key.replace(/^\//, '')}`;
-    }
-    constructor(opts){
-        _define_property(this, "rootDir", void 0);
-        _define_property(this, "publicBaseUrl", void 0);
-        this.rootDir = (null == opts ? void 0 : opts.rootDir) ?? node_path.join(process.cwd(), 'log', 'static');
-        const port = process.env.PORT || 3000;
-        const base = (null == opts ? void 0 : opts.publicBaseUrl) === '/' ? `http://localhost:${port}/` : (null == opts ? void 0 : opts.publicBaseUrl) ?? '/';
-        this.publicBaseUrl = base.endsWith('/') ? base : `${base}/`;
-    }
-}
-function adapter_define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-function envStr(env, name, fallback) {
-    const v = env[name];
-    if (void 0 === v || '' === v) return fallback;
-    return v;
-}
-class LocalAdapter {
-    fromEnv(env) {
-        return {
-            rootDir: envStr(env, 'LOCAL_STORE_DIR', node_path.join(process.cwd(), 'log', 'static')),
-            publicBaseUrl: envStr(env, 'LOCAL_STORE_BASE_URL', '/')
-        };
-    }
-    async create(config, _context) {
-        const objectStore = new LocalObjectStore({
-            rootDir: config.rootDir,
-            publicBaseUrl: config.publicBaseUrl
-        });
-        return {
-            objectStore
-        };
-    }
-    constructor(){
-        adapter_define_property(this, "id", 'local');
-    }
-}
-function createAdapterRegistry(adapters) {
-    return {
-        adapters,
-        getAdapterById: (id)=>{
-            const found = adapters.find((a)=>a.id === id);
-            if (!found) throw new Error(`Unknown ADAPTER_ID: ${id}`);
-            return found;
-        }
-    };
-}
-function createOssAdapterRegistry() {
-    return createAdapterRegistry([
-        new LocalAdapter()
-    ]);
-}
-function contentTypeByExt(filePath) {
-    if (filePath.endsWith('.js')) return "application/javascript";
-    if (filePath.endsWith('.json')) return 'application/json';
-    return 'application/octet-stream';
-}
-const DEFAULT_STATIC_ROOT = node_path.join(process.cwd(), 'log', 'static');
-async function serveLocalFile(c, rootDir) {
-    let requestPath = c.req.path;
-    try {
-        requestPath = decodeURIComponent(requestPath);
-    } catch  {
-        return c.text('Not Found', 404);
-    }
-    const relPath = requestPath.replace(/^\/+/, '');
-    const rootResolved = node_path.resolve(rootDir);
-    const filePath = node_path.resolve(rootResolved, relPath);
-    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${node_path.sep}`)) return c.text('Not Found', 404);
-    try {
-        const buf = await node_fs.promises.readFile(filePath);
-        return new Response(new Uint8Array(buf), {
-            status: 200,
-            headers: {
-                'Content-Type': contentTypeByExt(filePath)
-            }
-        });
-    } catch  {
-        return c.text('Not Found', 404);
-    }
-}
-function createStaticRoute(opts) {
-    const staticRoute = new Hono();
-    const rootDir = (null == opts ? void 0 : opts.rootDir) ?? DEFAULT_STATIC_ROOT;
-    staticRoute.get('/tree-shaking-shared/*', async (c)=>serveLocalFile(c, rootDir));
-    return staticRoute;
-}
+import { createServer, createOssAdapterRegistry, createLogger, DEFAULT_STATIC_ROOT, createApp, createAdapterDeps } from "./876.mjs";
 const DEFAULT_PRUNE_INTERVAL_MS = 3600000;
-function ossEnv_envStr(env, name, fallback) {
+function envStr(env, name, fallback) {
     const v = env[name];
     if (void 0 === v || '' === v) return fallback;
     return v;
 }
 function envNum(env, name, fallback) {
-    const v = ossEnv_envStr(env, name);
+    const v = envStr(env, name);
     if (!v) return fallback;
     const n = Number(v);
     return Number.isFinite(n) ? n : fallback;
 }
 function resolveOssEnv(params) {
-    const adapterId = ossEnv_envStr(params.env, 'ADAPTER_ID', params.defaultAdapterId) ?? 'local';
+    const adapterId = envStr(params.env, 'ADAPTER_ID', params.defaultAdapterId) ?? 'local';
     const adapter = params.registry.getAdapterById(adapterId);
     const adapterConfig = adapter.fromEnv ? adapter.fromEnv(params.env) : {};
     return {
         adapterId,
         adapterConfig,
-        corsOrigin: ossEnv_envStr(params.env, 'CORS_ORIGIN', '*') ?? '*',
-        staticRootDir: ossEnv_envStr(params.env, 'LOCAL_STORE_DIR', DEFAULT_STATIC_ROOT) ?? DEFAULT_STATIC_ROOT,
-        logLevel: ossEnv_envStr(params.env, 'LOG_LEVEL', 'info') ?? 'info',
+        corsOrigin: envStr(params.env, 'CORS_ORIGIN', '*') ?? '*',
+        staticRootDir: envStr(params.env, 'LOCAL_STORE_DIR', DEFAULT_STATIC_ROOT) ?? DEFAULT_STATIC_ROOT,
+        logLevel: envStr(params.env, 'LOG_LEVEL', 'info') ?? 'info',
         port: envNum(params.env, 'PORT', 3000),
-        hostname: ossEnv_envStr(params.env, 'HOST', '0.0.0.0') ?? '0.0.0.0',
+        hostname: envStr(params.env, 'HOST', '0.0.0.0') ?? '0.0.0.0',
         pruneIntervalMs: envNum(params.env, 'PNPM_PRUNE_INTERVAL_MS', DEFAULT_PRUNE_INTERVAL_MS),
         runtimeEnv: params.env
     };
 }
-function createDiMiddleware(deps) {
-    return async (c, next)=>{
-        c.set('objectStore', deps.objectStore);
-        if (deps.projectPublisher) c.set('projectPublisher', deps.projectPublisher);
-        await next();
-    };
-}
-const loggerMiddleware = async (c, next)=>{
-    const category = c.req.path.split('/')[1] || 'root';
-    const child = logger_logger.child({
-        category,
-        path: c.req.path,
-        method: c.req.method
-    });
-    c.set('logger', child);
-    await next();
-};
-const parseNormalizedKey = (key)=>{
-    const res = key.split('@');
-    return {
-        name: res.slice(0, -1).join('@'),
-        version: res[res.length - 1]
-    };
-};
-const normalizedKey = (name, v)=>`${name}@${v}`;
-function normalizeConfig(config) {
-    const { shared, plugins, target, libraryType, hostName, uploadOptions } = config;
-    const commonNormalizedConfig = {
-        plugins: (null == plugins ? void 0 : plugins.sort(([a], [b])=>a.localeCompare(b))) ?? [],
-        target: Array.isArray(target) ? [
-            ...target
-        ].sort() : [
-            target
-        ],
-        uploadOptions,
-        libraryType,
-        hostName
-    };
-    const normalizedConfig = {};
-    shared.forEach(([sharedName, version, usedExports], index)=>{
-        const key = normalizedKey(sharedName, version);
-        normalizedConfig[key] = {
-            ...commonNormalizedConfig,
-            shared: shared.slice(0, index).concat(shared.slice(index + 1)).sort(([s, v, u], [b, v2, u2])=>`${s}${v}${u.sort().join('')}`.localeCompare(`${b}${v2}${u2.sort().join('')}`)),
-            usedExports
-        };
-    });
-    return normalizedConfig;
-}
-function extractBuildConfig(config, type) {
-    const { shared, plugins, target, libraryType, usedExports, hostName } = config;
-    return {
-        shared,
-        plugins,
-        target,
-        libraryType,
-        usedExports,
-        type,
-        hostName
-    };
-}
-const UploadOptionsSchema = z.object({
-    scmName: z.string(),
-    bucketName: z.string(),
-    publicFilePath: z.string(),
-    publicPath: z.string(),
-    cdnRegion: z.string()
-});
-const BasicSchema = z.object({
-    shared: z.array(z.tuple([
-        z.string(),
-        z.string(),
-        z.array(z.string())
-    ])).describe('List of plugins: [name, version, usedExports]'),
-    plugins: z.array(z.tuple([
-        z.string(),
-        z.string().optional()
-    ])).describe('Specify extra build plugin names, support specify version in second item').optional(),
-    target: z.union([
-        z.string(),
-        z.array(z.string())
-    ]).describe('Used to configure the target environment of Rspack output and the ECMAScript version of Rspack runtime code, the same with rspack#target'),
-    libraryType: z.string(),
-    hostName: z.string().describe('The name of the host app / mf')
-});
-const ConfigSchema = BasicSchema.extend({
-    uploadOptions: UploadOptionsSchema.optional()
-});
-const CheckTreeShakingSchema = ConfigSchema.extend({
-    uploadOptions: UploadOptionsSchema.optional()
-});
-const STATS_NAME = 'mf-stats.json';
-let runtimeEnv = {};
-const setRuntimeEnv = (env)=>{
-    runtimeEnv = env;
-};
-const getRuntimeEnv = ()=>runtimeEnv;
-function runCommand_define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-class CommandExecutionError extends Error {
-    constructor(command, exitCode, stdout, stderr){
-        super(`Command "${command}" exited with code ${exitCode}`), runCommand_define_property(this, "command", void 0), runCommand_define_property(this, "exitCode", void 0), runCommand_define_property(this, "stdout", void 0), runCommand_define_property(this, "stderr", void 0);
-        this.name = 'CommandExecutionError';
-        this.command = command;
-        this.exitCode = exitCode;
-        this.stdout = stdout;
-        this.stderr = stderr;
-    }
-}
-const runCommand = (command, options = {})=>new Promise((resolve, reject)=>{
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        const child = spawn(command, {
-            cwd: options.cwd,
-            env: {
-                ...getRuntimeEnv(),
-                ...options.env
-            },
-            shell: true,
-            stdio: [
-                'ignore',
-                'pipe',
-                'pipe'
-            ]
-        });
-        child.stdout.on('data', (chunk)=>{
-            stdoutChunks.push(chunk.toString());
-        });
-        child.stderr.on('data', (chunk)=>{
-            stderrChunks.push(chunk.toString());
-        });
-        child.on('error', (error)=>{
-            reject(error);
-        });
-        child.on('close', (exitCode)=>{
-            const stdout = stdoutChunks.join('');
-            const stderr = stderrChunks.join('');
-            if (0 === exitCode) return void resolve({
-                stdout,
-                stderr,
-                exitCode
-            });
-            reject(new CommandExecutionError(command, exitCode ?? -1, stdout, stderr));
-        });
-    });
-let installs = 0;
-let pruneScheduled = false;
-let pruning = false;
-const DEFAULT_INTERVAL = 3600000;
-const markInstallStart = ()=>{
-    installs++;
-};
-const markInstallEnd = ()=>{
-    installs = Math.max(0, installs - 1);
-    schedulePruneSoon();
-};
-const schedulePruneSoon = (delay = 30000)=>{
-    if (pruneScheduled) return;
-    pruneScheduled = true;
-    setTimeout(()=>{
-        pruneScheduled = false;
-        maybePrune();
-    }, delay);
-};
-const maybePrune = async ()=>{
-    if (pruning || installs > 0) return void schedulePruneSoon(60000);
-    pruning = true;
-    try {
-        await runCommand('pnpm store prune');
-    } catch  {} finally{
-        pruning = false;
-    }
-};
-const startPeriodicPrune = (intervalMs = DEFAULT_INTERVAL)=>{
-    if (intervalMs <= 0) return;
-    setInterval(()=>{
-        maybePrune();
-    }, intervalMs);
-};
-const createUniqueTempDirByKey = async (key)=>{
-    const base = node_path.join(node_os.tmpdir(), `re-shake-share-${key}`);
-    let candidate = base;
-    for(;;)try {
-        await promises.mkdir(candidate, {
-            recursive: false
-        });
-        return candidate;
-    } catch  {
-        const rand = Math.floor(1e9 * Math.random());
-        candidate = `${base}-${rand}`;
-    }
-};
-const prepareProject = async (config, excludeShared)=>{
-    const key = createHash('sha256').update(JSON.stringify(config)).digest('hex');
-    const dir = await createUniqueTempDirByKey(key);
-    const templateDir = node_path.join(__dirname, '.', 'template', 're-shake-share');
-    await promises.cp(templateDir, dir, {
-        recursive: true
-    });
-    const pkgPath = node_path.join(dir, 'package.json');
-    const indexPath = node_path.join(dir, 'index.ts');
-    const rspackConfigPath = node_path.join(dir, 'rspack.config.ts');
-    const [pkgContent, indexContent, rspackConfigContent] = await Promise.all([
-        promises.readFile(pkgPath, 'utf-8'),
-        promises.readFile(indexPath, 'utf-8'),
-        promises.readFile(rspackConfigPath, 'utf-8')
-    ]);
-    const pkg = JSON.parse(pkgContent);
-    const deps = {
-        ...pkg.dependencies || {}
-    };
-    const shared = {};
-    const mfConfig = {
-        name: 're_shake',
-        library: {
-            type: 'global'
-        },
-        manifest: true,
-        shared
-    };
-    let pluginImportStr = '';
-    let pluginOptionStr = '[\n';
-    let sharedImport = '';
-    Object.entries(config).forEach(([key, { plugins = [], libraryType, usedExports, hostName }], index)=>{
-        const { name, version } = parseNormalizedKey(key);
-        deps[name] = version;
-        if (!index) {
-            plugins.forEach(([pluginName, pluginVersion], pIndex)=>{
-                deps[pluginName] = pluginVersion ?? 'latest';
-                const pluginImportName = `plugin_${pIndex}`;
-                pluginImportStr += `import ${pluginImportName} from '${pluginName}';\n`;
-                pluginOptionStr += `new ${pluginImportName}(),`;
-            });
-            mfConfig.library.type = libraryType;
-            mfConfig.name = hostName;
-        }
-        shared[name] = {
-            requiredVersion: version,
-            version,
-            treeShaking: excludeShared.some(([n, v])=>n === name && v === version) ? void 0 : {
-                usedExports,
-                mode: 'server-calc'
-            }
-        };
-        sharedImport += `import shared_${index} from '${name}';\n`;
-    });
-    pluginOptionStr += '\n]';
-    pkg.dependencies = deps;
-    const newPkgContent = JSON.stringify(pkg, null, 2);
-    const sharedImportPlaceholder = "${SHARED_IMPORT}";
-    const newIndexContent = indexContent.replace(sharedImportPlaceholder, sharedImport);
-    const pluginsPlaceholder = "${ PLUGINS }";
-    const mfConfigPlaceholder = "${ MF_CONFIG }";
-    let cfg = rspackConfigContent;
-    cfg += pluginImportStr;
-    cfg = cfg.replace(pluginsPlaceholder, pluginOptionStr);
-    cfg = cfg.replace(mfConfigPlaceholder, JSON.stringify(mfConfig, null, 2));
-    await Promise.all([
-        promises.writeFile(pkgPath, newPkgContent),
-        promises.writeFile(indexPath, newIndexContent),
-        promises.writeFile(rspackConfigPath, cfg)
-    ]);
-    return dir;
-};
-const installDependencies = async (cwd)=>{
-    markInstallStart();
-    try {
-        await runCommand("pnpm i --ignore-scripts --prefer-offline --reporter=silent ", {
-            cwd,
-            env: {
-                npm_config_registry: process.env.MF_NPM_REGISTRY || 'https://registry.npmjs.org/'
-            }
-        });
-    } finally{
-        markInstallEnd();
-    }
-};
-const buildProject = async (cwd, type)=>{
-    const scripts = [];
-    if ('re-shake' === type) scripts.push('pnpm build');
-    else scripts.push('pnpm build:full');
-    await Promise.all(scripts.map((script)=>runCommand(script, {
-            cwd
-        })));
-};
-const retrieveSharedFilepaths = async (projectDir, type)=>{
-    const sharedFilepaths = [];
-    const collectSharedFilepaths = async (t)=>{
-        const dir = 'full' === t ? 'full-shared' : 'dist';
-        const distDir = node_path.join(projectDir, dir);
-        const statsContent = await promises.readFile(node_path.join(distDir, STATS_NAME), 'utf-8');
-        const stats = JSON.parse(statsContent);
-        stats.shared.forEach((s)=>{
-            const { name, version, fallback, fallbackName } = s;
-            if (fallback && fallbackName) {
-                var _s_usedExports;
-                const filepath = node_path.join(distDir, fallback);
-                sharedFilepaths.push({
-                    name,
-                    version,
-                    filepath,
-                    globalName: fallbackName,
-                    type: t,
-                    modules: s.usedExports,
-                    canTreeShaking: s.canTreeShaking ?? (null == (_s_usedExports = s.usedExports) ? void 0 : _s_usedExports.length) !== 0
-                });
-            }
-        });
-    };
-    await collectSharedFilepaths(type);
-    return sharedFilepaths;
-};
-const runBuild = async (normalizedConfig, excludeShared, type)=>{
-    const tStart = Date.now();
-    const tmpDir = await prepareProject(normalizedConfig, excludeShared);
-    const tPrepare = Date.now();
-    logger_logger.info(`prepareProject took ${tPrepare - tStart}ms`);
-    await installDependencies(tmpDir);
-    const tInstall = Date.now();
-    logger_logger.info(`installDependencies took ${tInstall - tPrepare}ms`);
-    await buildProject(tmpDir, type);
-    const tBuild = Date.now();
-    logger_logger.info(`buildProject took ${tBuild - tInstall}ms`);
-    const sharedFilePaths = await retrieveSharedFilepaths(tmpDir, type);
-    const tRetrieve = Date.now();
-    logger_logger.info(`retrieveSharedFilepaths took ${tRetrieve - tBuild}ms`);
-    return {
-        sharedFilePaths,
-        dir: tmpDir
-    };
-};
-async function cleanUp(tmpDir) {
-    if (!tmpDir) return;
-    await promises.rm(tmpDir, {
-        recursive: true,
-        force: true
-    });
-}
-const encodeName = function(name, prefix = '', withExt = false) {
-    const ext = withExt ? '.js' : '';
-    return `${prefix}${name.replace(/@/g, 'scope_').replace(/-/g, '_').replace(/\//g, '__').replace(/\./g, '')}${ext}`;
-};
-function retrieveGlobalName(mfName, sharedName, version) {
-    return encodeName(`${mfName}_${sharedName}_${version}`);
-}
-function createCacheHash(config, type) {
-    const relevant = extractBuildConfig({
-        ...config,
-        usedExports: 'full' === type ? [] : config.usedExports
-    }, type);
-    const json = json_stable_stringify(relevant);
-    if (!json) throw new Error('Can not stringify build config!');
-    return createHash('sha256').update(json).digest('hex');
-}
-function retrieveCDNPath({ config, sharedKey, type }) {
-    const configHash = createCacheHash(config, type);
-    return `tree-shaking-shared/${SERVER_VERSION}/${sharedKey}/${configHash}.js`;
-}
-async function cacheService_hitCache(sharedKey, config, type, store) {
-    const cdnPath = retrieveCDNPath({
-        config,
-        sharedKey,
-        type
-    });
-    const exists = await store.exists(cdnPath);
-    return exists ? store.publicUrl(cdnPath) : null;
-}
-const retrieveCacheItems = async (normalizedConfig, type, store)=>{
-    const cacheItems = [];
-    const restConfig = {};
-    const excludeShared = [];
-    for (const [sharedKey, config] of Object.entries(normalizedConfig)){
-        let cache = false;
-        const { name, version } = parseNormalizedKey(sharedKey);
-        const cdnUrl = await cacheService_hitCache(sharedKey, config, type, store);
-        if (cdnUrl) {
-            cache = true;
-            cacheItems.push({
-                type,
-                name,
-                version,
-                cdnUrl,
-                globalName: retrieveGlobalName(config.hostName, name, version)
-            });
-        }
-        if (cache) excludeShared.push([
-            name,
-            version
-        ]);
-        else if (config.usedExports.length || 're-shake' !== type) restConfig[sharedKey] = config;
-        else excludeShared.push([
-            name,
-            version
-        ]);
-    }
-    return {
-        cacheItems,
-        excludeShared,
-        restConfig
-    };
-};
-async function uploadToCacheStore(sharedFilePaths, normalizedConfig, store) {
-    const results = [];
-    for (const file of sharedFilePaths){
-        const { name, version, filepath, globalName, type, modules, canTreeShaking } = file;
-        try {
-            const sharedKey = normalizedKey(name, version);
-            logger_logger.info(`Uploading ${sharedKey} to CDN`);
-            const config = normalizedConfig[sharedKey];
-            const cdnPath = retrieveCDNPath({
-                config,
-                sharedKey,
-                type
-            });
-            const t0 = Date.now();
-            await store.uploadFile(filepath, cdnPath);
-            const tUpload = Date.now() - t0;
-            const cdnUrl = store.publicUrl(cdnPath);
-            const res = {
-                name: name,
-                version: version,
-                globalName: globalName,
-                cdnUrl,
-                type,
-                modules,
-                canTreeShaking
-            };
-            try {
-                const jsonFilePath = filepath.replace(/\.js$/, '.json');
-                const jsonFile = JSON.stringify(res);
-                const jsonCdnUrl = cdnPath.replace(/\.js$/, '.json');
-                await promises.writeFile(jsonFilePath, jsonFile);
-                await store.uploadFile(jsonFilePath, jsonCdnUrl);
-            } catch (error) {
-                logger_logger.error(`Failed to upload ${name}@${version} json file: ${error}`);
-            }
-            results.push(res);
-            logger_logger.info(`Successfully uploaded ${name}@${version} to ${cdnUrl} in ${tUpload}ms`);
-        } catch (error) {
-            logger_logger.error(`Failed to upload ${name}@${version}: ${error}`);
-            throw error;
-        }
-    }
-    return results;
-}
-const downloadToFile = async (url, destPath)=>{
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`Download failed: ${res.status} ${res.statusText} - ${url}`);
-    const buf = Buffer.from(await res.arrayBuffer());
-    await promises.mkdir(node_path.dirname(destPath), {
-        recursive: true
-    });
-    await promises.writeFile(destPath, buf);
-    return destPath;
-};
-async function uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher, store) {
-    const tmpDir = await createUniqueTempDirByKey(`upload-project${Date.now().toString()}`);
-    const uploaded = [];
-    try {
-        for (const item of uploadResults)try {
-            const sharedKey = normalizedKey(item.name, item.version);
-            const config = normalizedConfig[sharedKey];
-            if (!config) {
-                logger_logger.error(`No config found for ${item.name}`);
-                continue;
-            }
-            const { uploadOptions } = config;
-            if (!uploadOptions) throw new Error(`No uploadOptions found for ${item.name}`);
-            const filename = node_path.basename(new URL(item.cdnUrl, 'http://dummy.com').pathname);
-            const localPath = node_path.join(tmpDir, filename);
-            const hash = createCacheHash({
-                ...config,
-                plugins: config.plugins || []
-            }, item.type);
-            const cdnUrl = publisher.publicUrl({
-                sharedName: item.name,
-                hash,
-                fileName: filename,
-                options: uploadOptions
-            });
-            const hitCache = await publisher.exists(cdnUrl);
-            if (hitCache) {
-                logger_logger.info(`Hit cache for ${item.name}@${item.version} -> ${cdnUrl}`);
-                uploaded.push({
-                    ...item,
-                    cdnUrl
-                });
-                continue;
-            }
-            logger_logger.info(`Downloading ${item.name}@${item.version} -> ${localPath}`);
-            const t0 = Date.now();
-            await downloadToFile(item.cdnUrl, localPath);
-            const tDownload = Date.now() - t0;
-            logger_logger.info(`Downloaded ${item.name}@${item.version} in ${tDownload}ms`);
-            const newCdnUrl = await publisher.publishFile({
-                localPath,
-                sharedName: item.name,
-                hash,
-                options: uploadOptions
-            });
-            uploaded.push({
-                ...item,
-                cdnUrl: newCdnUrl
-            });
-        } catch (error) {
-            logger_logger.error(`Failed to upload ${item.name}@${item.version}: ${error}`);
-        }
-        for (const s of sharedFilePaths)try {
-            const config = normalizedConfig[normalizedKey(s.name, s.version)];
-            if (!config) {
-                logger_logger.error(`No config found for ${s.name}`);
-                continue;
-            }
-            const { uploadOptions } = config;
-            if (!uploadOptions) throw new Error(`No uploadOptions found for ${s.name}`);
-            const hash = createCacheHash({
-                ...config,
-                plugins: config.plugins || []
-            }, s.type);
-            const cdnUrl = await publisher.publishFile({
-                localPath: s.filepath,
-                sharedName: s.name,
-                hash,
-                options: uploadOptions
-            });
-            uploaded.push({
-                name: s.name,
-                version: s.version,
-                globalName: s.globalName,
-                cdnUrl,
-                type: s.type,
-                modules: s.modules,
-                canTreeShaking: s.canTreeShaking
-            });
-        } catch (error) {
-            logger_logger.error(`Failed to upload ${s.name}@${s.version}: ${error}`);
-        }
-        return uploaded;
-    } finally{
-        promises.rm(tmpDir, {
-            recursive: true,
-            force: true
-        }).catch((err)=>{
-            logger_logger.error(`Failed to cleanup dir ${tmpDir}: ${err}`);
-        });
-    }
-}
-async function upload(sharedFilePaths, uploadResults, normalizedConfig, uploadOptions, store, publisher) {
-    const cacheUploaded = await uploadToCacheStore(sharedFilePaths, normalizedConfig, store);
-    if (!uploadOptions) {
-        const hydrated = await Promise.all(uploadResults.map(async (item)=>{
-            if ('full' !== item.type) return item;
-            const tmpDir = await createUniqueTempDirByKey(`download-full-json${Date.now().toString()}`);
-            const jsonPath = node_path.join(tmpDir, `${item.name}-${item.version}.json`);
-            try {
-                const tJson0 = Date.now();
-                await downloadToFile(item.cdnUrl.replace('.js', '.json'), jsonPath);
-                const tJson = Date.now() - tJson0;
-                logger_logger.info(`Downloaded ${item.name}@${item.version} json in ${tJson}ms`);
-                const jsonContent = JSON.parse(await promises.readFile(jsonPath, 'utf8'));
-                return {
-                    ...item,
-                    canTreeShaking: jsonContent.canTreeShaking,
-                    modules: jsonContent.modules
-                };
-            } catch (jsonError) {
-                logger_logger.error(`Failed to download ${item.name}@${item.version} json: ${jsonError}`);
-                return {
-                    ...item,
-                    canTreeShaking: item.canTreeShaking ?? true
-                };
-            } finally{
-                await promises.rm(tmpDir, {
-                    recursive: true,
-                    force: true
-                });
-            }
-        }));
-        return [
-            ...cacheUploaded,
-            ...hydrated
-        ];
-    }
-    if (!publisher) throw new Error('uploadOptions provided but no projectPublisher configured (configure the selected adapter to enable it or omit uploadOptions)');
-    const projectUploadResults = await uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher, store);
-    return projectUploadResults;
-}
-const buildLimit = p_limit(Math.max(1, node_os.cpus().length));
-const buildRoute = new Hono();
-buildRoute.post('/', zValidator('json', ConfigSchema), async (c)=>{
-    const logger = c.get('logger');
-    const startTime = Date.now();
-    const jobId = nanoid();
-    logger.info(jobId);
-    const body = c.req.valid('json');
-    logger.info(JSON.stringify(body));
-    const normalizedConfig = normalizeConfig(body);
-    const store = c.get('objectStore');
-    const publisher = c.get('projectPublisher');
-    try {
-        const t0 = Date.now();
-        const { cacheItems, excludeShared, restConfig } = await retrieveCacheItems(normalizedConfig, 're-shake', store);
-        const tRetrieveCache = Date.now();
-        logger.info(`retrieveCacheItems took ${tRetrieveCache - t0}ms`);
-        let sharedFilePaths = [];
-        let dir;
-        if (Object.keys(restConfig).length > 0) {
-            const buildResult = await buildLimit(()=>runBuild(normalizedConfig, excludeShared, 're-shake'));
-            sharedFilePaths = buildResult.sharedFilePaths;
-            dir = buildResult.dir;
-        }
-        const tBuild = Date.now();
-        logger.info(`runBuild took ${tBuild - tRetrieveCache}ms`);
-        const uploadResults = await upload(sharedFilePaths, cacheItems, normalizedConfig, body.uploadOptions, store, publisher);
-        const tUpload = Date.now();
-        logger.info(`upload took ${tUpload - tBuild}ms`);
-        cleanUp(dir).catch((err)=>{
-            logger.error(`Failed to cleanup dir ${dir}: ${err}`);
-        });
-        const tCleanUp = Date.now();
-        logger.info(`cleanUp scheduled (non-blocking) took ${tCleanUp - tUpload}ms`);
-        return c.json({
-            jobId,
-            status: 'success',
-            data: uploadResults,
-            cached: cacheItems,
-            duration: Date.now() - startTime
-        });
-    } catch (error) {
-        if (error instanceof CommandExecutionError) {
-            if (137 === error.exitCode) maybePrune();
-            return c.json({
-                jobId,
-                status: 'failed',
-                error: error.message,
-                command: error.command,
-                exitCode: error.exitCode,
-                stdout: error.stdout,
-                stderr: error.stderr
-            });
-        }
-        return c.json({
-            jobId,
-            status: 'failed',
-            error: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-async function handleCheckTreeshake(c, body) {
-    const logger = c.get('logger');
-    const startTime = Date.now();
-    const jobId = nanoid();
-    logger.info(jobId);
-    logger.info(JSON.stringify(body));
-    const normalizedConfig = normalizeConfig(body);
-    const store = c.get('objectStore');
-    const publisher = c.get('projectPublisher');
-    try {
-        const t0 = Date.now();
-        const { cacheItems, excludeShared, restConfig } = await retrieveCacheItems(normalizedConfig, 'full', store);
-        const tRetrieveCache = Date.now();
-        logger.info(`retrieveCacheItems took ${tRetrieveCache - t0}ms`);
-        let sharedFilePaths = [];
-        let dir;
-        if (Object.keys(restConfig).length > 0) {
-            const buildResult = await buildLimit(()=>runBuild(normalizedConfig, excludeShared, 'full'));
-            sharedFilePaths = buildResult.sharedFilePaths;
-            dir = buildResult.dir;
-        }
-        const tBuild = Date.now();
-        logger.info(`runBuild took ${tBuild - tRetrieveCache}ms`);
-        const uploadResults = await upload(sharedFilePaths, cacheItems, normalizedConfig, body.uploadOptions, store, publisher);
-        const tUpload = Date.now();
-        logger.info(`upload took ${tUpload - tBuild}ms`);
-        cleanUp(dir).catch((err)=>{
-            logger.error(`Failed to cleanup dir ${dir}: ${err}`);
-        });
-        const tCleanUp = Date.now();
-        logger.info(`cleanUp scheduled (non-blocking) took ${tCleanUp - tUpload}ms`);
-        return c.json({
-            jobId,
-            status: 'success',
-            data: uploadResults,
-            cached: cacheItems,
-            duration: Date.now() - startTime
-        });
-    } catch (error) {
-        if (error instanceof CommandExecutionError) {
-            if (137 === error.exitCode) maybePrune();
-            return c.json({
-                jobId,
-                status: 'failed',
-                error: error.message,
-                command: error.command,
-                exitCode: error.exitCode,
-                stdout: error.stdout,
-                stderr: error.stderr
-            });
-        }
-        return c.json({
-            jobId,
-            status: 'failed',
-            error: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-}
-buildRoute.post('/check-tree-shaking', zValidator('json', CheckTreeShakingSchema), async (c)=>handleCheckTreeshake(c, c.req.valid('json')));
-const maintenanceRoute = new Hono();
-maintenanceRoute.post('/', async (c)=>{
-    const logger = c.get('logger');
-    const jobId = nanoid();
-    const startTime = Date.now();
-    logger.info(jobId);
-    await maybePrune();
-    return c.json({
-        jobId,
-        status: 'success',
-        duration: Date.now() - startTime
-    });
-});
-const routes = new Hono();
-routes.route('/build', buildRoute);
-routes.route('/clean-cache', maintenanceRoute);
-function createApp(deps, opts) {
-    var _opts_appExtensions, _opts_frontendAdapters;
-    if (null == opts ? void 0 : opts.logger) setLogger(opts.logger);
-    setRuntimeEnv((null == opts ? void 0 : opts.runtimeEnv) ?? process.env);
-    const app = new Hono();
-    const corsOrigin = (null == opts ? void 0 : opts.corsOrigin) ?? '*';
-    const staticRootDir = (null == opts ? void 0 : opts.staticRootDir) ?? DEFAULT_STATIC_ROOT;
-    app.use('*', cors({
-        origin: corsOrigin,
-        allowMethods: [
-            'GET',
-            'POST',
-            'OPTIONS'
-        ],
-        allowHeaders: [
-            'Content-Type',
-            'Authorization'
-        ]
-    }));
-    app.use('*', loggerMiddleware);
-    app.use('*', createDiMiddleware(deps));
-    app.use('*', timeout(60000));
-    if (null == opts ? void 0 : null == (_opts_appExtensions = opts.appExtensions) ? void 0 : _opts_appExtensions.length) for (const extend of opts.appExtensions)extend(app);
-    app.get('/tree-shaking-shared/healthz', (c)=>c.json({
-            status: 'ok',
-            timestamp: new Date().toISOString()
-        }));
-    app.route('/tree-shaking-shared', routes);
-    app.route('/', createStaticRoute({
-        rootDir: staticRootDir
-    }));
-    if (null == opts ? void 0 : null == (_opts_frontendAdapters = opts.frontendAdapters) ? void 0 : _opts_frontendAdapters.length) for (const adapter of opts.frontendAdapters)adapter.register(app);
-    startPeriodicPrune(null == opts ? void 0 : opts.pruneIntervalMs);
-    return app;
-}
 const defaultBasePath = '/tree-shaking';
-const embeddedAdapter_contentTypeByExt = (filePath)=>{
+const contentTypeByExt = (filePath)=>{
     if (filePath.endsWith('.html')) return 'text/html; charset=utf-8';
     if (filePath.endsWith('.js')) return "application/javascript";
     if (filePath.endsWith('.css')) return 'text/css';
@@ -1002,7 +74,7 @@ function createEmbeddedFrontendAdapter(opts) {
                 return new Response(new Uint8Array(buf), {
                     status: 200,
                     headers: {
-                        'Content-Type': embeddedAdapter_contentTypeByExt(filePath)
+                        'Content-Type': contentTypeByExt(filePath)
                     }
                 });
             }
@@ -1015,7 +87,7 @@ function createEmbeddedFrontendAdapter(opts) {
             return new Response(new Uint8Array(buf), {
                 status: 200,
                 headers: {
-                    'Content-Type': embeddedAdapter_contentTypeByExt(fallbackPath)
+                    'Content-Type': contentTypeByExt(fallbackPath)
                 }
             });
         } catch  {
@@ -1031,16 +103,6 @@ function createEmbeddedFrontendAdapter(opts) {
         }
     };
 }
-function createServer(opts) {
-    const port = opts.port ?? 3000;
-    const hostname = opts.hostname ?? '0.0.0.0';
-    return serve({
-        fetch: opts.app.fetch,
-        port,
-        hostname,
-        overrideGlobalObjects: false
-    });
-}
 const hasIndexHtml = (dir)=>Boolean(dir && node_fs.existsSync(node_path.join(dir, 'index.html')));
 const resolveFrontendDistDir = ()=>{
     const envDir = process.env.TREESHAKE_FRONTEND_DIST;