@softarc/native-federation 4.3.2 → 4.4.1

package/README.md

@@ -437,11 +437,81 @@ module.exports = withNativeFederation({
 Notes:
 
 - `sharedMappings` is optional. If you omit it, all mapped paths are shared.
+- Entries are matched as patterns, so `'@my-org/*'` selects every mapped path under that scope.
 - You can use wildcard suffixes (for example, `@my-org/ui/*`) to include multiple mapped paths.
-- `skip` still applies and can be used to exclude mapped paths even if they were selected via `sharedMappings`.
+- `skip` still applies and can be used to exclude mapped paths even if they were selected via `sharedMappings`. For wildcard mappings it is matched against each resolved import (`@my-org/ui/button`), not the pattern.
 - Mapped paths are read from the workspace root tsconfig file: `tsconfig.base.json` if present, otherwise `tsconfig.json`.
 - The workspace root is detected by searching upward from the current working directory until a `package.json` is found.
 
+#### Configuring shared mappings
+
+A mapped path can carry the same kind of metadata as a shared npm package. Pair a list of patterns with a config object:
+
+```js
+module.exports = withNativeFederation({
+  sharedMappings: ['@my-org/auth-lib', [['@my-org/ui/*'], { singleton: false }]],
+});
+```
+
+Plain strings and annotated pairs can be mixed freely. When several entries match the same mapped path, **the first one wins**, so put the specific entries before the general ones.
+
+The honoured properties are `singleton`, `strictVersion`, `requiredVersion`, `version`, `shareScope`, `pool` and `includeSecondaries`. Anything omitted keeps its current default: `singleton: true`, `strictVersion` following the `mappingVersion` flag, and the version read from the mapped library's nearest `package.json`. Setting `version` explicitly also drives `requiredVersion` unless you set that too.
+
+`build`, `platform`, `chunks` and `packageInfo` are **not** honoured for mapped paths — every mapping is built into the same bundle, so there is nothing for them to select.
+
+For anything beyond a couple of entries, `mappingsFromWorkspace` is easier to read. It produces exactly the array form above:
+
+```js
+import { withNativeFederation, mappingsFromWorkspace } from '@softarc/native-federation/config';
+
+module.exports = withNativeFederation({
+  sharedMappings: mappingsFromWorkspace({ singleton: true, strictVersion: true })
+    .filter(['@my-org/ui/*', '@my-org/auth-lib'])
+    .patch(['@my-org/ui/*'], { singleton: false })
+    .get(),
+});
+```
+
+- Omit `.filter()` to select every mapped path — the same default as omitting `sharedMappings`.
+- `.patch()` annotates a subset; it never widens the selection, so patching a pattern that `.filter()` excluded is ignored with a warning.
+
+#### Keeping mappings that nothing imports
+
+With the `ignoreUnusedDeps` feature on (the default), mapped paths are pruned to those actually reachable from your entry points. A host that exposes little of its own but is expected to supply libraries to its remotes can opt out per mapping, the same way `shared` packages do:
+
+```js
+module.exports = withNativeFederation({
+  sharedMappings: mappingsFromWorkspace({
+    includeSecondaries: { keepAll: true, resolveGlob: true },
+  }).get(),
+});
+```
+
+- `keepAll` keeps the mapping even when nothing imports it. This is read exactly as it is for a shared package, so a bare `includeSecondaries: true` opts out too.
+- `resolveGlob` is additionally required for **wildcard** mappings. A wildcard is a pattern rather than an entry point, and normally only the reachability scan turns it into concrete files; `resolveGlob` expands it against the filesystem instead. Without it, a wildcard mapping is dropped with a warning.
+
+An expanded wildcard is named by the same rule the reachability scan uses, so `libs/ui/*` matching `libs/ui/button/index.ts` is shared as `@my-org/ui/button`.
+
+Expansion only accepts **entry points**. A glob cannot tell a library's public surface from its internals, so a match whose specifier still contains a dot in its last segment — `@my-org/ui/button/button.component`, `.spec`, `.d` — is skipped rather than shared.
+
+That restriction is not cosmetic: **only barrel imports can be shared as a mapped path.** A mapped path is advertised under its import specifier and marked external, so the specifier has to be one a browser import map can resolve, and a dot in the last segment does not resolve (see [vitejs/vite#21036](https://github.com/vitejs/vite/issues/21036)).
+
+So the rule is simply *would this end up in `remoteEntry.json`?* If it would, a non-barrel specifier fails the build:
+
+```
+Invalid 'shared mappings' config. Only barrel imports can be shared as a sharedMapping:
+'@my-org/ui/button/button.component'.
+```
+
+If it would not, nothing is reported — there is no reason to fail a build over a path that was never going to be published:
+
+- **pruned away** by `ignoreUnusedDeps` — nothing imports it, so it is already gone.
+- **skipped by a wildcard expansion** — `resolveGlob` is a guess about your public surface, so it drops non-barrel matches rather than inventing a build error out of `*.service.ts` files nobody imports.
+
+What is left is the case worth stopping for: something genuinely imports `@my-org/ui/button/button.component`, so it is about to be published and would break at runtime. Import the barrel (`@my-org/ui/button`) and re-export from it. Note that with `ignoreUnusedDeps: false` nothing is pruned, so every mapped path is published and therefore checked.
+
+Note that a host providing libraries its remotes depend on couples the two: the remote can no longer run standalone. Letting each application share the entry points it imports and leaving the orchestrator to deduplicate at runtime is usually the better default.
+
 The `mappingVersion` feature flag controls whether mapped paths get a version. It is **enabled by default**: Native Federation reads the version from the mapped library's nearest `package.json` and shares it with strict versioning, just like a published library.
 
 If your mapped paths point at plain internal source that isn't distributed as a versioned, buildable library, you can disable it. The mapped paths are then shared without a version constraint.

package/dist/config.d.ts

@@ -3,4 +3,5 @@ export { withNativeFederation } from './lib/config/with-native-federation.js';
 export { findRootTsConfigJson } from './lib/config/project-paths.js';
 export { setInferVersion } from './lib/config/version-lookup.js';
 export { share, shareAll, fromPackageJson } from './lib/config/share-utils.js';
+export { mappingsFromWorkspace } from './lib/config/mapping-utils.js';
 export { DEFAULT_SKIP_LIST } from './lib/config/default-skip-list.js';

package/dist/config.js

@@ -3,11 +3,13 @@ import { withNativeFederation } from "./lib/config/with-native-federation.js";
 import { findRootTsConfigJson } from "./lib/config/project-paths.js";
 import { setInferVersion } from "./lib/config/version-lookup.js";
 import { share, shareAll, fromPackageJson } from "./lib/config/share-utils.js";
+import { mappingsFromWorkspace } from "./lib/config/mapping-utils.js";
 import { DEFAULT_SKIP_LIST } from "./lib/config/default-skip-list.js";
 export {
   DEFAULT_SKIP_LIST,
   findRootTsConfigJson,
   fromPackageJson,
+  mappingsFromWorkspace,
   setInferVersion,
   share,
   shareAll,

package/dist/internal.d.ts

@@ -14,5 +14,6 @@ export { isESMExport, type ExportCondition, type ExportEntry, } from './lib/util
 export { isCjsCandidate, classifyByExtension, hasEsmSyntax, type ModuleFormat, } from './lib/utils/package/esm-detection.js';
 export { isIdentifierName, planCjsWrap, buildSyntheticCjsEntry, isEsmInteropError, } from './lib/utils/package/cjs-named-exports.js';
 export type { NfFileWatcher, NfFileWatcherOptions, } from './lib/domain/utils/file-watcher.contract.js';
-export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';
-export { linkedSharedDirs } from './lib/core/build/resolve-shared-dirs.js';
+export { syncNfFileWatcher, createNfWatcher, type WatchSources } from './lib/utils/file-watcher.js';
+export { linkedSharedDirs, sharedMappingDirs } from './lib/core/build/resolve-shared-dirs.js';
+export { isUnderDir, isUnderAnyDir } from './lib/utils/path-patterns.js';

package/dist/internal.js

@@ -20,7 +20,8 @@ import {
   isEsmInteropError
 } from "./lib/utils/package/cjs-named-exports.js";
 import { syncNfFileWatcher, createNfWatcher } from "./lib/utils/file-watcher.js";
-import { linkedSharedDirs } from "./lib/core/build/resolve-shared-dirs.js";
+import { linkedSharedDirs, sharedMappingDirs } from "./lib/core/build/resolve-shared-dirs.js";
+import { isUnderDir, isUnderAnyDir } from "./lib/utils/path-patterns.js";
 export {
   RebuildQueue,
   buildSyntheticCjsEntry,
@@ -34,10 +35,13 @@ export {
   isESMExport,
   isEsmInteropError,
   isIdentifierName,
+  isUnderAnyDir,
+  isUnderDir,
   linkedSharedDirs,
   logger,
   planCjsWrap,
   setLogLevel,
+  sharedMappingDirs,
   syncNfFileWatcher,
   writeImportMap
 };

package/dist/lib/config/expand-mappings.d.ts

@@ -0,0 +1,24 @@
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { GlobPort } from '../domain/utils/io-port.contract.js';
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+export interface MappingExpansionContext {
+    io: GlobPort;
+    workspaceRoot: string;
+}
+export declare function isWildcardMapping(mappedPath: string, mappedImport: string): boolean;
+/**
+ * Turns a wildcard mapping into the concrete entry points it stands for. A path containing a
+ * wildcard segment is not something the bundler can resolve, so it has to be walked on disk;
+ * the reachability pass is the only other thing that can materialise one.
+ *
+ * Naming goes through `matchMapping`, the same rule reachability uses, so an entry point is
+ * never advertised under a specifier the other path would not have produced. The glob is a
+ * guess about what consumers import, so it only yields entry-point-shaped specifiers; anything
+ * genuinely deep-imported is added by the reachability walk, which has the evidence.
+ */
+export declare function expandWildcardMapping(mappedPath: string, mappedImport: string, ctx: MappingExpansionContext): PathToImport;
+/**
+ * The `ignoreUnusedDeps: false` path: nothing is pruned, but wildcard mappings still have to
+ * become real entry points, and only `resolveGlob` can do that here.
+ */
+export declare function expandOrDropWildcards(config: NormalizedFederationConfig, ctx: MappingExpansionContext): PathToImport;

package/dist/lib/config/expand-mappings.js

@@ -0,0 +1,88 @@
+import * as path from "path";
+import { resolveMappingConfig, withoutSkippedMappings } from "./mapping-utils.js";
+import { isModuleFile, matchMapping } from "./match-mapping.js";
+import { isNonBarrelImport } from "./validate-mappings.js";
+import { parseWildcard, toGlobPattern, toPosix } from "../utils/path-patterns.js";
+import { logger } from "../utils/logger.js";
+const IGNORED_DIRS = ["**/node_modules/**"];
+function isWildcardMapping(mappedPath, mappedImport) {
+  return mappedPath.includes("*") || mappedImport.includes("*");
+}
+function expandWildcardMapping(mappedPath, mappedImport, ctx) {
+  const pattern = parseWildcard(toPosix(path.relative(ctx.workspaceRoot, mappedPath)));
+  if (!pattern.hasWildcard) {
+    logger.warn(`Mapping '${mappedImport}' has no wildcard to expand and was not shared.`);
+    return {};
+  }
+  const files = ctx.io.globFiles(toGlobPattern(pattern), {
+    cwd: ctx.workspaceRoot,
+    ignore: IGNORED_DIRS
+  });
+  const expanded = {};
+  const takenBy = {};
+  const collisions = [];
+  const notEntryPoints = [];
+  for (const file of files) {
+    if (!isModuleFile(file)) continue;
+    const absPath = path.join(ctx.workspaceRoot, toPosix(file).replace(/^\.\//, ""));
+    const importName = matchMapping(absPath, { [mappedPath]: mappedImport });
+    if (!importName) continue;
+    if (isNonBarrelImport(importName)) {
+      notEntryPoints.push(importName);
+      continue;
+    }
+    if (takenBy[importName]) {
+      collisions.push(`${importName} (${absPath}, kept ${takenBy[importName]})`);
+      continue;
+    }
+    takenBy[importName] = absPath;
+    expanded[absPath] = importName;
+  }
+  if (notEntryPoints.length > 0) {
+    logger.debug(
+      `Mapping '${mappedImport}' skipped ${notEntryPoints.length} match(es) that are not entry points: ${notEntryPoints.join(", ")}.`
+    );
+  }
+  if (collisions.length > 0) {
+    logger.warn(
+      `Mapping '${mappedImport}' expanded to duplicate imports; extra matches dropped: ${collisions.join(", ")}.`
+    );
+  }
+  if (Object.keys(expanded).length === 0) {
+    logger.warn(
+      notEntryPoints.length > 0 ? `Mapping '${mappedImport}' matched only implementation files, no entry points, and was not shared.` : `Mapping '${mappedImport}' matched no files on disk and was not shared.`
+    );
+  }
+  return expanded;
+}
+function expandOrDropWildcards(config, ctx) {
+  const result = {};
+  const dropped = [];
+  for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
+    if (!isWildcardMapping(mappedPath, mappedImport)) {
+      result[mappedPath] = mappedImport;
+      continue;
+    }
+    const mappingConfig = resolveMappingConfig(
+      mappedImport,
+      config.sharedMappingsConfig,
+      config.features.mappingVersion
+    );
+    if (mappingConfig.resolveGlob) {
+      Object.assign(result, expandWildcardMapping(mappedPath, mappedImport, ctx));
+      continue;
+    }
+    dropped.push(mappedImport);
+  }
+  if (dropped.length > 0) {
+    logger.warn(
+      `Sharing mapped paths with wildcards (*) needs either the ignoreUnusedDeps feature or 'includeSecondaries: { resolveGlob: true }'. Dropped: ${dropped.join(", ")}.`
+    );
+  }
+  return withoutSkippedMappings(result, config.skip);
+}
+export {
+  expandOrDropWildcards,
+  expandWildcardMapping,
+  isWildcardMapping
+};

package/dist/lib/config/get-used-dependencies.d.ts

@@ -19,6 +19,4 @@ type UsedDependenciesConfig = {
 };
 export declare function getUsedDependenciesFactory(workspaceRoot: string, fallbackEntryPoints?: string[]): (config: UsedDependenciesConfig) => UsedDependencies;
 export declare function getUsedDependenciesFactoryCore(deps: UsedDependenciesDeps, workspaceRoot: string, fallbackEntryPoints?: string[]): (config: UsedDependenciesConfig) => UsedDependencies;
-export declare function isSharedMapping(filePath: string, sharedMappings: PathToImport): boolean;
-export declare function matchMapping(filePath: string, sharedMappings: PathToImport): string | null;
 export {};

package/dist/lib/config/get-used-dependencies.js

@@ -1,9 +1,9 @@
 import { getProjectData as sheriffGetProjectData } from "@softarc/sheriff-core";
 import { cwd } from "process";
-import { sharedPackageJsonRepository, getPackageInfo } from "../utils/package/package-info.js";
+import { sharedPackageJsonRepository, tryGetPackageInfo } from "../utils/package/package-info.js";
 import { getExternalImportsCore } from "./get-external-imports.js";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
-import { parseWildcard, substituteWildcard, toPosix } from "../utils/path-patterns.js";
+import { isSharedMapping, matchMapping } from "./match-mapping.js";
 import * as path from "path";
 const defaultDeps = {
   io: nodeIo,
@@ -54,7 +54,7 @@ function addTransientDeps(packages, workspaceRoot, deps) {
     if (!dep) {
       continue;
     }
-    const pInfo = getPackageInfo(dep, workspaceRoot, deps.repo);
+    const pInfo = tryGetPackageInfo(dep, workspaceRoot, deps.repo);
     if (!pInfo) {
       continue;
     }
@@ -84,43 +84,7 @@ function resolveUsedMappings(fileInfos, workspaceRoot, sharedMappings) {
   }
   return usedMappings;
 }
-function isSharedMapping(filePath, sharedMappings) {
-  for (const sharedPath of Object.keys(sharedMappings)) {
-    const { prefix, hasWildcard } = parseWildcard(sharedPath);
-    if (hasWildcard) {
-      if (filePath.startsWith(prefix)) return true;
-    } else if (filePath.startsWith(sharedPath + path.sep) || filePath === sharedPath) {
-      return true;
-    }
-  }
-  return false;
-}
-function matchMapping(filePath, sharedMappings) {
-  for (const [sharedPath, sharedImport] of Object.entries(sharedMappings)) {
-    const { prefix, suffix, hasWildcard } = parseWildcard(sharedPath);
-    if (hasWildcard) {
-      if (!filePath.startsWith(prefix)) continue;
-      if (suffix && !filePath.includes(suffix)) continue;
-      const captured = suffix ? filePath.slice(prefix.length, filePath.indexOf(suffix, prefix.length)) : filePath.slice(prefix.length);
-      return substituteWildcard(sharedImport, toImportPath(captured));
-    } else if (filePath === sharedPath || isIndexOf(filePath, sharedPath)) {
-      return sharedImport;
-    }
-  }
-  return null;
-}
-const INDEX_PATTERN = /\/index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
-function isIndexOf(filePath, dirPath) {
-  return filePath.startsWith(dirPath + path.sep) && INDEX_PATTERN.test(filePath);
-}
-function toImportPath(filePath) {
-  const withoutExt = filePath.replace(/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/, "");
-  const normalized = toPosix(withoutExt);
-  return normalized.endsWith("/index") ? normalized.slice(0, -6) : normalized;
-}
 export {
   getUsedDependenciesFactory,
-  getUsedDependenciesFactoryCore,
-  isSharedMapping,
-  matchMapping
+  getUsedDependenciesFactoryCore
 };

package/dist/lib/config/mapped-paths.d.ts

@@ -1,7 +1,12 @@
 import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
 import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+import type { SharedMappingConfigs, SharedMappingEntry } from '../domain/config/federation-config.contract.js';
+export interface RawMappedPaths {
+    paths: PathToImport;
+    configs: SharedMappingConfigs;
+}
 /**
  * Will return user defined and tsconfig defined paths including their imports, might contain wildcards
  */
-export declare function getRawMappedPaths(rootTsConfigPath: string, configuredSharedMappings?: string[], rootPath?: string): PathToImport;
-export declare function getRawMappedPathsCore(io: FileReaderPort, rootTsConfigPath: string, configuredSharedMappings?: string[], rootPath?: string): PathToImport;
+export declare function getRawMappedPaths(rootTsConfigPath: string, configuredSharedMappings?: SharedMappingEntry[], rootPath?: string): RawMappedPaths;
+export declare function getRawMappedPathsCore(io: FileReaderPort, rootTsConfigPath: string, configuredSharedMappings?: SharedMappingEntry[], rootPath?: string): RawMappedPaths;

package/dist/lib/config/mapped-paths.js

@@ -1,6 +1,7 @@
 import * as path from "path";
 import JSON5 from "json5";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { matchesWildcard } from "../utils/path-patterns.js";
 function getRawMappedPaths(rootTsConfigPath, configuredSharedMappings, rootPath) {
   return getRawMappedPathsCore(nodeIo, rootTsConfigPath, configuredSharedMappings, rootPath);
 }
@@ -11,19 +12,35 @@ function getRawMappedPathsCore(io, rootTsConfigPath, configuredSharedMappings, r
   }
   const basePath = rootPath ?? path.normalize(path.dirname(rootTsConfigPath));
   const shareAll = !configuredSharedMappings;
-  const sharedMappings = configuredSharedMappings ?? [];
+  const { patterns, configs } = flattenEntries(configuredSharedMappings ?? []);
   const tsConfig = JSON5.parse(io.readText(rootTsConfigPath));
   const mappings = tsConfig?.compilerOptions?.paths;
   if (!mappings) {
-    return mappedPaths;
+    return { paths: mappedPaths, configs };
   }
   for (const key in mappings) {
     const libPath = path.normalize(path.join(basePath, mappings[key][0]));
-    if (shareAll || sharedMappings.includes(key)) {
+    if (shareAll || patterns.some((pattern) => matchesWildcard(key, pattern))) {
       mappedPaths[libPath] = key;
     }
   }
-  return mappedPaths;
+  return { paths: mappedPaths, configs };
+}
+function flattenEntries(entries) {
+  const patterns = [];
+  const configs = /* @__PURE__ */ Object.create(null);
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      patterns.push(entry);
+      continue;
+    }
+    const [keys, config] = entry;
+    for (const key of keys) {
+      patterns.push(key);
+      if (!(key in configs)) configs[key] = config;
+    }
+  }
+  return { patterns, configs };
 }
 export {
   getRawMappedPaths,

package/dist/lib/config/mapping-utils.d.ts

@@ -0,0 +1,32 @@
+import type { ExternalConfig } from '../domain/config/external-config.contract.js';
+import type { NormalizedMappingConfig, NormalizedSharedMappingConfigs, SharedMappingEntry } from '../domain/config/federation-config.contract.js';
+import type { PreparedSkipList } from '../domain/config/skip-list.contract.js';
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+export interface WorkspaceMappingsBuilder {
+    filter(patterns: string[]): WorkspaceMappingsBuilder;
+    patch(patterns: string[], cfg: Partial<ExternalConfig>): WorkspaceMappingsBuilder;
+    get(): SharedMappingEntry[];
+}
+/**
+ * Sugar over the `sharedMappings` array form: `get()` returns entries that could equally
+ * be written by hand. Without `filter()` the selection is every tsconfig path mapping.
+ */
+export declare function mappingsFromWorkspace(baseCfg?: ExternalConfig): WorkspaceMappingsBuilder;
+/**
+ * Wildcard mappings are only turned into concrete imports after the skip list has already been
+ * applied to the raw patterns, so the expanded entries have to be filtered again here.
+ */
+export declare function withoutSkippedMappings(paths: PathToImport, skipList: PreparedSkipList): PathToImport;
+/**
+ * Sole owner of the mapping defaults. `includeSecondaries` collapses to a boolean the same way
+ * `normalizeShared` does it, so both halves of `removeUnusedDeps` read one flag; `resolveGlob`
+ * is lifted out because it steers wildcard expansion, not secondary entry points.
+ */
+export declare function normalizeMappingConfig(cfg: ExternalConfig, mappingVersion: boolean): NormalizedMappingConfig;
+/**
+ * Looks a mapping's config up by its import name. Wildcard substitution rewrites imports
+ * (`@org/ui/*` -> `@org/ui/button`), so the table is keyed by the pattern the user wrote and
+ * matched, not compared. Declaration order decides: the first matching pattern wins.
+ * Falls back to the defaults so callers never re-state them.
+ */
+export declare function resolveMappingConfig(importName: string, configs: NormalizedSharedMappingConfigs, mappingVersion: boolean): NormalizedMappingConfig;

package/dist/lib/config/mapping-utils.js

@@ -0,0 +1,68 @@
+import { isInSkipList } from "./default-skip-list.js";
+import { matchesWildcard } from "../utils/path-patterns.js";
+import { logger } from "../utils/logger.js";
+const ALL = "*";
+function mappingsFromWorkspace(baseCfg = {}) {
+  const selection = [];
+  const patches = [];
+  const builder = {
+    filter(patterns) {
+      selection.push(...patterns);
+      return builder;
+    },
+    patch(patterns, cfg) {
+      patches.push({ patterns, cfg });
+      return builder;
+    },
+    get() {
+      const selected = selection.length > 0 ? [...selection] : [ALL];
+      const entries = [];
+      for (const { patterns, cfg } of patches) {
+        const kept = patterns.filter((p) => isSelected(p, selected));
+        for (const dropped of patterns.filter((p) => !isSelected(p, selected))) {
+          logger.warn(
+            `[mappingsFromWorkspace] patch('${dropped}') is not covered by filter() and was ignored.`
+          );
+        }
+        if (kept.length > 0) entries.push([kept, { ...baseCfg, ...cfg }]);
+      }
+      entries.push([selected, baseCfg]);
+      return entries;
+    }
+  };
+  return builder;
+}
+function isSelected(pattern, selection) {
+  return selection.some((s) => matchesWildcard(pattern, s));
+}
+function withoutSkippedMappings(paths, skipList) {
+  return Object.entries(paths).filter(([, mappedImport]) => !isInSkipList(mappedImport, skipList)).reduce((acc, [mappedPath, mappedImport]) => {
+    acc[mappedPath] = mappedImport;
+    return acc;
+  }, {});
+}
+function normalizeMappingConfig(cfg, mappingVersion) {
+  const includeSecondaries = typeof cfg.includeSecondaries === "object" ? !!cfg.includeSecondaries.keepAll : cfg.includeSecondaries;
+  return {
+    singleton: cfg.singleton ?? true,
+    strictVersion: cfg.strictVersion ?? mappingVersion,
+    ...cfg.requiredVersion !== void 0 && { requiredVersion: cfg.requiredVersion },
+    ...cfg.version !== void 0 && { version: cfg.version },
+    ...cfg.shareScope && { shareScope: cfg.shareScope },
+    ...cfg.pool && { pool: cfg.pool },
+    ...includeSecondaries !== void 0 && { includeSecondaries },
+    ...typeof cfg.includeSecondaries === "object" && cfg.includeSecondaries.resolveGlob && { resolveGlob: true }
+  };
+}
+function resolveMappingConfig(importName, configs, mappingVersion) {
+  for (const [pattern, config] of Object.entries(configs)) {
+    if (matchesWildcard(importName, pattern)) return config;
+  }
+  return normalizeMappingConfig({}, mappingVersion);
+}
+export {
+  mappingsFromWorkspace,
+  normalizeMappingConfig,
+  resolveMappingConfig,
+  withoutSkippedMappings
+};

package/dist/lib/config/match-mapping.d.ts

@@ -0,0 +1,9 @@
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+export declare function isModuleFile(filePath: string): boolean;
+export declare function isSharedMapping(filePath: string, sharedMappings: PathToImport): boolean;
+/**
+ * The single rule that turns a file into the import specifier it is shared under. Both the
+ * reachability walk and the `resolveGlob` expansion go through here, so an entry point cannot
+ * end up advertised under a name the other side would not have produced.
+ */
+export declare function matchMapping(filePath: string, sharedMappings: PathToImport): string | null;

package/dist/lib/config/match-mapping.js

@@ -0,0 +1,46 @@
+import * as path from "path";
+import { parseWildcard, substituteWildcard, toPosix } from "../utils/path-patterns.js";
+const MODULE_EXTENSION_PATTERN = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const DECLARATION_PATTERN = /\.d\.(ts|mts|cts)$/;
+function isModuleFile(filePath) {
+  return MODULE_EXTENSION_PATTERN.test(filePath) && !DECLARATION_PATTERN.test(filePath);
+}
+function isSharedMapping(filePath, sharedMappings) {
+  for (const sharedPath of Object.keys(sharedMappings)) {
+    const { prefix, hasWildcard } = parseWildcard(sharedPath);
+    if (hasWildcard) {
+      if (filePath.startsWith(prefix)) return true;
+    } else if (filePath.startsWith(sharedPath + path.sep) || filePath === sharedPath) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchMapping(filePath, sharedMappings) {
+  for (const [sharedPath, sharedImport] of Object.entries(sharedMappings)) {
+    const { prefix, suffix, hasWildcard } = parseWildcard(sharedPath);
+    if (hasWildcard) {
+      if (!filePath.startsWith(prefix)) continue;
+      if (suffix && !filePath.includes(suffix)) continue;
+      const captured = suffix ? filePath.slice(prefix.length, filePath.indexOf(suffix, prefix.length)) : filePath.slice(prefix.length);
+      return substituteWildcard(sharedImport, toImportPath(captured));
+    } else if (filePath === sharedPath || isIndexOf(filePath, sharedPath)) {
+      return sharedImport;
+    }
+  }
+  return null;
+}
+const INDEX_PATTERN = /\/index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+function isIndexOf(filePath, dirPath) {
+  return filePath.startsWith(dirPath + path.sep) && INDEX_PATTERN.test(filePath);
+}
+function toImportPath(filePath) {
+  const withoutExt = filePath.replace(MODULE_EXTENSION_PATTERN, "");
+  const normalized = toPosix(withoutExt);
+  return normalized.endsWith("/index") ? normalized.slice(0, -6) : normalized;
+}
+export {
+  isModuleFile,
+  isSharedMapping,
+  matchMapping
+};

package/dist/lib/config/remove-unused-deps.d.ts

@@ -1,3 +1,4 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 import type { UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
-export declare function removeUnusedDeps(usedDependencies: UsedDependencies, config: NormalizedFederationConfig): NormalizedFederationConfig;
+import { type MappingExpansionContext } from './expand-mappings.js';
+export declare function removeUnusedDeps(usedDependencies: UsedDependencies, config: NormalizedFederationConfig, ctx: MappingExpansionContext): NormalizedFederationConfig;

package/dist/lib/config/remove-unused-deps.js

@@ -1,11 +1,44 @@
-function removeUnusedDeps(usedDependencies, config) {
+import { resolveMappingConfig, withoutSkippedMappings } from "./mapping-utils.js";
+import {
+  expandWildcardMapping,
+  isWildcardMapping
+} from "./expand-mappings.js";
+import { logger } from "../utils/logger.js";
+function removeUnusedDeps(usedDependencies, config, ctx) {
   const filteredDependencies = Object.entries(config.shared).filter(([shared, meta]) => !!meta.includeSecondaries || usedDependencies.external.has(shared)).reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {});
   return {
     ...config,
     shared: filteredDependencies,
-    sharedMappings: usedDependencies.internal
+    // Both halves can contain wildcard-expanded imports, which the skip list has not seen yet.
+    sharedMappings: withoutSkippedMappings(
+      { ...keptMappings(config, ctx), ...usedDependencies.internal },
+      config.skip
+    )
   };
 }
+function keptMappings(config, ctx) {
+  const kept = {};
+  for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
+    const mappingConfig = resolveMappingConfig(
+      mappedImport,
+      config.sharedMappingsConfig,
+      config.features.mappingVersion
+    );
+    if (!mappingConfig.includeSecondaries) continue;
+    if (!isWildcardMapping(mappedPath, mappedImport)) {
+      kept[mappedPath] = mappedImport;
+      continue;
+    }
+    if (!mappingConfig.resolveGlob) {
+      logger.warn(
+        `Mapping '${mappedImport}' opts out of pruning, but wildcard mappings need 'includeSecondaries: { resolveGlob: true }' to be expanded, and will be pruned.`
+      );
+      continue;
+    }
+    Object.assign(kept, expandWildcardMapping(mappedPath, mappedImport, ctx));
+  }
+  return kept;
+}
 export {
   removeUnusedDeps
 };

package/dist/lib/config/validate-mappings.d.ts

@@ -0,0 +1,15 @@
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+/**
+ * A mapped path is advertised under its import specifier and marked external, so the specifier
+ * has to be one a browser import map can resolve. Only barrel-shaped specifiers are: a dot in
+ * the last segment breaks resolution, see https://github.com/vitejs/vite/issues/21036.
+ */
+export declare function isNonBarrelImport(importName: string): boolean;
+/**
+ * Runs on the final mapping set, which is exactly what gets advertised in `remoteEntry.json`.
+ * Anything still here will be published and resolved from an import map, so a specifier that
+ * cannot be resolved is a build error. Sources that legitimately decline to share — pruning,
+ * and the `resolveGlob` guess — have already dropped their non-barrel candidates by now, so
+ * this never fires for a path nobody asked to publish.
+ */
+export declare function assertBarrelMappings(paths: PathToImport): void;

package/dist/lib/config/validate-mappings.js

@@ -0,0 +1,28 @@
+import { logger } from "../utils/logger.js";
+const IMPORTABLE_EXTENSIONS = /* @__PURE__ */ new Set(["mjs", "js", "mts", "ts", "jsx", "tsx", "json"]);
+const MAX_LISTED = 5;
+function isNonBarrelImport(importName) {
+  if (!importName.includes(".")) return false;
+  const queryIndex = importName.search(/[?#]/);
+  const sanitized = queryIndex >= 0 ? importName.slice(0, queryIndex) : importName;
+  const lastSegment = sanitized.slice(sanitized.lastIndexOf("/") + 1);
+  const dotIndex = lastSegment.lastIndexOf(".");
+  if (dotIndex < 0) return false;
+  return !IMPORTABLE_EXTENSIONS.has(lastSegment.slice(dotIndex + 1));
+}
+function assertBarrelMappings(paths) {
+  const invalid = Object.values(paths).filter(isNonBarrelImport);
+  if (invalid.length === 0) return;
+  for (const importName of invalid) {
+    logger.warn(`Only barrel imports can be shared as a sharedMapping: '${importName}'.`);
+  }
+  const shown = invalid.slice(0, MAX_LISTED).map((i) => `'${i}'`).join(", ");
+  const rest = invalid.length - MAX_LISTED;
+  throw new Error(
+    `Invalid 'shared mappings' config. Only barrel imports can be shared as a sharedMapping: ${shown}${rest > 0 ? ` and ${rest} more` : ""}.`
+  );
+}
+export {
+  assertBarrelMappings,
+  isNonBarrelImport
+};