@softarc/native-federation 4.3.1 → 4.4.0

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

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

@@ -2,25 +2,30 @@ 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,
-      integrityHashes: config.features?.integrityHashes ?? false
+      integrityHashes: config.features?.integrityHashes ?? false,
+      synthesizeCjsExports: config.features?.synthesizeCjsExports ?? true
     },
     ...config.shareScope && { shareScope: config.shareScope }
   };
@@ -73,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/build-for-federation.d.ts

@@ -1,4 +1,11 @@
 import type { FederationInfo } from '../../domain/core/federation-info.contract.js';
 import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
 import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import { type SharedBundlePlan } from './shared-bundle-plan.js';
 export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], signal?: AbortSignal): Promise<FederationInfo>;
+/**
+ * Bundles shared/separate externals per plan and populates the federation cache.
+ * Shared bundles run sequentially (with signal checks); separate bundles run in
+ * parallel. Shared by the initial build and the watch rebuild.
+ */
+export declare function executeSharedBundlePlans(plans: SharedBundlePlan[], config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, signal?: AbortSignal): Promise<void>;

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

@@ -8,9 +8,9 @@ import { densifyExternals } from "../output/densify-externals.js";
 import { writeFederationInfo } from "../output/write-federation-info.js";
 import { writeImportMap } from "../output/write-import-map.js";
 import { logger } from "../../utils/logger.js";
-import { inferPackageFromSecondary, normalizePackageName } from "../../utils/normalize.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(
@@ -19,66 +19,7 @@ async function buildForFederation(config, fedOptions, externals, signal) {
   );
   logger.info("Building federation artifacts");
   logger.notice("Skip packages you don't want to share in your federation config");
