@module-federation/treeshake-server 0.0.1

package/dist/services/buildService.d.ts

@@ -0,0 +1,8 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { SharedFilePath } from './uploadService';
+export declare const createUniqueTempDirByKey: (key: string) => string;
+export declare const runBuild: (normalizedConfig: NormalizedConfig, excludeShared: Array<[string, string]>, type: BuildType) => Promise<{
+    sharedFilePaths: SharedFilePath[];
+    dir: string;
+}>;
+export declare function cleanUp(tmpDir?: string): void;

package/dist/services/cacheService.d.ts

@@ -0,0 +1,15 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { ObjectStore } from '../ports/objectStore';
+import type { UploadResult } from './uploadService';
+export declare function createCacheHash(config: NormalizedConfig[string], type: BuildType): string;
+export declare function retrieveCDNPath({ config, sharedKey, type, }: {
+    config: NormalizedConfig[string];
+    sharedKey: string;
+    type: BuildType;
+}): string;
+export declare function hitCache(sharedKey: string, config: NormalizedConfig[string], type: BuildType, store: ObjectStore): Promise<string | null>;
+export declare const retrieveCacheItems: (normalizedConfig: NormalizedConfig, type: BuildType, store: ObjectStore) => Promise<{
+    cacheItems: UploadResult[];
+    excludeShared: [sharedName: string, version: string][];
+    restConfig: NormalizedConfig;
+}>;

package/dist/services/pnpmMaintenance.d.ts

@@ -0,0 +1,4 @@
+export declare const markInstallStart: () => void;
+export declare const markInstallEnd: () => void;
+export declare const maybePrune: () => Promise<void>;
+export declare const startPeriodicPrune: (intervalMs?: number) => void;

package/dist/services/uploadService.d.ts

@@ -0,0 +1,36 @@
+import { type BuildType, type NormalizedConfig } from '../domain/build/normalize-config';
+import type { Config } from '../domain/build/schema';
+import type { ObjectStore } from '../ports/objectStore';
+import type { ProjectPublisher } from '../ports/projectPublisher';
+export interface SharedFilePath {
+    name: string;
+    version: string;
+    filepath: string;
+    globalName: string;
+    type: BuildType;
+    canTreeShaking: boolean;
+    modules?: string[];
+}
+export interface UploadResult {
+    name: string;
+    version: string;
+    globalName: string;
+    cdnUrl: string;
+    type: BuildType;
+    modules?: string[];
+    canTreeShaking?: boolean;
+}
+/**
+ * Upload shared files to CDN
+ * @param sharedFilePaths Array of shared file paths to upload
+ * @returns Array of upload results with CDN URLs
+ */
+export declare function uploadToCacheStore(sharedFilePaths: SharedFilePath[], normalizedConfig: NormalizedConfig, store: ObjectStore): Promise<UploadResult[]>;
+export interface UploadOpts {
+    bucketName: string;
+    scmName: string;
+    cdnRegion: string;
+    publicRoot: string;
+}
+export declare function uploadProject(uploadResults: UploadResult[], sharedFilePaths: SharedFilePath[], normalizedConfig: NormalizedConfig, publisher: ProjectPublisher): Promise<UploadResult[]>;
+export declare function upload(sharedFilePaths: SharedFilePath[], uploadResults: UploadResult[], normalizedConfig: NormalizedConfig, uploadOptions: Config['uploadOptions'], store: ObjectStore, publisher?: ProjectPublisher): Promise<UploadResult[]>;

package/dist/template/re-shake-share/Collect.js

