@softarc/native-federation 4.4.0 → 4.5.0-next.1

package/dist/internal.d.ts

@@ -15,5 +15,6 @@ export { isCjsCandidate, classifyByExtension, hasEsmSyntax, type ModuleFormat, }
 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, type WatchSources } from './lib/utils/file-watcher.js';
+export type { WatchPort, WatchHandle } from './lib/domain/utils/io-port.contract.js';
 export { linkedSharedDirs, sharedMappingDirs } from './lib/core/build/resolve-shared-dirs.js';
 export { isUnderDir, isUnderAnyDir } from './lib/utils/path-patterns.js';

package/dist/lib/config/configuration-context.d.ts

@@ -1,7 +1,8 @@
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
 export interface ConfigurationContext {
     workspaceRoot?: string;
     packageJson?: string;
 }
-export declare function useWorkspace(workspaceRoot: string): void;
+export declare function useWorkspace(workspaceRoot: string, io?: FileReaderPort): void;
 export declare function usePackageJson(packageJson?: string): void;
 export declare function getConfigContext(): ConfigurationContext;

package/dist/lib/config/configuration-context.js

@@ -1,6 +1,8 @@
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { toDiskCase } from "../utils/disk-case.js";
 let _context = {};
-function useWorkspace(workspaceRoot) {
-  _context = { ..._context, workspaceRoot };
+function useWorkspace(workspaceRoot, io = nodeIo) {
+  _context = { ..._context, workspaceRoot: toDiskCase(io, workspaceRoot) };
 }
 function usePackageJson(packageJson) {
   _context = { ..._context, packageJson };

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

@@ -4,6 +4,7 @@ import { sharedPackageJsonRepository, tryGetPackageInfo } from "../utils/package
 import { getExternalImportsCore } from "./get-external-imports.js";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
 import { isSharedMapping, matchMapping } from "./match-mapping.js";
+import { logger } from "../utils/logger.js";
 import * as path from "path";
 const defaultDeps = {
   io: nodeIo,
@@ -71,6 +72,8 @@ function addTransientDeps(packages, workspaceRoot, deps) {
 }
 function resolveUsedMappings(fileInfos, workspaceRoot, sharedMappings) {
   const usedMappings = {};
+  const matchesIgnoringCase = createCaseInsensitiveMatcher(sharedMappings);
+  const caseOnlyMisses = /* @__PURE__ */ new Set();
   for (const fileName of Object.keys(fileInfos)) {
     const fullFileName = path.join(workspaceRoot, fileName);
     if (isSharedMapping(fullFileName, sharedMappings)) continue;
@@ -80,10 +83,27 @@ function resolveUsedMappings(fileInfos, workspaceRoot, sharedMappings) {
       const fullImport = path.join(workspaceRoot, imp);
       const match = matchMapping(fullImport, sharedMappings);
       if (match) usedMappings[fullImport] = match;
+      else if (matchesIgnoringCase(fullImport)) caseOnlyMisses.add(fullImport);
     }
   }
+  warnOnCaseOnlyMisses(caseOnlyMisses);
   return usedMappings;
 }
+function createCaseInsensitiveMatcher(sharedMappings) {
+  const lowerCased = Object.fromEntries(
+    Object.entries(sharedMappings).map(([sharedPath, sharedImport]) => [
+      sharedPath.toLowerCase(),
+      sharedImport
+    ])
+  );
+  return (filePath) => matchMapping(filePath.toLowerCase(), lowerCased) !== null;
+}
+function warnOnCaseOnlyMisses(misses) {
+  if (misses.size === 0) return;
+  logger.warn(
+    `${misses.size} import(s) match a shared mapping only when case is ignored, so those libraries were pruned from remoteEntry.json -- e.g. '${[...misses][0]}'.`
+  );
+}
 export {
   getUsedDependenciesFactory,
   getUsedDependenciesFactoryCore

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

@@ -2,4 +2,4 @@ import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
 export declare function findRootTsConfigJson(): string;
 export declare function findRootTsConfigJsonCore(io: FileReaderPort): string;
 export declare function findPackageJson(io: FileReaderPort, folder: string): string;
-export declare function inferProjectPath(projectPath: string | undefined): string;
+export declare function inferProjectPath(projectPath: string | undefined, io?: FileReaderPort): string;

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

@@ -2,11 +2,12 @@ import * as path from "path";
 import { cwd } from "process";
 import { getConfigContext } from "./configuration-context.js";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { toDiskCase } from "../utils/disk-case.js";
 function findRootTsConfigJson() {
   return findRootTsConfigJsonCore(nodeIo);
 }
 function findRootTsConfigJsonCore(io) {
-  const packageJson = findPackageJson(io, cwd());
+  const packageJson = findPackageJson(io, toDiskCase(io, cwd()));
   const projectRoot = path.dirname(packageJson);
   const tsConfigBaseJson = path.join(projectRoot, "tsconfig.base.json");
   const tsConfigJson = path.join(projectRoot, "tsconfig.json");
@@ -29,7 +30,7 @@ function findPackageJson(io, folder) {
     "no package.json found. Searched the following folder and all parents: " + folder
   );
 }
-function inferProjectPath(projectPath) {
+function inferProjectPath(projectPath, io = nodeIo) {
   if (!projectPath && getConfigContext().packageJson) {
     projectPath = path.dirname(getConfigContext().packageJson || "");
   }
@@ -37,7 +38,7 @@ function inferProjectPath(projectPath) {
     projectPath = getConfigContext().workspaceRoot || "";
   }
   if (!projectPath) {
-    projectPath = cwd();
+    projectPath = toDiskCase(io, cwd());
   }
   return projectPath;
 }

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

@@ -6,14 +6,19 @@ import {
 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 }), {});
+  const sharedMappings = withoutSkippedMappings(
+    { ...keptMappings(config, ctx), ...usedDependencies.internal },
+    config.skip
+  );
+  if (Object.keys(config.sharedMappings).length > 0 && Object.keys(sharedMappings).length === 0) {
+    logger.warn(
+      "No shared mapping is reachable from the entry points, so remoteEntry.json will ship without this workspace's libraries. Disable 'ignoreUnusedDeps' to publish them anyway."
+    );
+  }
   return {
     ...config,
     shared: filteredDependencies,
-    // Both halves can contain wildcard-expanded imports, which the skip list has not seen yet.
-    sharedMappings: withoutSkippedMappings(
-      { ...keptMappings(config, ctx), ...usedDependencies.internal },
-      config.skip
-    )
+    sharedMappings
   };
 }
 function keptMappings(config, ctx) {

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

@@ -8,7 +8,7 @@ import {
 import { logger } from "../utils/logger.js";
 import { nodeIo } from "../utils/io/node-io-adapter.js";
 import { findPackageJson, inferProjectPath } from "./project-paths.js";
-import { isInferVersion, lookupVersion } from "./version-lookup.js";
+import { isInferVersion, lookupVersion, applyAutoRequiredOptions } from "./version-lookup.js";
 import { addSecondaries, getSecondaries } from "./secondaries.js";
 const fromPackageJson = (baseCfg, projectPath) => {
   const skipList = [...DEFAULT_SKIP_LIST];
@@ -59,8 +59,19 @@ function shareAllCore(io, config, opts = {}, repo = sharedPackageJsonRepository)
       if (!!opts.overrides && Object.keys(opts.overrides).some((o) => key.startsWith(o))) {
         continue;
       }
-      const inferVersion = !config.requiredVersion || config.requiredVersion === "auto";
-      const requiredVersion = inferVersion ? versions[key] : config.requiredVersion;
+      const requiredVersionCfg = config.requiredVersion ?? void 0;
+      const isAutoObject = typeof requiredVersionCfg === "object";
+      const inferVersion = !requiredVersionCfg || requiredVersionCfg === "auto" || isAutoObject;
+      let requiredVersion;
+      if (inferVersion) {
+        const base = versions[key];
+        requiredVersion = isAutoObject ? applyAutoRequiredOptions(base, {
+          range: requiredVersionCfg.range,
+          version: requiredVersionCfg.version ?? config.version
+        }) : base;
+      } else {
+        requiredVersion = requiredVersionCfg;
+      }
       if (!sharedExternals[key]) {
         sharedExternals[key] = { ...config, requiredVersion };
       }
@@ -100,11 +111,20 @@ function shareCore(io, configuredShareObjects, projectPath = "", skipList = DEFA
   const result = {};
   for (const key in shareObjects) {
     let includeSecondaries = false;
-    const shareObject = shareObjects[key];
-    if (shareObject.requiredVersion === "auto" || isInferVersion() && typeof shareObject.requiredVersion === "undefined" || (shareObject.requiredVersion?.length ?? 1) < 1) {
-      const version = lookupVersion(key, projectPath, repo);
-      shareObject.requiredVersion = version;
-      shareObject.version = version.replace(/^\D*/, "");
+    const { requiredVersion: requiredVersionCfg, ...rest } = shareObjects[key];
+    const shareObject = {
+      ...rest,
+      ...typeof requiredVersionCfg === "string" && {
+        requiredVersion: requiredVersionCfg
+      }
+    };
+    if (requiredVersionCfg === "auto" || isInferVersion() && typeof requiredVersionCfg === "undefined" || typeof requiredVersionCfg === "object" || (requiredVersionCfg?.length ?? 1) < 1) {
+      const isAutoObject = typeof requiredVersionCfg === "object";
+      const explicitVersion = isAutoObject ? requiredVersionCfg.version ?? shareObject.version : void 0;
+      const resolvedVersion = explicitVersion && explicitVersion !== "auto" ? explicitVersion : void 0;
+      const raw = resolvedVersion ?? lookupVersion(key, projectPath, repo);
+      shareObject.requiredVersion = isAutoObject && requiredVersionCfg.range ? applyAutoRequiredOptions(raw, { range: requiredVersionCfg.range }) : raw;
+      shareObject.version = raw.replace(/^\D*/, "");
     }
     if (typeof shareObject.includeSecondaries === "undefined") {
       shareObject.includeSecondaries = true;

package/dist/lib/config/version-lookup.d.ts

@@ -2,3 +2,7 @@ import type { PackageJsonRepository } from '../domain/utils/package-json.contrac
 export declare function setInferVersion(infer: boolean): void;
 export declare function isInferVersion(): boolean;
 export declare function lookupVersion(key: string, workspaceRoot: string, repo: PackageJsonRepository): string;
+export declare function applyAutoRequiredOptions(baseVersion: string, opts?: {
+    range?: 'exact' | '^' | '~' | 'minor' | 'patch';
+    version?: string;
+}): string;

package/dist/lib/config/version-lookup.js

@@ -30,7 +30,34 @@ function lookupVersionInMap(key, versions) {
   }
   return versions[key];
 }
+function applyAutoRequiredOptions(baseVersion, opts) {
+  const explicit = opts?.version && opts.version !== "auto" ? opts.version : void 0;
+  const raw = (explicit ?? baseVersion ?? "").trim();
+  if (!opts || !opts.range) return raw;
+  const requested = opts.range;
+  const singleTokenMatch = raw.match(
+    /^(?:[~^<>=]*\s*)?v?(\d+)(?:\.(\d+))?(?:\.(\d+))?((?:[-+][\w.]+)?)$/
+  );
+  if (!singleTokenMatch) {
+    return raw;
+  }
+  const [, major, minor = "0", patch = "0", extra] = singleTokenMatch;
+  const bareVersion = `${major}.${minor}.${patch}${extra}`;
+  switch (requested) {
+    case "exact":
+      return bareVersion;
+    case "^":
+    case "minor":
+      return `^${bareVersion}`;
+    case "~":
+    case "patch":
+      return `~${bareVersion}`;
+    default:
+      return raw;
+  }
+}
 export {
+  applyAutoRequiredOptions,
   isInferVersion,
   lookupVersion,
   setInferVersion

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

@@ -115,29 +115,6 @@ 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(
@@ -184,8 +161,6 @@ function getMappingVersion(fileName, workspaceRoot) {
 export {
   bundleExposedAndMappings,
   bundleExposedAndMappingsCore,
-  describeExposed,
-  describeSharedMappings,
   getMappingVersion,
   getMappingVersionCore
 };

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

@@ -6,7 +6,7 @@ import type { PackageJsonRepository } from '../../domain/utils/package-json.cont
  *  file-mapping agree on one identity for symlinked (npm-linked) deps. */
 export declare function resolveSharedPackageDirs(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, io?: FileReaderPort, repo?: PackageJsonRepository): Map<string, string>;
 /** Realpath'd dirs of symlinked shared packages — the bounded watch set.
- *  Deduped, since secondaries share a package dir. */
+ *  Deduped, since secondaries share a package dir. Empty unless `watchLinkedDeps` is on. */
 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
@@ -24,9 +24,12 @@ export declare function linkedSharedDirs(config: NormalizedFederationConfig, fed
  * 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.
+/** Per-key content signal (max mtime of the resolved dir) for linked checkouts only.
  *  Registry deps get no signal, keeping their checksum version-only. (Every key is
- *  still resolved: detecting the symlink requires the realpath + lstat.) */
+ *  still resolved: detecting the symlink requires the realpath + lstat.)
+ *
+ *  Deliberately not gated on `watchLinkedDeps`: that option decides whether an edit is
+ *  noticed live, never whether the next build is correct. */
 export declare function linkedContentSignals(keys: string[], folder: string, io?: FileReaderPort, repo?: PackageJsonRepository): Record<string, string>;
 /** `config.shared` keys whose package directory contains at least one modified file. */
 export declare function affectedSharedKeys(modifiedFiles: readonly string[], dirs: Map<string, string>, io?: FileReaderPort): Set<string>;

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 { isUnderDir, toPosix } from "../../utils/path-patterns.js";
+import { isOutsideNodeModules, 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 = [];
@@ -9,10 +9,12 @@ function resolveEntries(keys, folder, io, repo) {
     const pkgJsonPath = repo.findDepPackageJson(key, folder);
     if (!pkgJsonPath) continue;
     const pkgDir = path.dirname(pkgJsonPath);
+    const realDir = toPosix(io.realpath(pkgDir));
     out.push({
       key,
-      realDir: toPosix(io.realpath(pkgDir)),
-      isSymlink: !!io.stat(pkgDir)?.isSymbolicLink
+      realDir,
+      // pnpm's default linker symlinks every dep, so the link alone proves nothing.
+      isLinkedCheckout: !!io.stat(pkgDir)?.isSymbolicLink && isOutsideNodeModules(realDir)
     });
   }
   return out;
@@ -22,24 +24,29 @@ function resolveSharedPackageDirs(config, fedOptions, io = nodeIo, repo = shared
   return new Map(entries.map((e) => [e.key, e.realDir]));
 }
 function linkedSharedDirs(config, fedOptions, io = nodeIo, repo = sharedPackageJsonRepository) {
+  if (!fedOptions.watchLinkedDeps) return [];
   const entries = resolveEntries(Object.keys(config.shared), folderOf(fedOptions), io, repo);
-  return [...new Set(entries.filter((e) => e.isSymlink).map((e) => e.realDir))];
+  return [...new Set(entries.filter((e) => e.isLinkedCheckout).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"));
+  const dirs = Object.keys(config.sharedMappings).map((entryPoint) => toPosix(path.dirname(entryPoint))).filter(isOutsideNodeModules);
   return [...new Set(dirs)];
 }
 function maxMtime(io, dir) {
   let max = 0;
+  const bump = (s) => {
+    if (s && s.mtimeMs > max) max = s.mtimeMs;
+  };
   const walk = (d) => {
     for (const name of io.readDir(d)) {
       const full = path.join(d, name);
-      if (io.isDirectory(full)) walk(full);
-      else {
-        let s = io.stat(full);
-        if (s?.isSymbolicLink) s = io.stat(io.realpath(full));
-        if (s && s.mtimeMs > max) max = s.mtimeMs;
+      const entry = io.stat(full);
+      if (entry?.isSymbolicLink) {
+        if (!io.isDirectory(full)) bump(io.stat(io.realpath(full)));
+        continue;
       }
+      if (io.isDirectory(full)) walk(full);
+      else bump(entry);
     }
   };
   walk(dir);
@@ -47,8 +54,15 @@ function maxMtime(io, dir) {
 }
 function linkedContentSignals(keys, folder, io = nodeIo, repo = sharedPackageJsonRepository) {
   const signals = {};
+  const byDir = /* @__PURE__ */ new Map();
   for (const entry of resolveEntries(keys, folder, io, repo)) {
-    if (entry.isSymlink) signals[entry.key] = String(maxMtime(io, entry.realDir));
+    if (!entry.isLinkedCheckout) continue;
+    let signal = byDir.get(entry.realDir);
+    if (signal === void 0) {
+      signal = String(maxMtime(io, entry.realDir));
+      byDir.set(entry.realDir, signal);
+    }
+    signals[entry.key] = signal;
   }
   return signals;
 }

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

@@ -9,6 +9,7 @@ import { getDefaultCachePath } from "./cache/cache-persistence.js";
 import { getUsedDependenciesFactory } from "../config/get-used-dependencies.js";
 import { logger } from "../utils/logger.js";
 import { normalizePackageName } from "../utils/normalize.js";
+import { toDiskCase } from "../utils/disk-case.js";
 const defaultConfigLoader = async (fullConfigPath) => (await import(pathToFileURL(fullConfigPath).href))?.default;
 async function normalizeFederationOptions(options, cache) {
   return normalizeFederationOptionsCore(
@@ -18,19 +19,30 @@ async function normalizeFederationOptions(options, cache) {
   );
 }
 async function normalizeFederationOptionsCore(deps, options, cache) {
-  const fullConfigPath = path.join(options.workspaceRoot, options.federationConfig);
+  const workspaceRoot = toDiskCase(deps.io, options.workspaceRoot);
+  const packageJson = options.packageJson && toDiskCase(deps.io, options.packageJson);
+  const fullConfigPath = path.join(workspaceRoot, options.federationConfig);
   if (!deps.io.exists(fullConfigPath)) {
     throw new Error("Expected " + fullConfigPath);
   }
   let config = await deps.loadConfig(fullConfigPath);
-  const federationCache = cache ?? createFederationCache(
-    getDefaultCachePath(options.workspaceRoot)
+  const projectName = resolveProjectName(options.projectName ?? config.name);
+  const suppliedCache = cache ?? createFederationCache(
+    getDefaultCachePath(workspaceRoot)
   );
+  const federationCache = {
+    ...suppliedCache,
+    cachePath: path.join(suppliedCache.cachePath, projectName),
+    externals: [...suppliedCache.externals]
+  };
   const normalizedOptions = {
     ...options,
+    workspaceRoot,
+    ...packageJson && { packageJson },
     entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}).map((e) => e.file),
-    projectName: resolveProjectName(options.projectName ?? config.name),
+    projectName,
     cacheExternalArtifacts: options.cacheExternalArtifacts ?? true,
+    watchLinkedDeps: options.watchLinkedDeps ?? false,
     federationCache
   };
   const nothingShared = Object.keys(config.shared).length === 0 && Object.keys(config.sharedMappings).length === 0;
@@ -38,12 +50,12 @@ async function normalizeFederationOptionsCore(deps, options, cache) {
     logger.debug("Nothing is shared, skipping the used dependency scan.");
   } else if (config.features.ignoreUnusedDeps) {
     const getUsedDeps = (deps.usedDependenciesFactory ?? getUsedDependenciesFactory)(
-      options.workspaceRoot,
+      workspaceRoot,
       options.entryPoints
     );
     config = removeUnusedDeps(getUsedDeps(config), config, {
       io: deps.io,
-      workspaceRoot: options.workspaceRoot
+      workspaceRoot
     });
     logger.info("Removed unused dependencies.");
     logger.debug(
@@ -52,7 +64,7 @@ async function normalizeFederationOptionsCore(deps, options, cache) {
   } else {
     config.sharedMappings = expandOrDropWildcards(config, {
       io: deps.io,
-      workspaceRoot: options.workspaceRoot
+      workspaceRoot
     });
   }
   assertBarrelMappings(config.sharedMappings);

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
+};

package/dist/lib/domain/config/external-config.contract.d.ts

@@ -3,6 +3,16 @@ export type IncludeSecondariesOptions = {
     resolveGlob?: boolean;
     keepAll?: boolean;
 } | boolean;
+export interface AutoRequiredOptions {
+    version?: 'auto' | string;
+    /** Controls how the resolved package.json version is emitted.
+     * - 'exact' => "1.2.3"
+     * - '^' | '~' => '^1.2.3' or '~1.2.3'
+     * - 'minor' => maps to '^' (allow minor bumps)
+     * - 'patch' => maps to '~' (allow patch bumps)
+     */
+    range?: 'exact' | '^' | '~' | 'minor' | 'patch';
+}
 export interface ExternalConfig {
     singleton?: boolean;
     strictVersion?: boolean;
@@ -39,8 +49,10 @@ export interface NormalizedExternalConfig {
 }
 export type SharedExternalsConfig = Record<string, ExternalConfig>;
 export type NormalizedSharedExternalsConfig = Record<string, NormalizedExternalConfig>;
-export type ShareAllExternalsOptions = ExternalConfig;
-export type ShareExternalsOptions = SharedExternalsConfig;
+export type ShareAllExternalsOptions = Omit<ExternalConfig, 'requiredVersion'> & {
+    requiredVersion?: string | AutoRequiredOptions;
+};
+export type ShareExternalsOptions = Record<string, ShareAllExternalsOptions>;
 export type ResolvedExternalConfig = Omit<ExternalConfig, 'includeSecondaries'> & {
     includeSecondaries?: boolean;
 };

package/dist/lib/domain/core/federation-options.contract.d.ts

@@ -10,6 +10,11 @@ export interface FederationOptions {
     verbose?: boolean;
     dev?: boolean;
     watch?: boolean;
+    /** Poll-watch npm-linked shared deps so rebuilding the linked lib live-reloads the host.
+     *  Off by default: a registry dep is bundled once and cached by checksum, so watching
+     *  node_modules cannot change an outcome. With this off a linked lib still re-bundles on
+     *  the next build, it just does not live-reload. */
+    watchLinkedDeps?: boolean;
     packageJson?: string;
     entryPoints?: string[];
     buildNotifications?: BuildNotificationOptions;
@@ -19,4 +24,5 @@ export interface NormalizedFederationOptions<TBundlerCache = unknown> extends Fe
     entryPoints: string[];
     projectName: string;
     cacheExternalArtifacts: boolean;
+    watchLinkedDeps: boolean;
 }

package/dist/lib/domain/utils/file-watcher.contract.d.ts

@@ -1,4 +1,11 @@
+import type { WatchPort } from './io-port.contract.js';
 export interface NfFileWatcherOptions {
+    /** Watch implementation, defaulting to Node's fs. The built-in poll is dependency-free
+     *  but sweeps the tree every `pollIntervalMs`; a host that already ships a real watcher
+     *  should pass it here. An event-driven implementation may ignore `opts.poll`, but must
+     *  then survive inode replacement on its own: a polled dir supersedes the native watches
+     *  beneath it, so a missed rename-replace is never re-covered. */
+    watch?: WatchPort['watch'];
     onChange?: (path: string) => void;
     pollIntervalMs?: number;
     debounceMs?: number;

package/dist/lib/domain/utils/io-port.contract.d.ts

@@ -20,6 +20,8 @@ export interface FileReaderPort {
     /** Immediate child entry names (not full paths). Empty array on ENOENT, never throws. */
     readDir(path: string): string[];
     realpath(path: string): string;
+    /** The path as disk spells it, including case on case-insensitive filesystems. */
+    realpathNative(path: string): string;
     stat(path: string): StatInfo | null;
 }
 export interface FileWriterPort {

package/dist/lib/utils/disk-case.d.ts

@@ -0,0 +1,7 @@
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
+/**
+ * Every absolute path that gets string-compared later descends from a root supplied by the
+ * invoking tool, and on Windows two tools can report one root with different drive-letter case.
+ * Correcting it at the root keeps the comparison sites unchanged.
+ */
+export declare function toDiskCase(io: FileReaderPort, p: string): string;

package/dist/lib/utils/disk-case.js

@@ -0,0 +1,14 @@
+import * as path from "path";
+import { toPosix } from "./path-patterns.js";
+function toDiskCase(io, p) {
+  const real = io.realpathNative(p);
+  if (real === p || !differsOnlyByCase(real, p)) return p;
+  return path.normalize(real);
+}
+function differsOnlyByCase(a, b) {
+  const strip = (s) => toPosix(s).replace(/\/+$/, "").toLowerCase();
+  return strip(a) === strip(b);
+}
+export {
+  toDiskCase
+};

package/dist/lib/utils/file-watcher.js

@@ -1,12 +1,13 @@
 import { dirname, join } from "path";
 import { nodeIo } from "./io/node-io-adapter.js";
 import { logger } from "./logger.js";
-import { isUnderDir, toPosix } from "./path-patterns.js";
+import { isOutsideNodeModules, isUnderDir, toPosix } from "./path-patterns.js";
 function createNfWatcher(options = {}) {
   return createNfWatcherCore(nodeIo, options);
 }
 function createNfWatcherCore(io, options = {}, now = Date.now) {
   const { onChange } = options;
+  const watch = options.watch ?? ((p, o, cb) => io.watch(p, o, cb));
   const pollIntervalMs = options.pollIntervalMs ?? 300;
   const debounceMs = options.debounceMs ?? 0;
   const dedupeReplays = options.dedupeReplays ?? true;
@@ -21,18 +22,18 @@ function createNfWatcherCore(io, options = {}, now = Date.now) {
     return posix.length > 1 ? posix.replace(/\/+$/, "") : posix;
   };
   const covers = (path, poll) => {
-    for (const [dir, watch] of watchers) {
-      if ((watch.poll || !poll) && isUnderDir(path, dir)) return true;
+    for (const [dir, watch2] of watchers) {
+      if ((watch2.poll || !poll) && isUnderDir(path, dir)) return true;
     }
     return false;
   };
   const supersede = (dir, poll) => {
     for (const map of [watchers, fileDirWatchers]) {
-      for (const [key, watch] of map) {
-        if (watch.poll && !poll) continue;
+      for (const [key, watch2] of map) {
+        if (watch2.poll && !poll) continue;
         if (map === watchers && key === dir) continue;
         if (!isUnderDir(key, dir)) continue;
-        watch.handle.close();
+        watch2.handle.close();
         map.delete(key);
       }
     }
@@ -92,7 +93,7 @@ function createNfWatcherCore(io, options = {}, now = Date.now) {
           if (watchers.has(dir2) || covers(dir2, shouldPoll)) continue;
           try {
             watchers.set(dir2, {
-              handle: io.watch(p, { recursive: true, poll }, (filename) => {
+              handle: watch(p, { recursive: true, poll }, (filename) => {
                 if (filename) notify(toPosix(join(p, filename)));
               }),
               poll: shouldPoll
@@ -116,7 +117,7 @@ function createNfWatcherCore(io, options = {}, now = Date.now) {
         if (fileDirWatchers.has(dir)) continue;
         try {
           fileDirWatchers.set(dir, {
-            handle: io.watch(dir, { recursive: false, poll }, (filename) => {
+            handle: watch(dir, { recursive: false, poll }, (filename) => {
               if (!filename) return;
               const changed = toPosix(join(dir, filename));
               if (trackedFiles.has(changed)) notify(changed);
@@ -150,7 +151,7 @@ function toPaths(sources) {
   return typeof cache.keys === "function" ? cache.keys() : sources;
 }
 function syncNfFileWatcher(watcher, sources, linkedDirs = []) {
-  const files = [...toPaths(sources)].filter((k) => !k.includes("node_modules"));
+  const files = [...toPaths(sources)].filter(isOutsideNodeModules);
   if (files.length) watcher.addPaths(files);
   if (linkedDirs.length) watcher.addPaths(linkedDirs, { poll: true });
 }

package/dist/lib/utils/io/node-io-adapter.js

@@ -40,6 +40,15 @@ const nodeIo = {
       return path2;
     }
   },
+  // Only the native variant reports the spelling stored on disk: the JS realpathSync walks the
+  // components of the input string and rewrites only the ones that are symlinks.
+  realpathNative(path2) {
+    try {
+      return fs.realpathSync.native(path2);
+    } catch {
+      return path2;
+    }
+  },
   stat(path2) {
     try {
       const s = fs.lstatSync(path2);
@@ -96,6 +105,7 @@ function pollWatch(root, recursive, intervalMs, onEvent) {
         return;
       }
       for (const entry of entries) {
+        if (entry.name === "node_modules") continue;
         const full = path.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (recursive) walk(full);

package/dist/lib/utils/path-patterns.d.ts

@@ -26,3 +26,11 @@ export declare function substituteWildcard(template: string, captured: string):
  * `libs/ui-**` reads as `libs/ui-*` and silently matches nothing one level down.
  */
 export declare function toGlobPattern({ prefix, suffix }: WildcardPattern): string;
+/**
+ * A dev checkout rather than an installed package. A symlink alone cannot tell them apart:
+ * pnpm's default linker points every dep at `…/node_modules/.pnpm/<pkg>@<ver>/node_modules/
+ * <pkg>`, while `npm link` resolves to the checkout. Matched anywhere in the path, since a
+ * monorepo's store can sit above the workspace root, and by segment so a checkout under
+ * `node_modules_backup` still counts.
+ */
+export declare const isOutsideNodeModules: (dir: string) => boolean;

package/dist/lib/utils/path-patterns.js

@@ -28,8 +28,10 @@ function substituteWildcard(template, captured) {
 function toGlobPattern({ prefix, suffix }) {
   return prefix.slice(0, prefix.lastIndexOf("/") + 1) + "**/*" + suffix;
 }
+const isOutsideNodeModules = (dir) => !toPosix(dir).split("/").includes("node_modules");
 export {
   captureWildcard,
+  isOutsideNodeModules,
   isUnderAnyDir,
   isUnderDir,
   matchesWildcard,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.4.0",
+  "version": "4.5.0-next.1",
   "type": "module",
   "license": "MIT",
   "packageManager": "pnpm@11.18.0",