@softarc/native-federation 4.3.2 → 4.4.1

package/dist/lib/config/with-native-federation.js

@@ -2,21 +2,25 @@ import { getRawMappedPaths } from "./mapped-paths.js";
 import { fromPackageJson } from "./share-utils.js";
 import { findRootTsConfigJson } from "./project-paths.js";
 import { isInSkipList, prepareSkipList } from "./default-skip-list.js";
+import { normalizeMappingConfig, withoutSkippedMappings } from "./mapping-utils.js";
 import { logger } from "../utils/logger.js";
 function withNativeFederation(config) {
   const skip = prepareSkipList(config.skip ?? []);
   const chunks = config.chunks ?? true;
+  const mappingVersion = config.features?.mappingVersion ?? true;
+  const { paths, configs } = getRawMappedPaths(findRootTsConfigJson(), config.sharedMappings);
   const normalized = {
     $type: "classic",
     name: config.name ?? "",
     exposes: normalizeExposes(config.exposes),
     shared: normalizeShared(config, skip, chunks),
-    sharedMappings: removeSkippedMappings(config, skip),
+    sharedMappings: withoutSkippedMappings(paths, skip),
+    sharedMappingsConfig: normalizeMappingConfigs(configs, mappingVersion),
     chunks,
     skip,
     externals: config.externals ?? [],
     features: {
-      mappingVersion: config.features?.mappingVersion ?? true,
+      mappingVersion,
       ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
       denseChunking: config.features?.denseChunking ?? false,
       denseExternals: config.features?.denseExternals ?? false,
@@ -74,10 +78,18 @@ function normalizeShared(config, skip, chunks) {
   result = Object.keys(result).filter((key) => !isInSkipList(key, skip)).reduce((acc, cur) => ({ ...acc, [cur]: result[cur] }), {});
   return result;
 }
-function removeSkippedMappings(config, skipList) {
-  const rootTsConfigPath = findRootTsConfigJson();
-  const paths = getRawMappedPaths(rootTsConfigPath, config.sharedMappings);
-  return Object.entries(paths).filter(([, _import]) => !isInSkipList(_import, skipList)).reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
+const IGNORED_MAPPING_PROPS = ["build", "platform", "chunks", "packageInfo"];
+function normalizeMappingConfigs(configs, mappingVersion) {
+  return Object.entries(configs).reduce((acc, [pattern, cfg]) => {
+    const ignored = IGNORED_MAPPING_PROPS.filter((prop) => cfg[prop] !== void 0);
+    if (ignored.length > 0) {
+      logger.warn(
+        `Mapping '${pattern}' sets ${ignored.join(", ")}, which mapped paths do not honour (they all share one bundle). Ignored.`
+      );
+    }
+    acc[pattern] = normalizeMappingConfig(cfg, mappingVersion);
+    return acc;
+  }, {});
 }
 export {
   withNativeFederation

package/dist/lib/core/build/assemble-federation-info.d.ts

@@ -0,0 +1,8 @@
+import type { ArtifactInfo, FederationInfo } from '../../domain/core/federation-info.contract.js';
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
+/**
+ * Derives the `remoteEntry.json` payload from the populated federation cache. Shared by the initial
+ * build and the watch rebuild.
+ */
+export declare function assembleFederationInfo(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, artifactInfo: ArtifactInfo): FederationInfo;

package/dist/lib/core/build/assemble-federation-info.js

@@ -0,0 +1,34 @@
+import { densifyExternals } from "../output/densify-externals.js";
+function assembleFederationInfo(config, fedOptions, artifactInfo) {
+  const federationCache = fedOptions.federationCache;
+  const sharedExternals = applyShareScope(
+    [...federationCache.externals, ...artifactInfo.mappings],
+    config.shareScope
+  );
+  const federationInfo = {
+    name: config.name,
+    shared: config.features.denseExternals ? densifyExternals(sharedExternals) : sharedExternals,
+    exposes: artifactInfo.exposes,
+    buildNotificationsEndpoint: fedOptions.buildNotifications?.enable && fedOptions.dev ? fedOptions.buildNotifications?.endpoint : void 0
+  };
+  if (federationCache.chunks) {
+    federationInfo.chunks = federationCache.chunks;
+  }
+  if (artifactInfo.chunks) {
+    federationInfo.chunks = { ...federationInfo.chunks ?? {}, ...artifactInfo.chunks };
+  }
+  if (config.features.integrityHashes) {
+    federationInfo.integrity = {
+      ...federationCache.integrity ?? {},
+      ...artifactInfo.integrity ?? {}
+    };
+  }
+  return federationInfo;
+}
+function applyShareScope(externals, shareScope) {
+  if (!shareScope) return externals;
+  return externals.map((external) => external.shareScope ? external : { ...external, shareScope });
+}
+export {
+  assembleFederationInfo
+};

package/dist/lib/core/build/build-for-federation.js

@@ -1,22 +1,12 @@
-import {
-  bundleExposedAndMappings,
-  describeExposed,
-  describeSharedMappings
-} from "./bundle-exposed-and-mappings.js";
+import { bundleExposedAndMappings } from "./bundle-exposed-and-mappings.js";
 import { bundleShared } from "./bundle-shared.js";
-import { densifyExternals } from "../output/densify-externals.js";
-import { writeFederationInfo } from "../output/write-federation-info.js";
-import { writeImportMap } from "../output/write-import-map.js";
+import { assembleFederationInfo } from "./assemble-federation-info.js";
+import { writeFederationOutputs } from "../output/write-federation-outputs.js";
 import { logger } from "../../utils/logger.js";
 import { AbortedError } from "../../utils/errors.js";
 import { addExternalsToCache } from "../cache/federation-cache.js";
 import { planSharedBundles } from "./shared-bundle-plan.js";
-import path from "path";
 async function buildForFederation(config, fedOptions, externals, signal) {
-  fedOptions.federationCache.cachePath = path.join(
-    fedOptions.federationCache.cachePath,
-    fedOptions.projectName
-  );
   logger.info("Building federation artifacts");
   logger.notice("Skip packages you don't want to share in your federation config");
   await executeSharedBundlePlans(planSharedBundles(config, externals), config, fedOptions, signal);
@@ -31,36 +21,8 @@ async function buildForFederation(config, fedOptions, externals, signal) {
   logger.measure(start, "Step 3) Bundling all internal libraries and exposed modules.");
   if (signal?.aborted)
     throw new AbortedError("[buildForFederation] After exposed-and-mappings bundle");
-  const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
-  const sharedMappingInfo = !artifactInfo ? describeSharedMappings(config, fedOptions) : artifactInfo.mappings;
-  const sharedExternals = [...fedOptions.federationCache.externals, ...sharedMappingInfo];
-  if (config?.shareScope) {
-    Object.values(sharedExternals).forEach((external) => {
-      if (!external.shareScope) external.shareScope = config.shareScope;
-    });
-  }
-  const shared = config.features.denseExternals ? densifyExternals(sharedExternals) : sharedExternals;
-  const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev ? fedOptions.buildNotifications?.endpoint : void 0;
-  const federationInfo = {
-    name: config.name,
-    shared,
-    exposes: exposedInfo,
-    buildNotificationsEndpoint
-  };
-  if (fedOptions.federationCache.chunks) {
-    federationInfo.chunks = fedOptions.federationCache.chunks;
-  }
-  if (artifactInfo?.chunks) {
-    federationInfo.chunks = { ...federationInfo.chunks ?? {}, ...artifactInfo?.chunks };
-  }
-  if (config.features.integrityHashes) {
-    federationInfo.integrity = {
-      ...fedOptions.federationCache.integrity ?? {},
-      ...artifactInfo?.integrity ?? {}
-    };
-  }
-  writeFederationInfo(federationInfo, fedOptions);
-  writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
+  const federationInfo = assembleFederationInfo(config, fedOptions, artifactInfo);
+  writeFederationOutputs(federationInfo, fedOptions);
   return federationInfo;
 }
 async function executeSharedBundlePlans(plans, config, fedOptions, signal) {
@@ -75,7 +37,7 @@ async function executeSharedBundlePlans(plans, config, fedOptions, signal) {
     logger.measure(start, `Step 2.1) Bundling '${plan.bundleName}' externals`);
     addExternalsToCache(fedOptions.federationCache, info);
     if (signal?.aborted)
-      throw new AbortedError(`[buildForFederation] After ${plan.bundleName} bundle`);
+      throw new AbortedError(`[executeSharedBundlePlans] After ${plan.bundleName} bundle`);
   }
   const separatePlans = plans.filter((p) => p.kind === "separate");
   if (separatePlans.length > 0) {
@@ -91,7 +53,7 @@ async function executeSharedBundlePlans(plans, config, fedOptions, signal) {
     );
     logger.measure(start, "Step 2.2) Bundling all separate external packages");
     for (const info of results) addExternalsToCache(fedOptions.federationCache, info);
-    if (signal?.aborted) throw new AbortedError("[buildForFederation] After separate bundle");
+    if (signal?.aborted) throw new AbortedError("[executeSharedBundlePlans] After separate bundle");
   }
 }
 export {

package/dist/lib/core/build/bundle-exposed-and-mappings.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactInfo, ExposesInfo, SharedInfo } from '../../domain/core/federation-info.contract.js';
+import type { ArtifactInfo } from '../../domain/core/federation-info.contract.js';
 import type { FileReaderPort } from '../../domain/utils/io-port.contract.js';
 import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
 import { type NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
@@ -7,7 +7,5 @@ export declare function bundleExposedAndMappings(config: NormalizedFederationCon
 export declare function bundleExposedAndMappingsCore(deps: {
     adapter: NFBuildAdapter;
 }, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
-export declare function describeExposed(config: NormalizedFederationConfig, options: NormalizedFederationOptions): Array<ExposesInfo>;
-export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions): Array<SharedInfo>;
 export declare function getMappingVersionCore(io: FileReaderPort, fileName: string, workspaceRoot: string): string;
 export declare function getMappingVersion(fileName: string, workspaceRoot: string): string;

package/dist/lib/core/build/bundle-exposed-and-mappings.js

@@ -7,6 +7,7 @@ import { nodeIo } from "../../utils/io/node-io-adapter.js";
 import { AbortedError } from "../../utils/errors.js";
 import { rewriteChunkImports } from "./rewrite-chunk-imports.js";
 import { getBuildAdapter } from "./build-adapter.js";
+import { resolveMappingConfig } from "../../config/mapping-utils.js";
 async function bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal) {
   return bundleExposedAndMappingsCore(
     { adapter: getBuildAdapter() },
@@ -78,7 +79,13 @@ async function bundleExposedAndMappingsCore(deps, config, fedOptions, externals,
   for (const item of shared) {
     const distEntryFile = popFromResultMap(resultMap, item.outName);
     sharedResult.push(
-      toSharedMappingInfo(item.fileName, item.key, path.basename(distEntryFile), config, fedOptions)
+      toSharedMappingInfo(
+        item.fileName,
+        item.key,
+        path.basename(distEntryFile),
+        config,
+        fedOptions
+      )
     );
     entryFiles.push(distEntryFile);
   }
@@ -108,40 +115,23 @@ async function bundleExposedAndMappingsCore(deps, config, fedOptions, externals,
   const integrity = config.features.integrityHashes ? computeIntegrityMap([...entryFiles, ...chunkPaths], "") : void 0;
   return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks, integrity };
 }
-function describeExposed(config, options) {
-  const result = [];
-  for (const key in config.exposes) {
-    const expose = config.exposes[key];
-    const localPath = normalize(
-      path.normalize(path.join(options.workspaceRoot, expose.file))
-    );
-    result.push({
-      key,
-      outFileName: "",
-      ...expose.element && { element: expose.element },
-      dev: !options.dev ? void 0 : {
-        entryPoint: localPath
-      }
-    });
-  }
-  return result;
-}
-function describeSharedMappings(config, fedOptions) {
-  const result = [];
-  for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
-    result.push(toSharedMappingInfo(mappedPath, mappedImport, "", config, fedOptions));
-  }
-  return result;
-}
 function toSharedMappingInfo(mappedPath, mappedImport, outFileName, config, fedOptions) {
   const mappingVersion = config.features.mappingVersion ? getMappingVersion(mappedPath, fedOptions.workspaceRoot) : "";
+  const mappingConfig = resolveMappingConfig(
+    mappedImport,
+    config.sharedMappingsConfig,
+    config.features.mappingVersion
+  );
+  const version = mappingConfig.version ?? mappingVersion;
   return {
     packageName: mappedImport,
     outFileName,
-    requiredVersion: mappingVersion.length > 0 ? "~" + mappingVersion : "",
-    singleton: true,
-    strictVersion: config.features.mappingVersion,
-    version: mappingVersion,
+    requiredVersion: mappingConfig.requiredVersion ?? (version.length > 0 ? "~" + version : ""),
+    singleton: mappingConfig.singleton,
+    strictVersion: mappingConfig.strictVersion,
+    version,
+    ...mappingConfig.shareScope && { shareScope: mappingConfig.shareScope },
+    ...mappingConfig.pool && { pool: mappingConfig.pool },
     dev: !fedOptions.dev ? void 0 : {
       entryPoint: normalize(path.normalize(mappedPath))
     }
@@ -171,8 +161,6 @@ function getMappingVersion(fileName, workspaceRoot) {
 export {
   bundleExposedAndMappings,
   bundleExposedAndMappingsCore,
-  describeExposed,
-  describeSharedMappings,
   getMappingVersion,
   getMappingVersionCore
 };

package/dist/lib/core/build/bundle-shared.js

@@ -1,7 +1,8 @@
 import * as path from "path";
 import {
   sharedPackageJsonRepository,
-  getPackageInfo
+  getPackageInfo,
+  installedVersions
 } from "../../utils/package/package-info.js";
 import { logger } from "../../utils/logger.js";
 import { nodeIo } from "../../utils/io/node-io-adapter.js";
@@ -41,13 +42,18 @@ async function bundleSharedCore(deps, sharedBundles, config, fedOptions, externa
     deps.io,
     deps.repo
   );
+  const resolvedVersions = installedVersions(Object.keys(sharedBundles), folder, deps.repo);
+  for (const [key, cfg] of Object.entries(sharedBundles)) {
+    if (cfg.packageInfo) resolvedVersions[key] = cfg.packageInfo.version ?? "";
+  }
   const checksum = getChecksumCore(
     deps.io,
     sharedBundles,
     fedOptions.dev ? "1" : "0",
     builderVersion,
-    config.features.synthesizeCjsExports,
-    contentSignals
+    config.features,
+    contentSignals,
+    resolvedVersions
   );
   const bundleCache = cacheEntryCore(
     deps.io,

package/dist/lib/core/build/rebuild-for-federation.js

@@ -1,10 +1,6 @@
-import {
-  bundleExposedAndMappings,
-  describeExposed,
-  describeSharedMappings
-} from "./bundle-exposed-and-mappings.js";
-import { writeFederationInfo } from "../output/write-federation-info.js";
-import { writeImportMap } from "../output/write-import-map.js";
+import { bundleExposedAndMappings } from "./bundle-exposed-and-mappings.js";
+import { assembleFederationInfo } from "./assemble-federation-info.js";
+import { writeFederationOutputs } from "../output/write-federation-outputs.js";
 import { logger } from "../../utils/logger.js";
 import { AbortedError } from "../../utils/errors.js";
 import { planSharedBundles } from "./shared-bundle-plan.js";
@@ -14,7 +10,6 @@ import { cacheEntryCore, getFilename } from "../cache/cache-persistence.js";
 import { nodeIo } from "../../utils/io/node-io-adapter.js";
 import { sharedPackageJsonRepository } from "../../utils/package/package-info.js";
 async function rebuildForFederation(config, fedOptions, externals, modifiedFiles, signal) {
-  const federationCache = fedOptions.federationCache;
   await rebuildAffectedExternals(config, fedOptions, externals, modifiedFiles, signal);
   logger.info(`Re-bundling all internal libraries and exposed modules..'`);
   const start = process.hrtime();
@@ -27,31 +22,9 @@ async function rebuildForFederation(config, fedOptions, externals, modifiedFiles
   );
   logger.measure(start, "To re-bundle all internal libraries and exposed modules.");
   if (signal?.aborted)
-    throw new AbortedError("[buildForFederation] After exposed-and-mappings bundle");
-  const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
-  const sharedMappingInfo = !artifactInfo ? describeSharedMappings(config, fedOptions) : artifactInfo.mappings;
-  const sharedExternals = [...federationCache.externals, ...sharedMappingInfo];
-  const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev ? fedOptions.buildNotifications?.endpoint : void 0;
-  const federationInfo = {
-    name: config.name,
-    shared: sharedExternals,
-    exposes: exposedInfo,
-    buildNotificationsEndpoint
-  };
-  if (federationCache.chunks) {
-    federationInfo.chunks = federationCache.chunks;
-  }
-  if (artifactInfo?.chunks) {
-    federationInfo.chunks = { ...federationInfo.chunks ?? {}, ...artifactInfo?.chunks };
-  }
-  if (config.features.integrityHashes) {
-    federationInfo.integrity = {
-      ...federationCache.integrity ?? {},
-      ...artifactInfo?.integrity ?? {}
-    };
-  }
-  writeFederationInfo(federationInfo, fedOptions);
-  writeImportMap(federationCache, fedOptions, federationInfo.integrity);
+    throw new AbortedError("[rebuildForFederation] After exposed-and-mappings bundle");
+  const federationInfo = assembleFederationInfo(config, fedOptions, artifactInfo);
+  writeFederationOutputs(federationInfo, fedOptions);
   return federationInfo;
 }
 async function rebuildAffectedExternals(config, fedOptions, externals, modifiedFiles, signal, io = nodeIo, repo = sharedPackageJsonRepository) {

package/dist/lib/core/build/resolve-shared-dirs.d.ts

@@ -8,6 +8,22 @@ export declare function resolveSharedPackageDirs(config: NormalizedFederationCon
 /** Realpath'd dirs of symlinked shared packages — the bounded watch set.
  *  Deduped, since secondaries share a package dir. */
 export declare function linkedSharedDirs(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, io?: FileReaderPort, repo?: PackageJsonRepository): string[];
+/**
+ * Source directories of the workspace libs in `config.sharedMappings` — the watch set
+ * for mappings, derived from config alone rather than from a bundler cache.
+ *
+ * Coarser than the inputs a build actually compiled, and deliberately so: it covers
+ * files added to a lib after the last build, which a compiled-inputs watch set cannot
+ * know about yet. It does not follow imports out of the lib, so an adapter that can
+ * enumerate its build inputs should watch both. See angular-adapter#94.
+ *
+ * How coarse is the caller's to bound: an entry point that is not a lib barrel widens the
+ * watch to whatever directory it sits in (`'@app/env': ['src/environments/environment.ts']`
+ * to that folder, `'@shared': ['src/index.ts']` to all of `src`), and with `sharedMappings`
+ * unset every tsconfig path becomes a mapping. Watch these natively rather than polled —
+ * they are source trees, not the dist output `linkedSharedDirs` exists for.
+ */
+export declare function sharedMappingDirs(config: NormalizedFederationConfig): string[];
 /** Per-key content signal (max mtime of the resolved dir) for symlinked deps only.
  *  Registry deps get no signal, keeping their checksum version-only. (Every key is
  *  still resolved: detecting the symlink requires the realpath + lstat.) */

package/dist/lib/core/build/resolve-shared-dirs.js

@@ -1,7 +1,7 @@
 import * as path from "path";
 import { nodeIo } from "../../utils/io/node-io-adapter.js";
 import { sharedPackageJsonRepository } from "../../utils/package/package-info.js";
-import { toPosix } from "../../utils/path-patterns.js";
+import { isUnderDir, toPosix } from "../../utils/path-patterns.js";
 const folderOf = (fedOptions) => fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
 function resolveEntries(keys, folder, io, repo) {
   const out = [];
@@ -25,6 +25,10 @@ function linkedSharedDirs(config, fedOptions, io = nodeIo, repo = sharedPackageJ
   const entries = resolveEntries(Object.keys(config.shared), folderOf(fedOptions), io, repo);
   return [...new Set(entries.filter((e) => e.isSymlink).map((e) => e.realDir))];
 }
+function sharedMappingDirs(config) {
+  const dirs = Object.keys(config.sharedMappings).map((entryPoint) => toPosix(path.dirname(entryPoint))).filter((dir) => !dir.includes("node_modules"));
+  return [...new Set(dirs)];
+}
 function maxMtime(io, dir) {
   let max = 0;
   const walk = (d) => {
@@ -53,8 +57,7 @@ function affectedSharedKeys(modifiedFiles, dirs, io = nodeIo) {
   if (modifiedFiles.length === 0 || dirs.size === 0) return affected;
   const realFiles = modifiedFiles.map((f) => toPosix(io.realpath(f)));
   for (const [key, dir] of dirs) {
-    const prefix = dir.endsWith("/") ? dir : dir + "/";
-    if (realFiles.some((f) => f === dir || f.startsWith(prefix))) affected.add(key);
+    if (realFiles.some((f) => isUnderDir(f, dir))) affected.add(key);
   }
   return affected;
 }
@@ -62,5 +65,6 @@ export {
   affectedSharedKeys,
   linkedContentSignals,
   linkedSharedDirs,
-  resolveSharedPackageDirs
+  resolveSharedPackageDirs,
+  sharedMappingDirs
 };

package/dist/lib/core/cache/cache-persistence.d.ts

@@ -1,10 +1,12 @@
 import type { NormalizedExternalConfig } from '../../domain/config/external-config.contract.js';
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
 import type { ChunkInfo, IntegrityMap, SharedInfo } from '../../domain/core/federation-info.contract.js';
 import type { FileReaderPort, FileWriterPort, HashPort } from '../../domain/utils/io-port.contract.js';
 export declare const getDefaultCachePath: (workspaceRoot: string) => string;
 export declare const getFilename: (title: string, dev?: boolean) => string;
-export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string, synthesizeCjsExports?: boolean, contentSignals?: Record<string, string>) => string;
-export declare const getChecksumCore: (hash: HashPort, shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string, synthesizeCjsExports?: boolean, contentSignals?: Record<string, string>) => string;
+export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string, features?: FeatureFlags, contentSignals?: Record<string, string>, resolvedVersions?: Record<string, string>) => string;
+export type FeatureFlags = Partial<NormalizedFederationConfig['features']>;
+export declare const getChecksumCore: (hash: HashPort, shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string, features?: FeatureFlags, contentSignals?: Record<string, string>, resolvedVersions?: Record<string, string>) => string;
 export type CacheMetadata = {
     checksum: string;
     externals: SharedInfo[];

package/dist/lib/core/cache/cache-persistence.js

@@ -6,15 +6,31 @@ const getFilename = (title, dev) => {
   const devSuffix = dev ? "-dev" : "";
   return `${title}${devSuffix}.meta.json`;
 };
-const getChecksum = (shared, dev, builderVersion = "", synthesizeCjsExports = true, contentSignals = {}) => getChecksumCore(nodeIo, shared, dev, builderVersion, synthesizeCjsExports, contentSignals);
-const getChecksumCore = (hash, shared, dev, builderVersion = "", synthesizeCjsExports = true, contentSignals = {}) => {
+const getChecksum = (shared, dev, builderVersion = "", features = {}, contentSignals = {}, resolvedVersions = {}) => getChecksumCore(nodeIo, shared, dev, builderVersion, features, contentSignals, resolvedVersions);
+const featureState = (features) => Object.entries(features).sort(([a], [b]) => a < b ? -1 : 1).map(([flag, on]) => `${flag}=${on ? "1" : "0"}`).join(",");
+const SHARED_INFO_FIELDS = [
+  "requiredVersion",
+  "singleton",
+  "strictVersion",
+  "shareScope",
+  "pool"
+];
+const sharedInfoState = (config) => {
+  const values = SHARED_INFO_FIELDS.map((field) => config[field] ?? null);
+  return values.every((value) => value === null) ? "" : `!${JSON.stringify(values)}`;
+};
+const getChecksumCore = (hash, shared, dev, builderVersion = "", features = {}, contentSignals = {}, resolvedVersions = {}) => {
   const denseExternals = Object.keys(shared).sort().reduce((clean, external) => {
-    const version = shared[external].version ? `@${shared[external].version}` : "";
+    const installed = resolvedVersions[external];
+    const declared = shared[external].version;
+    const version = installed ? `~${installed}` : declared ? `@${declared}` : "";
     const signal = contentSignals[external] ? `#${contentSignals[external]}` : "";
-    return clean + ":" + external + version + signal;
+    return clean + ":" + external + version + sharedInfoState(shared[external]) + signal;
   }, "deps");
-  const cjs = synthesizeCjsExports ? "1" : "0";
-  return hash.hash("sha256", denseExternals + `:dev=${dev}:builder=${builderVersion}:cjs=${cjs}`).hex();
+  return hash.hash(
+    "sha256",
+    denseExternals + `:dev=${dev}:builder=${builderVersion}:features=${featureState(features)}`
+  ).hex();
 };
 const cacheEntryCore = (io, pathToCache, fileName) => {
   const metadataFile = path.join(pathToCache, fileName);
@@ -36,8 +52,11 @@ const cacheEntryCore = (io, pathToCache, fileName) => {
       io.mkdirp(fullOutputPath);
       cachedResult.files.forEach((file) => {
         const cachedFile = path.join(pathToCache, file);
-        const distFileName = path.join(fullOutputPath, file);
-        if (io.exists(cachedFile)) io.copyFile(cachedFile, distFileName);
+        if (!io.exists(cachedFile))
+          throw new Error(
+            `Cached artifact '${file}' recorded in '${metadataFile}' is missing. Delete '${pathToCache}' and rebuild.`
+          );
+        io.copyFile(cachedFile, path.join(fullOutputPath, file));
       });
     },
     clear: () => {

package/dist/lib/core/normalize-options.d.ts

@@ -1,11 +1,11 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
-import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
+import type { FileReaderPort, GlobPort } from '../domain/utils/io-port.contract.js';
 import { type FederationCache } from '../../domain.js';
 import { getUsedDependenciesFactory } from '../config/get-used-dependencies.js';
 type ConfigLoader = (fullConfigPath: string) => Promise<NormalizedFederationConfig>;
 interface NormalizeFederationDeps {
-    io: FileReaderPort;
+    io: FileReaderPort & GlobPort;
     loadConfig: ConfigLoader;
     usedDependenciesFactory?: typeof getUsedDependenciesFactory;
 }

package/dist/lib/core/normalize-options.js

@@ -2,6 +2,8 @@ import * as path from "path";
 import { pathToFileURL } from "url";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
 import { removeUnusedDeps } from "../config/remove-unused-deps.js";
+import { expandOrDropWildcards } from "../config/expand-mappings.js";
+import { assertBarrelMappings } from "../config/validate-mappings.js";
 import { createFederationCache } from "./cache/federation-cache.js";
 import { getDefaultCachePath } from "./cache/cache-persistence.js";
 import { getUsedDependenciesFactory } from "../config/get-used-dependencies.js";
@@ -21,35 +23,45 @@ async function normalizeFederationOptionsCore(deps, options, cache) {
     throw new Error("Expected " + fullConfigPath);
   }
   let config = await deps.loadConfig(fullConfigPath);
-  const federationCache = cache ?? createFederationCache(
+  const projectName = resolveProjectName(options.projectName ?? config.name);
+  const suppliedCache = cache ?? createFederationCache(
     getDefaultCachePath(options.workspaceRoot)
   );
+  const federationCache = {
+    ...suppliedCache,
+    cachePath: path.join(suppliedCache.cachePath, projectName),
+    externals: [...suppliedCache.externals]
+  };
   const normalizedOptions = {
     ...options,
     entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}).map((e) => e.file),
-    projectName: resolveProjectName(options.projectName ?? config.name),
+    projectName,
     cacheExternalArtifacts: options.cacheExternalArtifacts ?? true,
     federationCache
   };
-  if (config.features.ignoreUnusedDeps) {
+  const nothingShared = Object.keys(config.shared).length === 0 && Object.keys(config.sharedMappings).length === 0;
+  if (nothingShared) {
+    logger.debug("Nothing is shared, skipping the used dependency scan.");
+  } else if (config.features.ignoreUnusedDeps) {
     const getUsedDeps = (deps.usedDependenciesFactory ?? getUsedDependenciesFactory)(
       options.workspaceRoot,
       options.entryPoints
     );
-    config = removeUnusedDeps(getUsedDeps(config), config);
+    config = removeUnusedDeps(getUsedDeps(config), config, {
+      io: deps.io,
+      workspaceRoot: options.workspaceRoot
+    });
     logger.info("Removed unused dependencies.");
     logger.debug(
       'This can be disabled per dependency/external using the "includeSecondaries: {keepAll: true}" property. Or in general by disabling the "ignoreUnusedDeps" feature. '
     );
   } else {
-    const withWildcard = Object.keys(config.sharedMappings).some((m) => m.includes("*"));
-    if (withWildcard) {
-      logger.warn(
-        "Sharing mapped paths with wildcards (*) is only supported with ignoreUnusedDeps feature."
-      );
-      config.sharedMappings = Object.entries(config.sharedMappings).filter(([_path]) => !_path.includes("*")).reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
-    }
+    config.sharedMappings = expandOrDropWildcards(config, {
+      io: deps.io,
+      workspaceRoot: options.workspaceRoot
+    });
   }
+  assertBarrelMappings(config.sharedMappings);
   return { config, options: normalizedOptions };
 }
 function resolveProjectName(name) {

package/dist/lib/core/output/write-federation-outputs.d.ts

@@ -0,0 +1,7 @@
+import type { FederationInfo } from '../../domain/core/federation-info.contract.js';
+import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
+/**
+ * The import map is built from the flat federation cache rather than `federationInfo.shared`: a
+ * dense group has no import-map representation, every specifier needs its own entry.
+ */
+export declare function writeFederationOutputs(federationInfo: FederationInfo, fedOptions: NormalizedFederationOptions): void;

package/dist/lib/core/output/write-federation-outputs.js

@@ -0,0 +1,9 @@
+import { writeFederationInfo } from "./write-federation-info.js";
+import { writeImportMap } from "./write-import-map.js";
+function writeFederationOutputs(federationInfo, fedOptions) {
+  writeFederationInfo(federationInfo, fedOptions);
+  writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
+}
+export {
+  writeFederationOutputs
+};