@@ -0,0 +1,115 @@
+function getProvidedExports(compilation, mod, statsModules, identifier) {
+    try {
+        const mg = compilation.moduleGraph;
+        if (!mg) return 'unknown';
+        const exportsInfo = mg.getExportsInfo(mod);
+        if (!exportsInfo) return 'unknown';
+        const provided = exportsInfo.getProvidedExports && exportsInfo.getProvidedExports();
+        if (Array.isArray(provided)) return provided.filter((x)=>'string' == typeof x);
+        const statModule = statsModules.find((x)=>x.identifier === identifier);
+        if (!statModule) return 'unknown';
+        if (statModule.providedExports) return statModule.providedExports;
+        return 'unknown';
+    } catch (e) {
+        return 'unknown';
+    }
+}
+function isEsmLikeModule(mod) {
+    const bm = mod && mod.buildMeta;
+    if (!bm) return;
+    if ('string' == typeof bm.exportsType) return 'default' !== bm.exportsType;
+    if ('boolean' == typeof bm.strictHarmonyModule) return bm.strictHarmonyModule;
+    if ('boolean' == typeof bm.harmonyModule) return bm.harmonyModule;
+}
+function isSideEffectFree(mod) {
+    const fm = mod && mod.factoryMeta;
+    if (fm && 'boolean' == typeof fm.sideEffectFree) return fm.sideEffectFree;
+    const bm = mod && mod.buildMeta;
+    if (bm && 'boolean' == typeof bm.sideEffectFree) return bm.sideEffectFree;
+    return false;
+}
+class SharedTreeShakingAuditPlugin {
+    constructor(opts){
+        opts = opts || {};
+        this.options = {
+            libs: opts.libs || [],
+            filename: opts.filename || 'shared-tree-shaking-report.json',
+            entryOnly: void 0 !== opts.entryOnly ? !!opts.entryOnly : true,
+            debug: !!opts.debug
+        };
+    }
+    apply(compiler) {
+        const pluginName = 'SharedTreeShakingAuditPlugin';
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation)=>{
+            const collectSharedEntryPlugin = compiler.options.plugins.find((p)=>'CollectSharedEntryPlugin' === p.name);
+            if (!collectSharedEntryPlugin) return;
+            const stage = compiler.webpack && compiler.webpack.Compilation && compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE || 4000;
+            compilation.hooks.processAssets.tapPromise({
+                name: pluginName,
+                stage
+            }, async ()=>{
+                const reports = [];
+                const statsModules = compilation.getStats().toJson().modules;
+                for (const libName of this.options.libs){
+                    const report = {
+                        lib: libName,
+                        resolvedEntry: void 0,
+                        entryModuleIdentifier: void 0,
+                        canTreeShaking: false,
+                        reasons: [],
+                        evidence: {},
+                        exports: 'unknown'
+                    };
+                    if (!libName) {
+                        report.reasons.push('lib configuration is empty');
+                        reports.push(report);
+                        continue;
+                    }
+                    let entryModule;
+                    for (const mod of compilation.modules){
+                        const res = mod && mod.resource;
+                        if (res && 'string' == typeof res) {
+                            if (mod.rawRequest === libName) {
+                                entryModule = mod;
+                                break;
+                            }
+                        }
+                    }
+                    if (!entryModule) {
+                        report.reasons.push(`can not find module for ${libName}`);
+                        reports.push(report);
+                        continue;
+                    }
+                    report.entryModuleIdentifier = 'function' == typeof entryModule.identifier && entryModule.identifier() || entryModule.debugId || 'unknown';
+                    const providedExports = getProvidedExports(compilation, entryModule, statsModules, report.entryModuleIdentifier);
+                    report.exports = providedExports;
+                    const esmLike = isEsmLikeModule(entryModule);
+                    const sideEffectFree = isSideEffectFree(entryModule);
+                    report.evidence.isEsmLike = esmLike;
+                    report.evidence.sideEffectFree = sideEffectFree;
+                    report.evidence.buildMeta = entryModule.buildMeta;
+                    report.evidence.factoryMeta = entryModule.factoryMeta;
+                    if (false === esmLike) report.reasons.push('entry module is not ESM (likely CJS), static treeshake is hard');
+                    if (false === sideEffectFree) report.reasons.push('sideEffectFree=false, treeshake might be forbidden');
+                    const canTreeshake = false !== esmLike && false !== sideEffectFree;
+                    report.canTreeShaking = canTreeshake;
+                    if (canTreeshake) report.reasons.push('entry module is ESM-like and not marked as side-effect, necessary conditions are met');
+                    if (this.options.debug) compilation.warnings.push(new Error(`[${pluginName}] ${libName} entry=${resolvedEntry} exports=${Array.isArray(providedExports) ? providedExports.length : providedExports}`));
+                    reports.push(report);
+                }
+                const output = {
+                    generatedAt: new Date().toISOString(),
+                    libs: reports
+                };
+                const json = JSON.stringify(output, null, 2);
+                const RawSource = compiler.webpack && compiler.webpack.sources && compiler.webpack.sources.RawSource ? compiler.webpack.sources.RawSource : null;
+                if (RawSource) compilation.emitAsset(this.options.filename, new RawSource(json));
+                else compilation.assets[this.options.filename] = {
+                    source: ()=>json,
+                    size: ()=>json.length
+                };
+            });
+        });
+    }
+}
+export default SharedTreeShakingAuditPlugin;

package/dist/template/re-shake-share/EmitManifest.js

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import path from 'path';
+class EmitManifest {
+    constructor(secondaryTreeShaking){
+        this.secondaryTreeShaking = secondaryTreeShaking;
+    }
+    apply(compiler) {
+        const { secondaryTreeShaking } = this;
+        compiler.hooks.compilation.tap('SecondaryTreeShakingPlugin', (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: 'SecondaryTreeShakingPlugin',
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONAL - 1000
+            }, async ()=>{
+                const treeshakeSharedPlugin = compiler.options.plugins.find((p)=>'TreeShakingSharedPlugin' === p.name);
+                if (!treeshakeSharedPlugin) return;
+                const mfConfig = treeshakeSharedPlugin.mfConfig;
+                const fakeManifest = {
+                    shared: []
+                };
+                const { shared } = fakeManifest;
+                Object.entries(mfConfig.shared).forEach(([sharedName, sharedConfig])=>{
+                    shared.push({
+                        name: sharedName,
+                        version: sharedConfig.version
+                    });
+                });
+                try {
+                    if (!secondaryTreeShaking) {
+                        const treeshakeReport = fs.readFileSync(path.resolve(compilation.options.output.path, 'independent-packages/shared-tree-shaking-report.json'));
+                        const content = JSON.parse(treeshakeReport);
+                        content.libs.forEach((libInfo)=>{
+                            const { lib, canTreeShaking, exports } = libInfo;
+                            const targetShared = shared.find((s)=>s.name === lib);
+                            if (targetShared) {
+                                targetShared.canTreeshake = canTreeShaking;
+                                targetShared.usedExports = exports;
+                            }
+                        });
+                    }
+                } catch (e) {
+                    console.error(e);
+                }
+                compilation.emitAsset('mf-manifest.json', new compiler.webpack.sources.RawSource(JSON.stringify(fakeManifest)));
+                compilation.emitAsset('mf-stats.json', new compiler.webpack.sources.RawSource(JSON.stringify(fakeManifest)));
+            });
+        });
+    }
+}
+export default EmitManifest;

