@module-federation/treeshake-server 0.0.0-chore-bump-node-22-20260710161714

package/dist/server.js

@@ -0,0 +1,1144 @@
+#!/usr/bin/env node
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const SERVER_VERSION = 'v0-0205';
+const UPLOADED_DIR = '_shared-tree-shaking';
+const external_pino_namespaceObject = require("pino");
+var external_pino_default = /*#__PURE__*/ __webpack_require__.n(external_pino_namespaceObject);
+const createLogger = (opts)=>external_pino_default()({
+        level: 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 = external_node_path_default().join(this.rootDir, key.replace(/^\//, ''));
+        try {
+            const stat = await external_node_fs_default().promises.stat(filePath);
+            return stat.isFile();
+        } catch  {
+            return false;
+        }
+    }
+    async uploadFile(localPath, key) {
+        const rel = key.replace(/^\//, '');
+        const dest = external_node_path_default().join(this.rootDir, rel);
+        await external_node_fs_default().promises.mkdir(external_node_path_default().dirname(dest), {
+            recursive: true
+        });
+        await external_node_fs_default().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 = opts?.rootDir ?? external_node_path_default().join(process.cwd(), 'log', 'static');
+        const port = process.env.PORT || 3000;
+        const base = opts?.publicBaseUrl === '/' ? `http://localhost:${port}/` : 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', external_node_path_default().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()
+    ]);
+}
+const external_hono_namespaceObject = require("hono");
+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 = external_node_path_default().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 = external_node_path_default().resolve(rootDir);
+    const filePath = external_node_path_default().resolve(rootResolved, relPath);
+    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${external_node_path_default().sep}`)) return c.text('Not Found', 404);
+    try {
+        const buf = await external_node_fs_default().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 external_hono_namespaceObject.Hono();
+    const rootDir = opts?.rootDir ?? DEFAULT_STATIC_ROOT;
+    staticRoute.get('/tree-shaking-shared/*', async (c)=>serveLocalFile(c, rootDir));
+    return staticRoute;
+}
+const DEFAULT_PRUNE_INTERVAL_MS = 3600000;
+function ossEnv_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);
+    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 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',
+        port: envNum(params.env, 'PORT', 3000),
+        hostname: ossEnv_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
+    };
+}
+const cors_namespaceObject = require("hono/cors");
+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 external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const zod_validator_namespaceObject = require("@hono/zod-validator");
+const external_nanoid_namespaceObject = require("nanoid");
+const external_p_limit_namespaceObject = require("p-limit");
+var external_p_limit_default = /*#__PURE__*/ __webpack_require__.n(external_p_limit_namespaceObject);
+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: 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 external_zod_namespaceObject = require("zod");
+const UploadOptionsSchema = external_zod_namespaceObject.z.object({
+    scmName: external_zod_namespaceObject.z.string(),
+    bucketName: external_zod_namespaceObject.z.string(),
+    publicFilePath: external_zod_namespaceObject.z.string(),
+    publicPath: external_zod_namespaceObject.z.string(),
+    cdnRegion: external_zod_namespaceObject.z.string()
+});
+const BasicSchema = external_zod_namespaceObject.z.object({
+    shared: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.tuple([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+    ])).describe('List of plugins: [name, version, usedExports]'),
+    plugins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.tuple([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.string().optional()
+    ])).describe('Specify extra build plugin names, support specify version in second item').optional(),
+    target: external_zod_namespaceObject.z.union([
+        external_zod_namespaceObject.z.string(),
+        external_zod_namespaceObject.z.array(external_zod_namespaceObject.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: external_zod_namespaceObject.z.string(),
+    hostName: external_zod_namespaceObject.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 external_node_crypto_namespaceObject = require("node:crypto");
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const STATS_NAME = 'mf-stats.json';
+const external_node_child_process_namespaceObject = require("node:child_process");
+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 = (0, external_node_child_process_namespaceObject.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 = external_node_path_default().join(external_node_os_default().tmpdir(), `re-shake-share-${key}`);
+    let candidate = base;
+    for(;;)try {
+        await promises_default().mkdir(candidate, {
+            recursive: false
+        });
+        return candidate;
+    } catch  {
+        const rand = Math.floor(1e9 * Math.random());
+        candidate = `${base}-${rand}`;
+    }
+};
+const prepareProject = async (config, excludeShared)=>{
+    const key = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify(config)).digest('hex');
+    const dir = await createUniqueTempDirByKey(key);
+    const templateDir = external_node_path_default().join(__dirname, '.', 'template', 're-shake-share');
+    await promises_default().cp(templateDir, dir, {
+        recursive: true
+    });
+    const pkgPath = external_node_path_default().join(dir, 'package.json');
+    const indexPath = external_node_path_default().join(dir, 'index.ts');
+    const rspackConfigPath = external_node_path_default().join(dir, 'rspack.config.ts');
+    const [pkgContent, indexContent, rspackConfigContent] = await Promise.all([
+        promises_default().readFile(pkgPath, 'utf-8'),
+        promises_default().readFile(indexPath, 'utf-8'),
+        promises_default().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_default().writeFile(pkgPath, newPkgContent),
+        promises_default().writeFile(indexPath, newIndexContent),
+        promises_default().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 = external_node_path_default().join(projectDir, dir);
+        const statsContent = await promises_default().readFile(external_node_path_default().join(distDir, STATS_NAME), 'utf-8');
+        const stats = JSON.parse(statsContent);
+        stats.shared.forEach((s)=>{
+            const { name, version, fallback, fallbackName } = s;
+            if (fallback && fallbackName) {
+                const filepath = external_node_path_default().join(distDir, fallback);
+                sharedFilepaths.push({
+                    name,
+                    version,
+                    filepath,
+                    globalName: fallbackName,
+                    type: t,
+                    modules: s.usedExports,
+                    canTreeShaking: s.canTreeShaking ?? 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_default().rm(tmpDir, {
+        recursive: true,
+        force: true
+    });
+}
+const external_json_stable_stringify_namespaceObject = require("json-stable-stringify");
+var external_json_stable_stringify_default = /*#__PURE__*/ __webpack_require__.n(external_json_stable_stringify_namespaceObject);
+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 = external_json_stable_stringify_default()(relevant);
+    if (!json) throw new Error('Can not stringify build config!');
+    return (0, external_node_crypto_namespaceObject.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_default().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_default().mkdir(external_node_path_default().dirname(destPath), {
+        recursive: true
+    });
+    await promises_default().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 = external_node_path_default().basename(new URL(item.cdnUrl, 'http://dummy.com').pathname);
+            const localPath = external_node_path_default().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_default().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 = external_node_path_default().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_default().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_default().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 = external_p_limit_default()(Math.max(1, external_node_os_default().cpus().length));
+const buildRoute = new external_hono_namespaceObject.Hono();
+buildRoute.post('/', (0, zod_validator_namespaceObject.zValidator)('json', ConfigSchema), async (c)=>{
+    const logger = c.get('logger');
+    const startTime = Date.now();
+    const jobId = (0, external_nanoid_namespaceObject.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 = (0, external_nanoid_namespaceObject.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', (0, zod_validator_namespaceObject.zValidator)('json', CheckTreeShakingSchema), async (c)=>handleCheckTreeshake(c, c.req.valid('json')));
+const maintenanceRoute = new external_hono_namespaceObject.Hono();
+maintenanceRoute.post('/', async (c)=>{
+    const logger = c.get('logger');
+    const jobId = (0, external_nanoid_namespaceObject.nanoid)();
+    const startTime = Date.now();
+    logger.info(jobId);
+    await maybePrune();
+    return c.json({
+        jobId,
+        status: 'success',
+        duration: Date.now() - startTime
+    });
+});
+const routes = new external_hono_namespaceObject.Hono();
+routes.route('/build', buildRoute);
+routes.route('/clean-cache', maintenanceRoute);
+const timeout_namespaceObject = require("hono/timeout");
+function createApp(deps, opts) {
+    if (opts?.logger) setLogger(opts.logger);
+    setRuntimeEnv(opts?.runtimeEnv ?? process.env);
+    const app = new external_hono_namespaceObject.Hono();
+    const corsOrigin = opts?.corsOrigin ?? '*';
+    const staticRootDir = opts?.staticRootDir ?? DEFAULT_STATIC_ROOT;
+    app.use('*', (0, cors_namespaceObject.cors)({
+        origin: corsOrigin,
+        allowMethods: [
+            'GET',
+            'POST',
+            'OPTIONS'
+        ],
+        allowHeaders: [
+            'Content-Type',
+            'Authorization'
+        ]
+    }));
+    app.use('*', loggerMiddleware);
+    app.use('*', createDiMiddleware(deps));
+    app.use('*', (0, timeout_namespaceObject.timeout)(60000));
+    if (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 (opts?.frontendAdapters?.length) for (const adapter of opts.frontendAdapters)adapter.register(app);
+    startPeriodicPrune(opts?.pruneIntervalMs);
+    return app;
+}
+const defaultBasePath = '/tree-shaking';
+const embeddedAdapter_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';
+    if (filePath.endsWith('.json')) return 'application/json';
+    if (filePath.endsWith('.svg')) return 'image/svg+xml';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.webp')) return 'image/webp';
+    if (filePath.endsWith('.ico')) return 'image/x-icon';
+    return 'application/octet-stream';
+};
+const safeResolve = (rootDir, requestPath)=>{
+    const rootResolved = external_node_path_default().resolve(rootDir);
+    const rel = requestPath.replace(/^\/+/, '');
+    const filePath = external_node_path_default().resolve(rootResolved, rel);
+    if (filePath !== rootResolved && !filePath.startsWith(`${rootResolved}${external_node_path_default().sep}`)) return null;
+    return filePath;
+};
+function createEmbeddedFrontendAdapter(opts) {
+    const basePath = opts.basePath ?? defaultBasePath;
+    const normalizedBase = '/' === basePath ? '' : basePath.replace(/\/$/, '');
+    const distDir = opts.distDir;
+    const indexFile = opts.indexFile ?? 'index.html';
+    const spaFallback = opts.spaFallback ?? true;
+    const handler = async (c)=>{
+        let requestPath = c.req.path;
+        try {
+            requestPath = decodeURIComponent(requestPath);
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+        let relPath = requestPath;
+        if (normalizedBase && requestPath.startsWith(normalizedBase)) relPath = requestPath.slice(normalizedBase.length);
+        if (!relPath || '/' === relPath) relPath = `/${indexFile}`;
+        const filePath = safeResolve(distDir, relPath);
+        if (filePath) try {
+            const stat = await external_node_fs_default().promises.stat(filePath);
+            if (stat.isFile()) {
+                const buf = await external_node_fs_default().promises.readFile(filePath);
+                return new Response(new Uint8Array(buf), {
+                    status: 200,
+                    headers: {
+                        'Content-Type': embeddedAdapter_contentTypeByExt(filePath)
+                    }
+                });
+            }
+        } catch  {}
+        if (!spaFallback) return c.text('Not Found', 404);
+        const fallbackPath = safeResolve(distDir, `/${indexFile}`);
+        if (!fallbackPath) return c.text('Not Found', 404);
+        try {
+            const buf = await external_node_fs_default().promises.readFile(fallbackPath);
+            return new Response(new Uint8Array(buf), {
+                status: 200,
+                headers: {
+                    'Content-Type': embeddedAdapter_contentTypeByExt(fallbackPath)
+                }
+            });
+        } catch  {
+            return c.text('Not Found', 404);
+        }
+    };
+    return {
+        id: 'treeshake-embedded-frontend',
+        register (app) {
+            const base = normalizedBase || '/';
+            app.get(base, handler);
+            app.get(`${base}/*`, handler);
+        }
+    };
+}
+const node_server_namespaceObject = require("@hono/node-server");
+function createServer(opts) {
+    const port = opts.port ?? 3000;
+    const hostname = opts.hostname ?? '0.0.0.0';
+    return (0, node_server_namespaceObject.serve)({
+        fetch: opts.app.fetch,
+        port,
+        hostname,
+        overrideGlobalObjects: false
+    });
+}
+const hasIndexHtml = (dir)=>Boolean(dir && external_node_fs_default().existsSync(external_node_path_default().join(dir, 'index.html')));
+const resolveFrontendDistDir = ()=>{
+    const envDir = process.env.TREESHAKE_FRONTEND_DIST;
+    if (envDir) {
+        if (hasIndexHtml(envDir)) return envDir;
+        throw new Error(`TREESHAKE_FRONTEND_DIST is set but index.html is missing: ${envDir}`);
+    }
+    const candidates = [
+        external_node_path_default().resolve(__dirname, 'frontend'),
+        external_node_path_default().resolve(__dirname, '..', 'frontend')
+    ];
+    for (const candidate of candidates)if (hasIndexHtml(candidate)) return candidate;
+    const workspaceCandidates = [
+        external_node_path_default().resolve(process.cwd(), 'packages', 'treeshake-frontend', 'dist'),
+        external_node_path_default().resolve(process.cwd(), 'treeshake-frontend', 'dist')
+    ];
+    for (const candidate of workspaceCandidates)if (hasIndexHtml(candidate)) return candidate;
+};
+async function main() {
+    const registry = createOssAdapterRegistry();
+    const resolved = resolveOssEnv({
+        env: {
+            ...process.env,
+            ADAPTER_ID: 'local'
+        },
+        registry,
+        defaultAdapterId: 'local'
+    });
+    const logger = createLogger({
+        level: resolved.logLevel
+    });
+    const deps = await createAdapterDeps({
+        registry,
+        adapterId: resolved.adapterId,
+        adapterConfig: resolved.adapterConfig,
+        logger
+    });
+    const frontendAdapters = [];
+    const distDir = resolveFrontendDistDir();
+    if (!distDir) throw new Error('Treeshake UI dist not found. Rebuild the CLI bundle or set TREESHAKE_FRONTEND_DIST.');
+    frontendAdapters.push(createEmbeddedFrontendAdapter({
+        basePath: process.env.TREESHAKE_FRONTEND_BASE_PATH ?? '/tree-shaking',
+        distDir,
+        spaFallback: '0' !== process.env.TREESHAKE_FRONTEND_SPA_FALLBACK && 'false' !== process.env.TREESHAKE_FRONTEND_SPA_FALLBACK
+    }));
+    const app = createApp(deps, {
+        corsOrigin: resolved.corsOrigin,
+        staticRootDir: resolved.staticRootDir,
+        pruneIntervalMs: resolved.pruneIntervalMs,
+        logger,
+        runtimeEnv: resolved.runtimeEnv,
+        frontendAdapters
+    });
+    createServer({
+        app,
+        port: resolved.port,
+        hostname: resolved.hostname
+    });
+    console.log('Build service listening.');
+    if (frontendAdapters.length) console.log('Treeshake UI available.');
+}
+main().catch((err)=>{
+    console.error(err);
+    process.exit(1);
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});