@esmx/core 3.0.0-rc.70 → 3.0.0-rc.71

package/README.md

@@ -20,7 +20,7 @@
     </a>
   </div>
   
-  <p>A high-performance microfrontend framework supporting Vue, React, Preact, Solid, and Svelte with SSR and Module Federation capabilities</p>
+  <p>A high-performance microfrontend framework supporting Vue, React, Preact, Solid, and Svelte with SSR and Module Linking capabilities</p>
   
   <p>
     English | <a href="https://github.com/esmnext/esmx/blob/master/packages/core/README.zh-CN.md">中文</a>
@@ -38,16 +38,19 @@
 ## 📦 Installation
 
 ```bash
+# npm
 npm install @esmx/core
-```
 
-## 🚀 Quick Start
+# pnpm
+pnpm add @esmx/core
 
-```bash
-npm install @esmx/core
+# yarn
+yarn add @esmx/core
 ```
 
-For detailed usage examples and configuration options, please visit the [official documentation](https://esmx.dev).
+## 🚀 Quick Start
+
+See Quick Start guide: https://esmx.dev/guide/start/getting-started.html
 
 ## 📚 Documentation
 
@@ -55,4 +58,4 @@ Visit the [official documentation](https://esmx.dev) for detailed usage guides a
 
 ## 📄 License
 
-MIT © [Esmx Team](https://github.com/esmnext/esmx)
+MIT © [Esmx Team](https://github.com/esmnext/esmx)

package/README.zh-CN.md

@@ -20,7 +20,7 @@
     </a>
   </div>
   
-  <p>支持 Vue、React、Preact、Solid、Svelte 的高性能微前端框架，具备 SSR 和模块联邦能力</p>
+  <p>支持 Vue、React、Preact、Solid、Svelte 的高性能微前端框架，具备 SSR 和模块链接能力</p>
   
   <p>
     <a href="https://github.com/esmnext/esmx/blob/master/packages/core/README.md">English</a> | 中文
@@ -38,16 +38,19 @@
 ## 📦 安装
 
 ```bash
+# npm
 npm install @esmx/core
-```
 
-## 🚀 快速开始
+# pnpm
+pnpm add @esmx/core
 
-```bash
-npm install @esmx/core
+# yarn
+yarn add @esmx/core
 ```
 
-详细的使用示例和配置选项，请访问[官方文档](https://esmx.dev)。
+## 🚀 快速开始
+
+查看快速开始指南：https://esmx.dev/zh-CN/guide/start/getting-started.html
 
 ## 📚 文档
 
@@ -55,4 +58,4 @@ npm install @esmx/core
 
 ## 📄 许可证
 
-MIT © [Esmx Team](https://github.com/esmnext/esmx)
+MIT © [Esmx Team](https://github.com/esmnext/esmx)

package/dist/cli/cli.mjs

@@ -10,12 +10,17 @@ async function getSrcOptions() {
 }
 async function getDistOptions() {
   try {
-    return import(resolveImportPath(process.cwd(), "./dist/index.mjs")).then((m) => m.default);
+    const m = await import(resolveImportPath(process.cwd(), "./dist/node/src/entry.node.mjs"));
+    return m.default;
   } catch (e) {
-    throw new Error(
-      `Failed to load configuration from dist/index.mjs. Please make sure you have run 'esmx build' first.
-${e}`
+    console.error(
+      styleText(
+        "red",
+        "Failed to load dist entry: dist/node/src/entry.node.mjs"
+      )
     );
+    console.error(styleText("yellow", "Run `esmx build` and try again."));
+    process.exit(17);
   }
 }
 export async function cli(command) {

package/dist/core.mjs

@@ -14,7 +14,7 @@ import {
   parsePackConfig
 } from "./pack-config.mjs";
 import { createCache } from "./utils/cache.mjs";
-import { createImportMap } from "./utils/import-map.mjs";
+import { createClientImportMap, createImportMap } from "./utils/import-map.mjs";
 import { resolvePath } from "./utils/resolve-path.mjs";
 import { getImportPreloadInfo as getStaticImportPaths } from "./utils/static-import-lexer.mjs";
 export var COMMAND = /* @__PURE__ */ ((COMMAND2) => {
@@ -677,7 +677,7 @@ export class Esmx {
       let json = {};
       switch (env) {
         case "client": {
-          json = createImportMap({
+          json = createClientImportMap({
             manifests,
             getScope(name, scope) {
               return `/${name}${scope}`;

package/dist/utils/import-map.d.ts

@@ -47,4 +47,6 @@ export declare function createScopesMap(imports: SpecifierMap, manifests: readon
  * @see https://issues.chromium.org/issues/453147451
  */
 export declare function fixImportMapNestedScopes(importMap: Required<ImportMap>): Required<ImportMap>;
+export declare function compressImportMap(importMap: Required<ImportMap>): ImportMap;
 export declare function createImportMap({ manifests, getFile, getScope }: GetImportMapOptions): Required<ImportMap>;
+export declare function createClientImportMap(options: GetImportMapOptions): ImportMap;

package/dist/utils/import-map.mjs

@@ -48,6 +48,51 @@ export function fixImportMapNestedScopes(importMap) {
   });
   return importMap;
 }
+export function compressImportMap(importMap) {
+  const compressed = {
+    imports: { ...importMap.imports },
+    scopes: {}
+  };
+  const counts = {};
+  Object.values(importMap.scopes).forEach((scopeMappings) => {
+    Object.entries(scopeMappings).forEach(([specifier, target]) => {
+      if (Object.hasOwn(importMap.imports, specifier)) return;
+      counts[specifier] ??= {};
+      counts[specifier][target] = (counts[specifier][target] ?? 0) + 1;
+    });
+  });
+  Object.entries(counts).forEach(([specifier, targetCounts]) => {
+    const entries = Object.entries(targetCounts);
+    let best = null;
+    let secondBestCount = 0;
+    for (const [t, c] of entries) {
+      if (!best || c > best[1]) {
+        secondBestCount = best ? Math.max(secondBestCount, best[1]) : secondBestCount;
+        best = [t, c];
+      } else {
+        secondBestCount = Math.max(secondBestCount, c);
+      }
+    }
+    if (best && best[1] > secondBestCount) {
+      compressed.imports[specifier] = best[0];
+    }
+  });
+  Object.entries(importMap.scopes).forEach(([scopePath, scopeMappings]) => {
+    const filtered = {};
+    Object.entries(scopeMappings).forEach(([specifier, target]) => {
+      const globalTarget = compressed.imports[specifier];
+      if (globalTarget === target) {
+        return;
+      }
+      filtered[specifier] = target;
+    });
+    if (Object.keys(filtered).length > 0) {
+      compressed.scopes[scopePath] = filtered;
+    }
+  });
+  const hasScopes = Object.keys(compressed.scopes).length > 0;
+  return hasScopes ? compressed : { imports: compressed.imports };
+}
 export function createImportMap({
   manifests,
   getFile,
@@ -60,3 +105,8 @@ export function createImportMap({
     scopes
   };
 }
+export function createClientImportMap(options) {
+  const base = createImportMap(options);
+  const fixed = fixImportMapNestedScopes(base);
+  return compressImportMap(fixed);
+}

package/dist/utils/import-map.test.mjs

@@ -1,5 +1,6 @@
 import { assert, describe, test } from "vitest";
 import {
+  compressImportMap,
   createImportMap,
   createImportsMap,
   createScopesMap,
@@ -391,18 +392,16 @@ describe("fixImportMapNestedScopes", () => {
       }
     };
     const result = fixImportMapNestedScopes(importMap);
-    assert.deepEqual(result.imports, importMap.imports);
-    assert.deepEqual(
-      result.scopes["/shared-modules/vue2/"],
-      importMap.scopes["/shared-modules/vue2/"]
-    );
-    assert.deepEqual(
-      result.scopes["/shared-modules/vue2/component.u5v4w3x2.final.mjs"],
-      {
-        vue: "/shared-modules/vue2.q9r8s7t6.final.mjs",
-        "vue-router": "/shared-modules/vue2/router.y1z0a9b8.final.mjs"
+    const expected = {
+      imports: importMap.imports,
+      scopes: {
+        "/shared-modules/vue2/component.u5v4w3x2.final.mjs": {
+          vue: "/shared-modules/vue2.q9r8s7t6.final.mjs",
+          "vue-router": "/shared-modules/vue2/router.y1z0a9b8.final.mjs"
+        }
       }
-    );
+    };
+    assert.deepEqual(result, expected);
   });
   test("should handle complex priority scenarios with multiple nested levels", () => {
     const importMap = {
@@ -609,8 +608,11 @@ describe("fixImportMapNestedScopes", () => {
       }
     };
     const result = fixImportMapNestedScopes(importMap);
-    assert.deepEqual(result.imports, importMap.imports);
-    assert.isUndefined(result.scopes["/shared/modules/vue2/"]);
+    const expected = {
+      imports: importMap.imports,
+      scopes: {}
+    };
+    assert.deepEqual(result, expected);
     assert.doesNotThrow(() => {
       fixImportMapNestedScopes(importMap);
     });
@@ -1438,3 +1440,147 @@ describe("createImportMap", () => {
     });
   });
 });
+describe("compressImportMap", () => {
+  test("does not promote when no global exists; keeps scopes intact", () => {
+    const importMap = {
+      imports: {},
+      scopes: {
+        "/a/": {
+          vue: "/a/vue.final.mjs"
+        },
+        "/b/": {
+          vue: "/a/vue.final.mjs"
+        }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/a/vue.final.mjs" }
+    });
+  });
+  test("does not promote when scoped mappings conflict across scopes", () => {
+    const importMap = {
+      imports: {},
+      scopes: {
+        "/a/": { vue: "/a/vue.final.mjs" },
+        "/b/": { vue: "/b/vue.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, importMap);
+  });
+  test("removes scoped entries that equal global mapping", () => {
+    const importMap = {
+      imports: { vue: "/shared/vue.final.mjs" },
+      scopes: {
+        "/a/": {
+          vue: "/shared/vue.final.mjs",
+          lodash: "/a/lodash.final.mjs"
+        }
+      }
+    };
+    const result = compressImportMap(importMap);
+    const expected = {
+      imports: {
+        vue: "/shared/vue.final.mjs",
+        lodash: "/a/lodash.final.mjs"
+      }
+    };
+    assert.deepEqual(result, expected);
+  });
+  test("promotes to global when global matches single unique target across scopes", () => {
+    const importMap = {
+      imports: { vue: "/shared/vue.final.mjs" },
+      scopes: {
+        "/a/": { vue: "/shared/vue.final.mjs" },
+        "/b/": { vue: "/shared/vue.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/shared/vue.final.mjs" }
+    });
+  });
+  test("promotes to global when no global exists and targets are consistent across scopes (promote mode)", () => {
+    const importMap = {
+      imports: {},
+      scopes: {
+        "/a/": { vue: "/x/vue.final.mjs" },
+        "/b/": { vue: "/x/vue.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/x/vue.final.mjs" }
+    });
+  });
+  test("promotes dominant target and keeps exceptions in scopes (promote mode)", () => {
+    const importMap = {
+      imports: {},
+      scopes: {
+        "/a/": { vue: "/x/vue.final.mjs" },
+        "/b/": { vue: "/x/vue.final.mjs" },
+        "/c/": { vue: "/y/vue2.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/x/vue.final.mjs" },
+      scopes: {
+        "/c/": { vue: "/y/vue2.final.mjs" }
+      }
+    });
+  });
+  test("does not promote when no global exists; keeps scopes intact", () => {
+    const importMap = {
+      imports: {},
+      scopes: {
+        "/a/": { vue: "/shared/vue.final.mjs" },
+        "/b/": { vue: "/shared/vue.final.mjs" },
+        "/c/": { vue: "/c/vue2.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/shared/vue.final.mjs" },
+      scopes: { "/c/": { vue: "/c/vue2.final.mjs" } }
+    });
+  });
+  test("aggressive default does not override different existing global", () => {
+    const importMap = {
+      imports: { vue: "/global/vue.final.mjs" },
+      scopes: {
+        "/a/": { vue: "/shared/vue.final.mjs" },
+        "/b/": { vue: "/shared/vue.final.mjs" }
+      }
+    };
+    const result = compressImportMap(importMap);
+    assert.deepEqual(result, {
+      imports: { vue: "/global/vue.final.mjs" },
+      scopes: {
+        "/a/": { vue: "/shared/vue.final.mjs" },
+        "/b/": { vue: "/shared/vue.final.mjs" }
+      }
+    });
+  });
+  test("returns new object and keeps input unchanged", () => {
+    const original = {
+      imports: {},
+      scopes: {
+        "/a/": { vue: "/x/vue.final.mjs" },
+        "/b/": { vue: "/x/vue.final.mjs" },
+        "/c/": { vue: "/y/vue2.final.mjs" }
+      }
+    };
+    const importMap = JSON.parse(JSON.stringify(original));
+    const result = compressImportMap(importMap);
+    assert.notStrictEqual(result, importMap);
+    assert.notStrictEqual(result.imports, importMap.imports);
+    assert.notStrictEqual(result.scopes, importMap.scopes);
+    assert.deepEqual(importMap, original);
+    assert.deepEqual(result, {
+      imports: { vue: "/x/vue.final.mjs" },
+      scopes: { "/c/": { vue: "/y/vue2.final.mjs" } }
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@esmx/core",
-    "description": "A high-performance microfrontend framework supporting Vue, React, Preact, Solid, and Svelte with SSR and Module Federation capabilities.",
+    "description": "A high-performance microfrontend framework supporting Vue, React, Preact, Solid, and Svelte with SSR and Module Linking capabilities.",
     "contributors": [
         {
             "name": "lzxb",
@@ -39,7 +39,7 @@
         "Microfrontend",
         "SSR",
         "Rspack",
-        "Module Federation",
+        "Module Linking",
         "High Performance",
         "TypeScript"
     ],
@@ -59,7 +59,7 @@
         "build": "unbuild"
     },
     "dependencies": {
-        "@esmx/import": "3.0.0-rc.70",
+        "@esmx/import": "3.0.0-rc.71",
         "@types/serialize-javascript": "^5.0.4",
         "es-module-lexer": "^1.7.0",
         "find": "^0.3.0",
@@ -69,15 +69,15 @@
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
         "@types/find": "^0.2.4",
-        "@types/node": "^24.0.0",
-        "@types/send": "^0.17.4",
+        "@types/node": "^24.10.0",
+        "@types/send": "^1.2.1",
         "@types/write": "^2.0.4",
         "@vitest/coverage-v8": "3.2.4",
-        "typescript": "5.9.2",
-        "unbuild": "3.6.0",
+        "typescript": "5.9.3",
+        "unbuild": "3.6.1",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.70",
+    "version": "3.0.0-rc.71",
     "type": "module",
     "private": false,
     "exports": {
@@ -100,5 +100,5 @@
         "template",
         "public"
     ],
-    "gitHead": "9aa452ae73e450d285e4ddbd35a4ac8b53427d95"
+    "gitHead": "1616c7a1f820387d4d14bac0babd42356f6f7f33"
 }

package/src/cli/cli.ts

@@ -13,13 +13,19 @@ async function getSrcOptions(): Promise<EsmxOptions> {
 
 async function getDistOptions(): Promise<EsmxOptions> {
     try {
-        return import(
-            resolveImportPath(process.cwd(), './dist/index.mjs')
-        ).then((m) => m.default);
+        const m = await import(
+            resolveImportPath(process.cwd(), './dist/node/src/entry.node.mjs')
+        );
+        return m.default;
     } catch (e) {
-        throw new Error(
-            `Failed to load configuration from dist/index.mjs. Please make sure you have run 'esmx build' first.\n${e}`
+        console.error(
+            styleText(
+                'red',
+                'Failed to load dist entry: dist/node/src/entry.node.mjs'
+            )
         );
+        console.error(styleText('yellow', 'Run `esmx build` and try again.'));
+        process.exit(17);
     }
 }
 

package/src/core.ts

@@ -22,7 +22,7 @@ import {
 import type { ImportmapMode } from './render-context';
 import type { RenderContext, RenderContextOptions } from './render-context';
 import { type CacheHandle, createCache } from './utils/cache';
-import { createImportMap } from './utils/import-map';
+import { createClientImportMap, createImportMap } from './utils/import-map';
 import type { Middleware } from './utils/middleware';
 import { type ProjectPath, resolvePath } from './utils/resolve-path';
 import { getImportPreloadInfo as getStaticImportPaths } from './utils/static-import-lexer';
@@ -854,7 +854,7 @@ export class Esmx {
             let json: ImportMap = {};
             switch (env) {
                 case 'client': {
-                    json = createImportMap({
+                    json = createClientImportMap({
                         manifests,
                         getScope(name, scope) {
                             return `/${name}${scope}`;

package/src/utils/import-map.test.ts

@@ -1,5 +1,6 @@
 import { assert, describe, test } from 'vitest';
 import {
+    compressImportMap,
     createImportMap,
     createImportsMap,
     createScopesMap,
@@ -461,20 +462,17 @@ describe('fixImportMapNestedScopes', () => {
         };
 
         const result = fixImportMapNestedScopes(importMap);
-
-        assert.deepEqual(result.imports, importMap.imports);
-        assert.deepEqual(
-            result.scopes['/shared-modules/vue2/'],
-            importMap.scopes['/shared-modules/vue2/']
-        );
-
-        assert.deepEqual(
-            result.scopes['/shared-modules/vue2/component.u5v4w3x2.final.mjs'],
-            {
-                vue: '/shared-modules/vue2.q9r8s7t6.final.mjs',
-                'vue-router': '/shared-modules/vue2/router.y1z0a9b8.final.mjs'
+        const expected = {
+            imports: importMap.imports,
+            scopes: {
+                '/shared-modules/vue2/component.u5v4w3x2.final.mjs': {
+                    vue: '/shared-modules/vue2.q9r8s7t6.final.mjs',
+                    'vue-router':
+                        '/shared-modules/vue2/router.y1z0a9b8.final.mjs'
+                }
             }
-        );
+        };
+        assert.deepEqual(result, expected);
     });
 
     test('should handle complex priority scenarios with multiple nested levels', () => {
@@ -747,8 +745,11 @@ describe('fixImportMapNestedScopes', () => {
         };
 
         const result = fixImportMapNestedScopes(importMap);
-        assert.deepEqual(result.imports, importMap.imports);
-        assert.isUndefined(result.scopes['/shared/modules/vue2/']);
+        const expected = {
+            imports: importMap.imports,
+            scopes: {}
+        };
+        assert.deepEqual(result, expected);
         assert.doesNotThrow(() => {
             fixImportMapNestedScopes(importMap);
         });
@@ -1620,3 +1621,160 @@ describe('createImportMap', () => {
         });
     });
 });
+
+describe('compressImportMap', () => {
+    test('does not promote when no global exists; keeps scopes intact', () => {
+        const importMap = {
+            imports: {},
+            scopes: {
+                '/a/': {
+                    vue: '/a/vue.final.mjs'
+                },
+                '/b/': {
+                    vue: '/a/vue.final.mjs'
+                }
+            }
+        };
+
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/a/vue.final.mjs' }
+        });
+    });
+
+    test('does not promote when scoped mappings conflict across scopes', () => {
+        const importMap = {
+            imports: {},
+            scopes: {
+                '/a/': { vue: '/a/vue.final.mjs' },
+                '/b/': { vue: '/b/vue.final.mjs' }
+            }
+        };
+
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, importMap);
+    });
+
+    test('removes scoped entries that equal global mapping', () => {
+        const importMap = {
+            imports: { vue: '/shared/vue.final.mjs' },
+            scopes: {
+                '/a/': {
+                    vue: '/shared/vue.final.mjs',
+                    lodash: '/a/lodash.final.mjs'
+                }
+            }
+        };
+
+        const result = compressImportMap(importMap);
+        const expected = {
+            imports: {
+                vue: '/shared/vue.final.mjs',
+                lodash: '/a/lodash.final.mjs'
+            }
+        };
+        assert.deepEqual(result, expected);
+    });
+
+    test('promotes to global when global matches single unique target across scopes', () => {
+        const importMap = {
+            imports: { vue: '/shared/vue.final.mjs' },
+            scopes: {
+                '/a/': { vue: '/shared/vue.final.mjs' },
+                '/b/': { vue: '/shared/vue.final.mjs' }
+            }
+        };
+
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/shared/vue.final.mjs' }
+        });
+    });
+
+    test('promotes to global when no global exists and targets are consistent across scopes (promote mode)', () => {
+        const importMap = {
+            imports: {},
+            scopes: {
+                '/a/': { vue: '/x/vue.final.mjs' },
+                '/b/': { vue: '/x/vue.final.mjs' }
+            }
+        };
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/x/vue.final.mjs' }
+        });
+    });
+
+    test('promotes dominant target and keeps exceptions in scopes (promote mode)', () => {
+        const importMap = {
+            imports: {},
+            scopes: {
+                '/a/': { vue: '/x/vue.final.mjs' },
+                '/b/': { vue: '/x/vue.final.mjs' },
+                '/c/': { vue: '/y/vue2.final.mjs' }
+            }
+        };
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/x/vue.final.mjs' },
+            scopes: {
+                '/c/': { vue: '/y/vue2.final.mjs' }
+            }
+        });
+    });
+
+    test('does not promote when no global exists; keeps scopes intact', () => {
+        const importMap = {
+            imports: {},
+            scopes: {
+                '/a/': { vue: '/shared/vue.final.mjs' },
+                '/b/': { vue: '/shared/vue.final.mjs' },
+                '/c/': { vue: '/c/vue2.final.mjs' }
+            }
+        };
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/shared/vue.final.mjs' },
+            scopes: { '/c/': { vue: '/c/vue2.final.mjs' } }
+        });
+    });
+
+    test('aggressive default does not override different existing global', () => {
+        const importMap = {
+            imports: { vue: '/global/vue.final.mjs' },
+            scopes: {
+                '/a/': { vue: '/shared/vue.final.mjs' },
+                '/b/': { vue: '/shared/vue.final.mjs' }
+            }
+        };
+        const result = compressImportMap(importMap);
+        assert.deepEqual(result, {
+            imports: { vue: '/global/vue.final.mjs' },
+            scopes: {
+                '/a/': { vue: '/shared/vue.final.mjs' },
+                '/b/': { vue: '/shared/vue.final.mjs' }
+            }
+        });
+    });
+
+    test('returns new object and keeps input unchanged', () => {
+        const original = {
+            imports: {},
+            scopes: {
+                '/a/': { vue: '/x/vue.final.mjs' },
+                '/b/': { vue: '/x/vue.final.mjs' },
+                '/c/': { vue: '/y/vue2.final.mjs' }
+            }
+        };
+        const importMap = JSON.parse(JSON.stringify(original));
+        const result = compressImportMap(importMap);
+        assert.notStrictEqual(result, importMap);
+        assert.notStrictEqual(result.imports, importMap.imports);
+        assert.notStrictEqual(result.scopes, importMap.scopes);
+        assert.deepEqual(importMap, original);
+        assert.deepEqual(result, {
+            imports: { vue: '/x/vue.final.mjs' },
+            scopes: { '/c/': { vue: '/y/vue2.final.mjs' } }
+        });
+    });
+});

package/src/utils/import-map.ts

@@ -126,6 +126,61 @@ export function fixImportMapNestedScopes(
     return importMap;
 }
 
+export function compressImportMap(importMap: Required<ImportMap>): ImportMap {
+    const compressed: Required<ImportMap> = {
+        imports: { ...importMap.imports },
+        scopes: {}
+    };
+
+    const counts: Record<string, Record<string, number>> = {};
+    Object.values(importMap.scopes).forEach((scopeMappings) => {
+        Object.entries(scopeMappings).forEach(([specifier, target]) => {
+            if (Object.hasOwn(importMap.imports, specifier)) return;
+            counts[specifier] ??= {};
+            counts[specifier][target] = (counts[specifier][target] ?? 0) + 1;
+        });
+    });
+
+    Object.entries(counts).forEach(([specifier, targetCounts]) => {
+        const entries = Object.entries(targetCounts);
+
+        let best: [string, number] | null = null;
+        let secondBestCount = 0;
+        for (const [t, c] of entries) {
+            if (!best || c > best[1]) {
+                secondBestCount = best
+                    ? Math.max(secondBestCount, best[1])
+                    : secondBestCount;
+                best = [t, c];
+            } else {
+                secondBestCount = Math.max(secondBestCount, c);
+            }
+        }
+        if (best && best[1] > secondBestCount) {
+            compressed.imports[specifier] = best[0];
+        }
+    });
+
+    Object.entries(importMap.scopes).forEach(([scopePath, scopeMappings]) => {
+        const filtered: SpecifierMap = {};
+
+        Object.entries(scopeMappings).forEach(([specifier, target]) => {
+            const globalTarget = compressed.imports[specifier];
+            if (globalTarget === target) {
+                return;
+            }
+            filtered[specifier] = target;
+        });
+
+        if (Object.keys(filtered).length > 0) {
+            compressed.scopes[scopePath] = filtered;
+        }
+    });
+
+    const hasScopes = Object.keys(compressed.scopes).length > 0;
+    return hasScopes ? compressed : { imports: compressed.imports };
+}
+
 export function createImportMap({
     manifests,
     getFile,
@@ -139,3 +194,9 @@ export function createImportMap({
         scopes
     };
 }
+
+export function createClientImportMap(options: GetImportMapOptions): ImportMap {
+    const base = createImportMap(options);
+    const fixed = fixImportMapNestedScopes(base);
+    return compressImportMap(fixed);
+}