package/dist/template/re-shake-share/index.ts

@@ -0,0 +1 @@
+${SHARED_IMPORT}

package/dist/template/re-shake-share/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "re-shake",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "SECONDARY_TREE_SHAKING=true rspack build",
+    "build:full": "rspack build"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@rspack/cli": "^1.5.8",
+    "@rspack/core": "^1.5.8"
+  },
+  "pnpm": {
+    "overrides": {
+      "@rspack/core": "npm:@rspack-canary/core@1.7.3-canary-58d41d16-20260115035302"
+    },
+    "peerDependencyRules": {
+      "allowAny": [
+        "@rspack/*"
+      ]
+    }
+  }
+}

package/dist/template/re-shake-share/rspack.config.ts

@@ -0,0 +1,33 @@
+import { sharing } from "@rspack/core";
+import path from 'path';
+import CollectPlugin from "./Collect";
+import EmitManifest from './EmitManifest';
+
+
+const SECONDARY_TREE_SHAKING = Boolean(process.env.SECONDARY_TREE_SHAKING)
+
+const mfConfig = ${ MF_CONFIG };
+
+module.exports = {
+	entry: './index.ts',
+	output:{
+		path: path.resolve(process.cwd(), SECONDARY_TREE_SHAKING ? 'dist' : 'full-shared'),
+	},
+	plugins: [
+		new EmitManifest(SECONDARY_TREE_SHAKING),
+		new sharing.TreeShakingSharedPlugin({
+			secondary: SECONDARY_TREE_SHAKING,
+			plugins: ${ PLUGINS },
+			mfConfig,
+		}),
+		!SECONDARY_TREE_SHAKING && new CollectPlugin({
+			libs: Object.entries(mfConfig.shared).map(([k, v]) => {
+				if(!v.treeShaking) {
+					return null;
+				}
+				return k;
+			}).filter(Boolean),
+			filename: "shared-tree-shaking-report.json",
+		}),
+	]
+};

package/dist/utils/runCommand.d.ts

@@ -0,0 +1,20 @@
+export interface CommandOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class CommandExecutionError extends Error {
+    readonly command: string;
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    constructor(command: string, exitCode: number, stdout: string, stderr: string);
+}
+/**
+ * Execute a shell command and collect its output.
+ */
+export declare const runCommand: (command: string, options?: CommandOptions) => Promise<CommandResult>;

package/dist/utils/runtimeEnv.d.ts

@@ -0,0 +1,3 @@
+export type RuntimeEnv = Record<string, string | undefined>;
+export declare const setRuntimeEnv: (env: RuntimeEnv) => void;
+export declare const getRuntimeEnv: () => RuntimeEnv;

package/dist/utils/uploadSdk.d.ts

@@ -0,0 +1,10 @@
+export interface UploadDirectoryOptions {
+    outputDir: string;
+    cdnBaseUrl: string;
+    targetPath: string;
+}
+/**
+ * Placeholder for a real CDN upload SDK.
+ * In real usage you should import the vendor SDK and replace this implementation.
+ */
+export declare function uploadDirectory({ outputDir, cdnBaseUrl, targetPath, }: UploadDirectoryOptions): Promise<string>;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@module-federation/treeshake-server",
+  "version": "0.0.1",
+  "description": "Build service powered by Hono that installs dependencies, builds with Rspack, and uploads artifacts.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "treeshake-server": "dist/server.js"
+  },
+  "scripts": {
+    "build": "pnpm -C ../treeshake-frontend build && rslib build && node scripts/copy-frontend.js",
+    "lint": "biome lint src scripts",
+    "prestart": "npm run build",
+    "dev": "node scripts/dev.js",
+    "start": "node dist/server.js",
+    "test": "rstest"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@hono/node-server": "1.19.5",
+    "@hono/zod-validator": "0.7.4",
+    "dotenv": "16.4.5",
+    "hono": "4.10.2",
+    "json-stable-stringify": "1.3.0",
+    "nanoid": "5.1.6",
+    "pino": "10.1.0",
+    "undici": "5.29.0",
+    "zod": "4.1.12"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.3",
+    "@playwright/test": "^1.57.0",
+    "@rstest/core": "^0.6.5",
+    "@types/node": "^20.11.30",
+    "@vercel/nft": "^1.1.1",
+    "pino-pretty": "^13.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20.19.5",
+    "pnpm": ">=10.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}