-  const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(
-    config.shared
-  );
-  if (Object.keys(sharedBrowser).length > 0) {
-    logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
-    const start2 = process.hrtime();
-    const sharedPackageInfoBrowser = await bundleShared(
-      sharedBrowser,
-      config,
-      fedOptions,
-      externals,
-      { platform: "browser", bundleName: "browser-shared", chunks: config.chunks }
-    );
-    logger.measure(start2, "Step 2.1) Bundling all shared browser externals");
-    addExternalsToCache(fedOptions.federationCache, sharedPackageInfoBrowser);
-    if (signal?.aborted) throw new AbortedError("[buildForFederation] After shared-browser bundle");
-  }
-  if (Object.keys(sharedServer).length > 0) {
-    logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
-    const start2 = process.hrtime();
-    const sharedPackageInfoServer = await bundleShared(
-      sharedServer,
-      config,
-      fedOptions,
-      externals,
-      { platform: "node", bundleName: "node-shared", chunks: config.chunks }
-    );
-    logger.measure(start2, "Step 2.1) Bundling all shared node externals");
-    addExternalsToCache(fedOptions.federationCache, sharedPackageInfoServer);
-    if (signal?.aborted) throw new AbortedError("[buildForFederation] After shared-node bundle");
-  }
-  if (Object.keys(separateBrowser).length > 0) {
-    logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
-    const start2 = process.hrtime();
-    const separatePackageInfoBrowser = await bundleSeparatePackages(
-      separateBrowser,
-      externals,
-      config,
-      fedOptions,
-      { platform: "browser" }
-    );
-    logger.measure(start2, "Step 2.2) Bundling all separate browser external packages");
-    addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
-    if (signal?.aborted)
-      throw new AbortedError("[buildForFederation] After separate-browser bundle");
-  }
-  if (Object.keys(separateServer).length > 0) {
-    logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
-    const start2 = process.hrtime();
-    const separatePackageInfoServer = await bundleSeparatePackages(
-      separateServer,
-      externals,
-      config,
-      fedOptions,
-      { platform: "node" }
-    );
-    logger.measure(start2, "Step 2.2) Bundling all separate node external packages");
-    addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
-  }
-  if (signal?.aborted) throw new AbortedError("[buildForFederation] After separate-node bundle");
+  await executeSharedBundlePlans(planSharedBundles(config, externals), config, fedOptions, signal);
   const start = process.hrtime();
   const artifactInfo = await bundleExposedAndMappings(
     config,
@@ -122,81 +63,38 @@ async function buildForFederation(config, fedOptions, externals, signal) {
   writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
   return federationInfo;
 }
-async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, buildOptions) {
-  const groupedByPackage = {};
-  for (const [key, shared] of Object.entries(separateBrowser)) {
-    const packageName = shared.build === "separate" ? key : inferPackageFromSecondary(key);
-    if (!groupedByPackage[packageName]) {
-      groupedByPackage[packageName] = {
-        chunks: shared.chunks,
-        entries: {}
-      };
-    }
-    groupedByPackage[packageName].entries[key] = shared;
+async function executeSharedBundlePlans(plans, config, fedOptions, signal) {
+  for (const plan of plans.filter((p) => p.kind === "shared")) {
+    logger.info(`Bundling external npm packages with bundle type '${plan.bundleName}'`);
+    const start = process.hrtime();
+    const info = await bundleShared(plan.entries, config, fedOptions, plan.externals, {
+      platform: plan.platform,
+      bundleName: plan.bundleName,
+      chunks: plan.chunks
+    });
+    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`);
   }
-  const bundlePromises = Object.entries(groupedByPackage).map(
-    async ([packageName, packageConfig]) => {
-      return bundleShared(
-        packageConfig.entries,
-        config,
-        fedOptions,
-        externals.filter((e) => !e.startsWith(packageName)),
-        {
-          platform: buildOptions.platform,
-          chunks: packageConfig.chunks,
-          bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`
-        }
-      );
-    }
-  );
-  const buildResults = await Promise.all(bundlePromises);
-  return buildResults.reduce(
-    (acc, r) => {
-      let chunks = acc.chunks;
-      if (r.chunks) {
-        chunks = { ...acc.chunks ?? {}, ...r.chunks };
-      }
-      let integrity = acc.integrity;
-      if (r.integrity) {
-        integrity = { ...acc.integrity ?? {}, ...r.integrity };
-      }
-      return {
-        externals: [...acc.externals, ...r.externals],
-        chunks,
-        integrity
-      };
-    },
-    { externals: [] }
-  );
-}
-function splitShared(shared) {
-  const sharedServer = {};
-  const sharedBrowser = {};
-  const separateBrowser = {};
-  const separateServer = {};
-  for (const key in shared) {
-    const obj = shared[key];
-    if (obj?.platform === "node") {
-      if (obj.build === "default") {
-        sharedServer[key] = obj;
-      } else {
-        separateServer[key] = obj;
-      }
-    } else if (obj?.platform === "browser") {
-      if (obj.build === "default") {
-        sharedBrowser[key] = obj;
-      } else {
-        separateBrowser[key] = obj;
-      }
-    }
+  const separatePlans = plans.filter((p) => p.kind === "separate");
+  if (separatePlans.length > 0) {
+    const start = process.hrtime();
+    const results = await Promise.all(
+      separatePlans.map(
+        (plan) => bundleShared(plan.entries, config, fedOptions, plan.externals, {
+          platform: plan.platform,
+          bundleName: plan.bundleName,
+          chunks: plan.chunks
+        })
+      )
+    );
+    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");
   }
-  return {
-    sharedBrowser,
-    sharedServer,
-    separateBrowser,
-    separateServer
-  };
 }
 export {
-  buildForFederation
+  buildForFederation,
+  executeSharedBundlePlans
 };

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);
   }
@@ -112,9 +119,7 @@ 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))
-    );
+    const localPath = normalize(path.normalize(path.join(options.workspaceRoot, expose.file)));
     result.push({
       key,
       outFileName: "",
@@ -135,13 +140,21 @@ function describeSharedMappings(config, fedOptions) {
 }
 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))
     }

package/dist/lib/core/build/bundle-shared.d.ts

@@ -5,6 +5,7 @@ import type { HashPort, IoPort } from '../../domain/utils/io-port.contract.js';
 import { type NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
 import type { NormalizedExternalConfig } from '../../domain/config/external-config.contract.js';
 import type { NFBuildAdapter } from '../../domain/core/build-adapter.contract.js';
+import { type ModuleEvaluator } from './synthesize-cjs-exports.js';
 export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
     platform: 'browser' | 'node';
     bundleName: string;
@@ -18,6 +19,12 @@ interface BundleSharedDeps {
     io: IoPort;
     repo: PackageJsonRepository;
     adapter: NFBuildAdapter;
+    /**
+     * Loads a module by absolute path at build time (Node `require`) and returns its
+     * runtime exports, from which a CJS external's named exports are then enumerated.
+     * Omitted → no named-export synthesis; externals stay default-only.
+     */
+    evaluateModule?: ModuleEvaluator;
 }
 export declare function bundleSharedCore(deps: BundleSharedDeps, sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
     platform: 'browser' | 'node';

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";
@@ -9,12 +10,21 @@ import { DEFAULT_EXTERNAL_LIST } from "./default-external-list.js";
 import { isSourceFile, transformChunkImports } from "./rewrite-chunk-imports.js";
 import { toChunkImport } from "../../domain/core/chunk.js";
 import { cacheEntryCore, getChecksumCore, getFilename } from "../cache/cache-persistence.js";
+import { linkedContentSignals } from "./resolve-shared-dirs.js";
 import { computeIntegrityMapCore } from "./compute-integrity.js";
 import { fileURLToPath } from "url";
 import { getBuildAdapter } from "./build-adapter.js";
+import { synthesizeCjsNamedExportsEntry } from "./synthesize-cjs-exports.js";
+import { createRequire } from "module";
 async function bundleShared(sharedBundles, config, fedOptions, externals, buildOptions) {
+  const requireFromWorkspace = createRequire(path.join(fedOptions.workspaceRoot, "index.js"));
   return bundleSharedCore(
-    { io: nodeIo, repo: sharedPackageJsonRepository, adapter: getBuildAdapter() },
+    {
+      io: nodeIo,
+      repo: sharedPackageJsonRepository,
+      adapter: getBuildAdapter(),
+      evaluateModule: (absPath) => requireFromWorkspace(absPath)
+    },
     sharedBundles,
     config,
     fedOptions,
@@ -25,13 +35,26 @@ async function bundleShared(sharedBundles, config, fedOptions, externals, buildO
 async function bundleSharedCore(deps, sharedBundles, config, fedOptions, externals, buildOptions) {
   const builderPackageJson = readBuilderPackageJson(deps.io, fileURLToPath(import.meta.url));
   const builderVersion = parseBuilderVersion(builderPackageJson);
+  const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
+  const contentSignals = linkedContentSignals(
+    Object.keys(sharedBundles),
+    folder,
+    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
+    builderVersion,
+    config.features,
+    contentSignals,
+    resolvedVersions
   );
-  const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
   const bundleCache = cacheEntryCore(
     deps.io,
     fedOptions.federationCache.cachePath,
@@ -67,8 +90,22 @@ async function bundleSharedCore(deps, sharedBundles, config, fedOptions, externa
   const configState = `BUNDLER_CHUNKS;${builderVersion};${JSON.stringify(config)}`;
   const entryPoints = packageInfos.map((pi) => {
     const encName = pi.packageName.replace(/[^A-Za-z0-9]/g, "_");
-    const outName = createOutName(deps.io, pi, configState, fedOptions, encName);
-    return { fileName: pi.entryPoint, outName };
+    const outName = createOutName(
+      deps.io,
+      pi,
+      configState,
+      fedOptions,
+      encName,
+      contentSignals[pi.packageName] ?? ""
+    );
+    const synthetic = deps.evaluateModule && config.features.synthesizeCjsExports ? synthesizeCjsNamedExportsEntry(
+      deps.io,
+      deps.evaluateModule,
+      pi,
+      fedOptions.federationCache.cachePath,
+      outName
+    ) : null;
+    return { fileName: synthetic ?? pi.entryPoint, outName };
   });
   const fullOutputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
   const useDefaultExternalList = buildOptions.platform === "browser" && !config.features.ignoreUnusedDeps;
@@ -177,8 +214,8 @@ function applyRenames(bundleResult, entryPoints, renamed) {
     if (next) ep.outName = next;
   }
 }
-function createOutName(io, pi, configState, fedOptions, encName) {
-  const hashBase = pi.version + "_" + pi.entryPoint + "_" + configState;
+function createOutName(io, pi, configState, fedOptions, encName, contentSignal = "") {
+  const hashBase = pi.version + "_" + pi.entryPoint + "_" + configState + (contentSignal ? "_" + contentSignal : "");
   const hash = calcHashCore(io, hashBase);
   const outName = fedOptions.dev ? `${encName}.${hash}-dev.js` : `${encName}.${hash}.js`;
   return outName;

package/dist/lib/core/build/rebuild-for-federation.d.ts

@@ -1,4 +1,12 @@
 import type { FederationInfo } from '../../domain/core/federation-info.contract.js';
 import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
 import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import type { IoPort } from '../../domain/utils/io-port.contract.js';
+import type { PackageJsonRepository } from '../../domain/utils/package-json.contract.js';
 export declare function rebuildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal): Promise<FederationInfo>;
+/**
+ * When a modified file belongs to a shared package (e.g. npm-linked dev dep),
+ * re-bundle the affected bundle(s); unchanged bundles hit their cache, so
+ * `federationCache.externals` regenerates cheaply. No package touched → no-op.
+ */
+export declare function rebuildAffectedExternals(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal, io?: IoPort, repo?: PackageJsonRepository): Promise<void>;

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

@@ -7,8 +7,15 @@ import { writeFederationInfo } from "../output/write-federation-info.js";
 import { writeImportMap } from "../output/write-import-map.js";
 import { logger } from "../../utils/logger.js";
 import { AbortedError } from "../../utils/errors.js";
+import { planSharedBundles } from "./shared-bundle-plan.js";
+import { executeSharedBundlePlans } from "./build-for-federation.js";
+import { affectedSharedKeys, resolveSharedPackageDirs } from "./resolve-shared-dirs.js";
+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();
   const artifactInfo = await bundleExposedAndMappings(
@@ -47,6 +54,25 @@ async function rebuildForFederation(config, fedOptions, externals, modifiedFiles
   writeImportMap(federationCache, fedOptions, federationInfo.integrity);
   return federationInfo;
 }
+async function rebuildAffectedExternals(config, fedOptions, externals, modifiedFiles, signal, io = nodeIo, repo = sharedPackageJsonRepository) {
+  if (modifiedFiles.length === 0) return;
+  const plans = planSharedBundles(config, externals);
+  if (plans.length === 0) return;
+  const dirs = resolveSharedPackageDirs(config, fedOptions, io, repo);
+  const affected = affectedSharedKeys(modifiedFiles, dirs, io);
+  const affectedPlans = plans.filter((p) => p.keys.some((k) => affected.has(k)));
+  if (affectedPlans.length === 0) return;
+  const federationCache = fedOptions.federationCache;
+  for (const plan of affectedPlans) {
+    logger.info(`Detected change in linked shared package(s); re-bundling '${plan.bundleName}'.`);
+    cacheEntryCore(io, federationCache.cachePath, getFilename(plan.bundleName, fedOptions.dev)).clear();
+  }
+  federationCache.externals = [];
+  federationCache.chunks = void 0;
+  federationCache.integrity = void 0;
+  await executeSharedBundlePlans(plans, config, fedOptions, signal);
+}
 export {
+  rebuildAffectedExternals,
   rebuildForFederation
 };

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

@@ -0,0 +1,32 @@
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import type { NormalizedFederationOptions } from '../../domain/core/federation-options.contract.js';
+import type { FileReaderPort } from '../../domain/utils/io-port.contract.js';
+import type { PackageJsonRepository } from '../../domain/utils/package-json.contract.js';
+/** Each `config.shared` key → its realpath'd package dir, so watcher, checksum, and
+ *  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. */
+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.) */
+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

@@ -0,0 +1,70 @@
+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";
+const folderOf = (fedOptions) => fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
+function resolveEntries(keys, folder, io, repo) {
+  const out = [];
+  for (const key of keys) {
+    const pkgJsonPath = repo.findDepPackageJson(key, folder);
+    if (!pkgJsonPath) continue;
+    const pkgDir = path.dirname(pkgJsonPath);
+    out.push({
+      key,
+      realDir: toPosix(io.realpath(pkgDir)),
+      isSymlink: !!io.stat(pkgDir)?.isSymbolicLink
+    });
+  }
+  return out;
+}
+function resolveSharedPackageDirs(config, fedOptions, io = nodeIo, repo = sharedPackageJsonRepository) {
+  const entries = resolveEntries(Object.keys(config.shared), folderOf(fedOptions), io, repo);
+  return new Map(entries.map((e) => [e.key, e.realDir]));
+}
+function linkedSharedDirs(config, fedOptions, io = nodeIo, repo = sharedPackageJsonRepository) {
+  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) => {
+    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;
+      }
+    }
+  };
+  walk(dir);
+  return max;
+}
+function linkedContentSignals(keys, folder, io = nodeIo, repo = sharedPackageJsonRepository) {
+  const signals = {};
+  for (const entry of resolveEntries(keys, folder, io, repo)) {
+    if (entry.isSymlink) signals[entry.key] = String(maxMtime(io, entry.realDir));
+  }
+  return signals;
+}
+function affectedSharedKeys(modifiedFiles, dirs, io = nodeIo) {
+  const affected = /* @__PURE__ */ new Set();
+  if (modifiedFiles.length === 0 || dirs.size === 0) return affected;
+  const realFiles = modifiedFiles.map((f) => toPosix(io.realpath(f)));
+  for (const [key, dir] of dirs) {
+    if (realFiles.some((f) => isUnderDir(f, dir))) affected.add(key);
+  }
+  return affected;
+}
+export {
+  affectedSharedKeys,
+  linkedContentSignals,
+  linkedSharedDirs,
+  resolveSharedPackageDirs,
+  sharedMappingDirs
+};

package/dist/lib/core/build/shared-bundle-plan.d.ts

@@ -0,0 +1,22 @@
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import type { NormalizedExternalConfig } from '../../domain/config/external-config.contract.js';
+export interface SharedBundlePlan {
+    bundleName: string;
+    platform: 'browser' | 'node';
+    chunks: boolean;
+    entries: Record<string, NormalizedExternalConfig>;
+    externals: string[];
+    keys: string[];
+    kind: 'shared' | 'separate';
+}
+type SplitSharedResult = {
+    sharedServer: Record<string, NormalizedExternalConfig>;
+    sharedBrowser: Record<string, NormalizedExternalConfig>;
+    separateBrowser: Record<string, NormalizedExternalConfig>;
+    separateServer: Record<string, NormalizedExternalConfig>;
+};
+export declare function splitShared(shared: Record<string, NormalizedExternalConfig>): SplitSharedResult;
+/** Single source of truth for package → bundle(name) mapping, shared by the initial
+ *  build and the watch rebuild so both target the same cache entries. */
+export declare function planSharedBundles(config: NormalizedFederationConfig, externals: string[]): SharedBundlePlan[];
+export {};