@softarc/native-federation 4.3.1 → 4.3.2

package/dist/internal.d.ts

@@ -11,5 +11,8 @@ export { RebuildQueue, type TrackResult } from './lib/core/rebuild-queue.js';
 export { writeImportMap } from './lib/core/output/write-import-map.js';
 export { getDefaultCachePath, getChecksum } from './lib/core/cache/cache-persistence.js';
 export { isESMExport, type ExportCondition, type ExportEntry, } from './lib/utils/package/package-info.js';
+export { isCjsCandidate, classifyByExtension, hasEsmSyntax, type ModuleFormat, } from './lib/utils/package/esm-detection.js';
+export { isIdentifierName, planCjsWrap, buildSyntheticCjsEntry, isEsmInteropError, } from './lib/utils/package/cjs-named-exports.js';
 export type { NfFileWatcher, NfFileWatcherOptions, } from './lib/domain/utils/file-watcher.contract.js';
 export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';
+export { linkedSharedDirs } from './lib/core/build/resolve-shared-dirs.js';

package/dist/internal.js

@@ -8,15 +8,35 @@ import { getDefaultCachePath, getChecksum } from "./lib/core/cache/cache-persist
 import {
   isESMExport
 } from "./lib/utils/package/package-info.js";
+import {
+  isCjsCandidate,
+  classifyByExtension,
+  hasEsmSyntax
+} from "./lib/utils/package/esm-detection.js";
+import {
+  isIdentifierName,
+  planCjsWrap,
+  buildSyntheticCjsEntry,
+  isEsmInteropError
+} from "./lib/utils/package/cjs-named-exports.js";
 import { syncNfFileWatcher, createNfWatcher } from "./lib/utils/file-watcher.js";
+import { linkedSharedDirs } from "./lib/core/build/resolve-shared-dirs.js";
 export {
   RebuildQueue,
+  buildSyntheticCjsEntry,
+  classifyByExtension,
   createNfWatcher,
   getChecksum,
   getDefaultCachePath,
+  hasEsmSyntax,
   hashFile,
+  isCjsCandidate,
   isESMExport,
+  isEsmInteropError,
+  isIdentifierName,
+  linkedSharedDirs,
   logger,
+  planCjsWrap,
   setLogLevel,
   syncNfFileWatcher,
   writeImportMap

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

@@ -20,7 +20,8 @@ function withNativeFederation(config) {
       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 }
   };

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-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

@@ -9,12 +9,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 +34,21 @@ 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 checksum = getChecksumCore(
     deps.io,
     sharedBundles,
     fedOptions.dev ? "1" : "0",
-    builderVersion
+    builderVersion,
+    config.features.synthesizeCjsExports,
+    contentSignals
   );
-  const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
   const bundleCache = cacheEntryCore(
     deps.io,
     fedOptions.federationCache.cachePath,
@@ -67,8 +84,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 +208,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,16 @@
+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[];
+/** 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,66 @@
+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";
+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 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) {
+    const prefix = dir.endsWith("/") ? dir : dir + "/";
+    if (realFiles.some((f) => f === dir || f.startsWith(prefix))) affected.add(key);
+  }
+  return affected;
+}
+export {
+  affectedSharedKeys,
+  linkedContentSignals,
+  linkedSharedDirs,
+  resolveSharedPackageDirs
+};

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

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

@@ -0,0 +1,70 @@
+import { inferPackageFromSecondary, normalizePackageName } from "../../utils/normalize.js";
+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;
+    }
+  }
+  return { sharedBrowser, sharedServer, separateBrowser, separateServer };
+}
+function planSeparate(separate, platform, externals) {
+  const grouped = {};
+  for (const [key, shared] of Object.entries(separate)) {
+    const packageName = shared.build === "separate" ? key : inferPackageFromSecondary(key);
+    if (!grouped[packageName]) grouped[packageName] = { chunks: shared.chunks, entries: {} };
+    grouped[packageName].entries[key] = shared;
+  }
+  return Object.entries(grouped).map(([packageName, group]) => ({
+    bundleName: `${platform}-${normalizePackageName(packageName)}`,
+    platform,
+    chunks: group.chunks,
+    entries: group.entries,
+    externals: externals.filter((e) => !e.startsWith(packageName)),
+    keys: Object.keys(group.entries),
+    kind: "separate"
+  }));
+}
+function planSharedBundles(config, externals) {
+  const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(
+    config.shared
+  );
+  const plans = [];
+  if (Object.keys(sharedBrowser).length > 0) {
+    plans.push({
+      bundleName: "browser-shared",
+      platform: "browser",
+      chunks: config.chunks,
+      entries: sharedBrowser,
+      externals,
+      keys: Object.keys(sharedBrowser),
+      kind: "shared"
+    });
+  }
+  if (Object.keys(sharedServer).length > 0) {
+    plans.push({
+      bundleName: "node-shared",
+      platform: "node",
+      chunks: config.chunks,
+      entries: sharedServer,
+      externals,
+      keys: Object.keys(sharedServer),
+      kind: "shared"
+    });
+  }
+  plans.push(...planSeparate(separateBrowser, "browser", externals));
+  plans.push(...planSeparate(separateServer, "node", externals));
+  return plans;
+}
+export {
+  planSharedBundles,
+  splitShared
+};

package/dist/lib/core/build/synthesize-cjs-exports.d.ts

@@ -0,0 +1,12 @@
+import type { IoPort } from '../../domain/utils/io-port.contract.js';
+import type { PackageInfo } from '../../domain/utils/package-json.contract.js';
+/** Evaluates a module at build time (Node `require`) and returns its value, or throws. */
+export type ModuleEvaluator = (absPath: string) => unknown;
+/**
+ * For a CommonJS shared external, `require()`s it, enumerates its runtime named
+ * exports, and writes a synthetic ESM entry re-exporting them.
+ *
+ * Returns the synthetic entry path, or `null` to keep the original entry (not a CJS
+ * candidate, no names to wrap, or a `require()` failure → default-only fallback).
+ */
+export declare function synthesizeCjsNamedExportsEntry(io: IoPort, evaluateModule: ModuleEvaluator, pi: PackageInfo, cachePath: string, outName: string): string | null;

package/dist/lib/core/build/synthesize-cjs-exports.js

@@ -0,0 +1,58 @@
+import * as path from "path";
+import { logger } from "../../utils/logger.js";
+import { isCjsCandidate } from "../../utils/package/esm-detection.js";
+import {
+  planCjsWrap,
+  buildSyntheticCjsEntry,
+  isEsmInteropError
+} from "../../utils/package/cjs-named-exports.js";
+const SYNTHETIC_DIR = ".nf-cjs-entries";
+const warned = /* @__PURE__ */ new Set();
+function nearestPackageType(io, fromDir) {
+  let dir = fromDir;
+  for (; ; ) {
+    const pkg = path.join(dir, "package.json");
+    if (io.exists(pkg)) {
+      try {
+        const type = JSON.parse(io.readText(pkg))?.type;
+        return type === "module" || type === "commonjs" ? type : void 0;
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function synthesizeCjsNamedExportsEntry(io, evaluateModule, pi, cachePath, outName) {
+  const entryPoint = pi.entryPoint;
+  const candidate = isCjsCandidate({
+    esm: pi.esm,
+    entryPoint,
+    packageType: nearestPackageType(io, path.dirname(entryPoint)),
+    readSource: () => io.readText(entryPoint)
+  });
+  if (!candidate) return null;
+  let plan;
+  try {
+    plan = planCjsWrap(evaluateModule(entryPoint));
+  } catch (err) {
+    if (!isEsmInteropError(err) && !warned.has(entryPoint)) {
+      warned.add(entryPoint);
+      const detail = err instanceof Error ? err.message : String(err);
+      logger.warn(
+        `[native-federation] Could not enumerate named exports of "${entryPoint}" at build time (${detail}); falling back to default-only. Named imports from this package may fail across the module boundary.`
+      );
+    }
+    return null;
+  }
+  if (!plan.wrap) return null;
+  const dir = path.join(cachePath, SYNTHETIC_DIR);
+  io.mkdirp(dir);
+  const syntheticPath = path.join(dir, outName);
+  io.writeText(syntheticPath, buildSyntheticCjsEntry(entryPoint, plan.keys));
+  return syntheticPath;
+}
+export {
+  synthesizeCjsNamedExportsEntry
+};

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

@@ -3,8 +3,8 @@ import type { ChunkInfo, IntegrityMap, SharedInfo } from '../../domain/core/fede
 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) => string;
-export declare const getChecksumCore: (hash: HashPort, shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string) => 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 type CacheMetadata = {
     checksum: string;
     externals: SharedInfo[];

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

@@ -6,12 +6,15 @@ const getFilename = (title, dev) => {
   const devSuffix = dev ? "-dev" : "";
   return `${title}${devSuffix}.meta.json`;
 };
-const getChecksum = (shared, dev, builderVersion = "") => getChecksumCore(nodeIo, shared, dev, builderVersion);
-const getChecksumCore = (hash, shared, dev, builderVersion = "") => {
+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 denseExternals = Object.keys(shared).sort().reduce((clean, external) => {
-    return clean + ":" + external + (shared[external].version ? `@${shared[external].version}` : "");
+    const version = shared[external].version ? `@${shared[external].version}` : "";
+    const signal = contentSignals[external] ? `#${contentSignals[external]}` : "";
+    return clean + ":" + external + version + signal;
   }, "deps");
-  return hash.hash("sha256", denseExternals + `:dev=${dev}:builder=${builderVersion}`).hex();
+  const cjs = synthesizeCjsExports ? "1" : "0";
+  return hash.hash("sha256", denseExternals + `:dev=${dev}:builder=${builderVersion}:cjs=${cjs}`).hex();
 };
 const cacheEntryCore = (io, pathToCache, fileName) => {
   const metadataFile = path.join(pathToCache, fileName);

package/dist/lib/core/federation-builder.d.ts

@@ -1,6 +1,6 @@
 import type { FederationInfo } from '../domain/core/federation-info.contract.js';
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import { type FederationOptions } from '../domain/core/federation-options.contract.js';
+import { type FederationOptions, type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
 import type { NFBuildAdapter } from '../domain/core/build-adapter.contract.js';
 export interface BuildHelperParams {
     options: FederationOptions;
@@ -19,5 +19,6 @@ export declare const federationBuilder: {
     readonly federationInfo: FederationInfo;
     readonly externals: string[];
     readonly config: NormalizedFederationConfig;
+    readonly options: NormalizedFederationOptions;
 };
 export {};

package/dist/lib/core/federation-builder.js

@@ -46,6 +46,9 @@ const federationBuilder = {
   },
   get config() {
     return config;
+  },
+  get options() {
+    return options;
   }
 };
 export {

package/dist/lib/core/output/densify-externals.js

@@ -40,6 +40,7 @@ function densifyExternals(shared) {
       if (entry.version !== void 0) dense.version = entry.version;
       if (entry.shareScope !== void 0) dense.shareScope = entry.shareScope;
       if (entry.bundle !== void 0) dense.bundle = entry.bundle;
+      if (entry.pool !== void 0) dense.pool = entry.pool;
       if (entry.dev !== void 0) dense.dev = entry.dev;
       groupIndex.set(key, result.length);
       result.push(dense);

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

@@ -21,6 +21,7 @@ export interface FederationConfig {
         denseChunking?: boolean;
         denseExternals?: boolean;
         integrityHashes?: boolean;
+        synthesizeCjsExports?: boolean;
     };
 }
 export interface NormalizedFederationConfig {
@@ -39,5 +40,6 @@ export interface NormalizedFederationConfig {
         denseChunking: boolean;
         denseExternals: boolean;
         integrityHashes: boolean;
+        synthesizeCjsExports: boolean;
     };
 }

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

@@ -1,10 +1,16 @@
 export interface NfFileWatcherOptions {
     onChange?: (path: string) => void;
+    pollIntervalMs?: number;
+    debounceMs?: number;
+}
+interface AddPathsOptions {
+    poll?: boolean;
 }
 export interface NfFileWatcher {
-    addPaths(paths: string | readonly string[]): void;
+    addPaths(paths: string | readonly string[], opts?: AddPathsOptions): void;
     close(): Promise<void>;
     get(): ReadonlySet<string>;
     clear(): void;
     mutate(fn: (dirtyPaths: Set<string>) => void): void;
 }
+export {};

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

@@ -3,6 +3,10 @@ export interface Digest {
     hex(): string;
     base64(): string;
 }
+export interface StatInfo {
+    mtimeMs: number;
+    isSymbolicLink: boolean;
+}
 export interface FileReaderPort {
     readText(path: string): string;
     readBytes(path: string): Uint8Array;
@@ -13,6 +17,8 @@ export interface FileReaderPort {
     isDirectory(path: string): boolean;
     /** Immediate child entry names (not full paths). Empty array on ENOENT, never throws. */
     readDir(path: string): string[];
+    realpath(path: string): string;
+    stat(path: string): StatInfo | null;
 }
 export interface FileWriterPort {
     writeText(path: string, data: string): void;
@@ -31,15 +37,20 @@ export interface HashPort {
 export interface WatchHandle {
     close(): void;
 }
+interface WatchOptions {
+    recursive: boolean;
+    poll?: {
+        intervalMs: number;
+    };
+}
 export interface WatchPort {
     /**
      * For a recursive directory watch `onEvent` receives the changed entry's
      * filename relative to `path`; for a file it receives the path itself (or
      * null when the platform omits it).
      */
-    watch(path: string, opts: {
-        recursive: boolean;
-    }, onEvent: (filename: string | null) => void): WatchHandle;
+    watch(path: string, opts: WatchOptions, onEvent: (filename: string | null) => void): WatchHandle;
 }
 export interface IoPort extends FileReaderPort, FileWriterPort, GlobPort, HashPort, WatchPort {
 }
+export {};

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

@@ -4,4 +4,4 @@ export declare function createNfWatcher(options?: NfFileWatcherOptions): NfFileW
 export declare function createNfWatcherCore(io: WatchPort & FileReaderPort, options?: NfFileWatcherOptions): NfFileWatcher;
 export declare function syncNfFileWatcher(watcher: NfFileWatcher, bundlerCache: {
     keys(): IterableIterator<string>;
-}): void;
+}, linkedDirs?: readonly string[]): void;

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

@@ -7,22 +7,37 @@ function createNfWatcher(options = {}) {
 }
 function createNfWatcherCore(io, options = {}) {
   const { onChange } = options;
+  const pollIntervalMs = options.pollIntervalMs ?? 300;
+  const debounceMs = options.debounceMs ?? 0;
   const watchers = /* @__PURE__ */ new Map();
   const dirtyPaths = /* @__PURE__ */ new Set();
-  const notify = (path) => {
+  const deliver = (path) => {
     if (onChange) onChange(path);
     else dirtyPaths.add(path);
   };
+  const pending = /* @__PURE__ */ new Set();
+  let flushTimer;
+  const flush = () => {
+    for (const p of pending) deliver(p);
+    pending.clear();
+  };
+  const notify = (path) => {
+    if (debounceMs <= 0) return deliver(path);
+    pending.add(path);
+    if (flushTimer) clearTimeout(flushTimer);
+    flushTimer = setTimeout(flush, debounceMs);
+    flushTimer.unref?.();
+  };
   return {
-    addPaths(paths) {
+    addPaths(paths, opts) {
       const list = typeof paths === "string" ? [paths] : [...paths];
+      const poll = opts?.poll ? { intervalMs: pollIntervalMs } : void 0;
       for (const p of list) {
         if (watchers.has(p)) continue;
         try {
-          const isDir = io.isDirectory(p);
-          const handle = isDir ? io.watch(p, { recursive: true }, (filename) => {
+          const handle = io.isDirectory(p) ? io.watch(p, { recursive: true, poll }, (filename) => {
             if (filename) notify(toPosix(join(p, filename)));
-          }) : io.watch(p, { recursive: false }, () => notify(toPosix(p)));
+          }) : io.watch(p, { recursive: false, poll }, () => notify(toPosix(p)));
           watchers.set(p, handle);
         } catch {
           logger.debug(`Could not watch path '${p}'.`);
@@ -33,6 +48,7 @@ function createNfWatcherCore(io, options = {}) {
     clear: () => dirtyPaths.clear(),
     mutate: (fn) => fn(dirtyPaths),
     async close() {
+      if (flushTimer) clearTimeout(flushTimer);
       for (const handle of watchers.values()) {
         handle.close();
       }
@@ -40,9 +56,10 @@ function createNfWatcherCore(io, options = {}) {
     }
   };
 }
-function syncNfFileWatcher(watcher, bundlerCache) {
+function syncNfFileWatcher(watcher, bundlerCache, linkedDirs = []) {
   const files = [...bundlerCache.keys()].filter((k) => !k.includes("node_modules"));
   if (files.length) watcher.addPaths(files);
+  if (linkedDirs.length) watcher.addPaths(linkedDirs, { poll: true });
 }
 export {
   createNfWatcher,

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

@@ -1,48 +1,64 @@
 import * as fs from "fs";
+import * as path from "path";
 import * as crypto from "crypto";
 import fg from "fast-glob";
 const nodeIo = {
-  readText(path) {
-    return fs.readFileSync(path, "utf-8");
+  readText(path2) {
+    return fs.readFileSync(path2, "utf-8");
   },
-  readBytes(path) {
-    return fs.readFileSync(path);
+  readBytes(path2) {
+    return fs.readFileSync(path2);
   },
-  exists(path) {
-    return fs.existsSync(path);
+  exists(path2) {
+    return fs.existsSync(path2);
   },
-  isFile(path) {
+  isFile(path2) {
     try {
-      return fs.statSync(path).isFile();
+      return fs.statSync(path2).isFile();
     } catch {
       return false;
     }
   },
-  isDirectory(path) {
+  isDirectory(path2) {
     try {
-      return fs.statSync(path).isDirectory();
+      return fs.statSync(path2).isDirectory();
     } catch {
       return false;
     }
   },
-  readDir(path) {
+  readDir(path2) {
     try {
-      return fs.readdirSync(path);
+      return fs.readdirSync(path2);
     } catch {
       return [];
     }
   },
-  writeText(path, data) {
-    fs.writeFileSync(path, data, "utf-8");
+  realpath(path2) {
+    try {
+      return fs.realpathSync(path2);
+    } catch {
+      return path2;
+    }
   },
-  mkdirp(path) {
-    fs.mkdirSync(path, { recursive: true });
+  stat(path2) {
+    try {
+      const s = fs.lstatSync(path2);
+      return { mtimeMs: s.mtimeMs, isSymbolicLink: s.isSymbolicLink() };
+    } catch {
+      return null;
+    }
+  },
+  writeText(path2, data) {
+    fs.writeFileSync(path2, data, "utf-8");
+  },
+  mkdirp(path2) {
+    fs.mkdirSync(path2, { recursive: true });
   },
   copyFile(from, to) {
     fs.copyFileSync(from, to);
   },
-  remove(path) {
-    fs.unlinkSync(path);
+  remove(path2) {
+    fs.unlinkSync(path2);
   },
   globFiles(pattern, opts) {
     return fg.sync(pattern, { cwd: opts.cwd, onlyFiles: true, deep: Infinity });
@@ -54,15 +70,55 @@ const nodeIo = {
       base64: () => sum.digest("base64")
     };
   },
-  watch(path, opts, onEvent) {
+  watch(watchPath, opts, onEvent) {
+    if (opts.poll) return pollWatch(watchPath, opts.recursive, opts.poll.intervalMs, onEvent);
     const watcher = opts.recursive ? fs.watch(
-      path,
+      watchPath,
       { recursive: true },
       (_event, filename) => onEvent(filename ? filename.toString() : null)
-    ) : fs.watch(path, () => onEvent(path));
+    ) : fs.watch(watchPath, () => onEvent(watchPath));
     return { close: () => watcher.close() };
   }
 };
+function pollWatch(root, recursive, intervalMs, onEvent) {
+  const snapshot = () => {
+    const out = /* @__PURE__ */ new Map();
+    const walk = (dir) => {
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (recursive) walk(full);
+        } else {
+          try {
+            out.set(path.relative(root, full), fs.statSync(full).mtimeMs);
+          } catch {
+          }
+        }
+      }
+    };
+    walk(root);
+    return out;
+  };
+  let prev = snapshot();
+  const timer = setInterval(() => {
+    const next = snapshot();
+    for (const [rel, mtime] of next) {
+      if (prev.get(rel) !== mtime) onEvent(rel);
+    }
+    for (const rel of prev.keys()) {
+      if (!next.has(rel)) onEvent(rel);
+    }
+    prev = next;
+  }, intervalMs);
+  timer.unref?.();
+  return { close: () => clearInterval(timer) };
+}
 export {
   nodeIo
 };

package/dist/lib/utils/package/cjs-named-exports.d.ts

@@ -0,0 +1,21 @@
+/** A key is re-exportable only if it is a syntactically valid identifier name. */
+export declare const isIdentifierName: (name: string) => boolean;
+/**
+ * Decides whether a `require()`d CommonJS value needs a synthetic named-export
+ * wrapper, and which names to re-export. UMD/CJS packages (e.g. dayjs) assign
+ * named exports dynamically, invisible to static lexers; enumerating the value
+ * recovers them. ES-module namespaces and `__esModule` interop objects are
+ * skipped — a bundler already exposes those statically.
+ */
+export declare const planCjsWrap: (mod: unknown) => {
+    wrap: boolean;
+    keys: string[];
+};
+/**
+ * Synthetic ESM entry re-exporting the CommonJS default plus each discovered name.
+ * The `export { local as key }` clause lets reserved-word keys (`class`, `default`)
+ * pass without escaping.
+ */
+export declare const buildSyntheticCjsEntry: (importPath: string, keys: string[]) => string;
+/** True when a `require()` failure just means the file was ESM after all. */
+export declare const isEsmInteropError: (err: unknown) => boolean;

package/dist/lib/utils/package/cjs-named-exports.js

@@ -0,0 +1,36 @@
+const isIdentifierName = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+const planCjsWrap = (mod) => {
+  if (mod === null || typeof mod !== "object" && typeof mod !== "function") {
+    return { wrap: false, keys: [] };
+  }
+  if (mod[Symbol.toStringTag] === "Module") {
+    return { wrap: false, keys: [] };
+  }
+  if (mod["__esModule"]) {
+    return { wrap: false, keys: [] };
+  }
+  const keys = Object.keys(mod).filter(
+    (key) => key !== "default" && key !== "__esModule" && isIdentifierName(key)
+  );
+  return { wrap: keys.length > 0, keys };
+};
+const buildSyntheticCjsEntry = (importPath, keys) => {
+  const spec = JSON.stringify(importPath);
+  const lines = [`import _nfDefault from ${spec};`, `export default _nfDefault;`];
+  if (keys.length > 0) {
+    keys.forEach((key, i) => lines.push(`const _nf${i} = _nfDefault[${JSON.stringify(key)}];`));
+    lines.push(`export { ${keys.map((key, i) => `_nf${i} as ${key}`).join(", ")} };`);
+  }
+  return lines.join("\n") + "\n";
+};
+const isEsmInteropError = (err) => {
+  const code = err?.code;
+  if (code === "ERR_REQUIRE_ESM" || code === "ERR_REQUIRE_ASYNC_MODULE") return true;
+  return err instanceof SyntaxError && /Unexpected token 'export'|Cannot use import statement|export|import statement/.test(err.message);
+};
+export {
+  buildSyntheticCjsEntry,
+  isEsmInteropError,
+  isIdentifierName,
+  planCjsWrap
+};

package/dist/lib/utils/package/esm-detection.d.ts

@@ -3,3 +3,16 @@
  * or ambiguous (`undefined`).
  */
 export declare const isESMExport: (e: string) => boolean | undefined;
+export type ModuleFormat = 'esm' | 'cjs' | 'unknown';
+/** Node's format rule keyed on extension alone; `.js` stays ambiguous. */
+export declare const classifyByExtension: (entryPoint: string) => ModuleFormat;
+/** Does the source contain top-level ESM `import`/`export`? Dynamic `import()` is excluded (legal in CJS). */
+export declare const hasEsmSyntax: (source: string) => boolean;
+export declare const isCjsCandidate: (input: {
+    esm?: boolean;
+    entryPoint: string;
+    /** Nearest package.json `type` for an ambiguous `.js`. */
+    packageType?: "module" | "commonjs";
+    /** Lazy source for fallback content sniff; only read for an ambiguous `.js`. */
+    readSource?: () => string;
+}) => boolean;

package/dist/lib/utils/package/esm-detection.js

@@ -5,6 +5,35 @@ const isESMExport = (e) => {
   if (e === "cjs" || e === "commonjs") return false;
   return void 0;
 };
+const classifyByExtension = (entryPoint) => {
+  if (entryPoint.endsWith(".mjs")) return "esm";
+  if (entryPoint.endsWith(".cjs")) return "cjs";
+  if (entryPoint.endsWith(".js")) return "unknown";
+  return "esm";
+};
+const hasEsmSyntax = (source) => {
+  const head = source.slice(0, 16384);
+  const exportStmt = /(?:^|[;\n}])\s*export\s*(?:\{|\*|default\b|const\b|let\b|var\b|function\b|async\b|class\b)/;
+  const importStmt = /(?:^|[;\n}])\s*import\s*(?:[A-Za-z_$]|\{|\*|['"])/;
+  return exportStmt.test(head) || importStmt.test(head);
+};
+const isCjsCandidate = (input) => {
+  if (input.esm === true) return false;
+  const fmt = classifyByExtension(input.entryPoint);
+  if (fmt === "esm") return false;
+  if (fmt === "cjs") return true;
+  if (input.packageType === "module") return false;
+  if (input.readSource) {
+    try {
+      if (hasEsmSyntax(input.readSource())) return false;
+    } catch {
+    }
+  }
+  return true;
+};
 export {
+  classifyByExtension,
+  hasEsmSyntax,
+  isCjsCandidate,
   isESMExport
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "type": "module",
   "license": "MIT",
   "packageManager": "pnpm@11.11.0",
@@ -28,11 +28,11 @@
     "jiti": "^2.6.1",
     "jsdom": "^29.0.0",
     "knip": "^6.20.0",
-    "prettier": "^3.8.1",
+    "prettier": "^3.9.4",
     "tslib": "^2.3.0",
     "typescript": "~6.0.0",
     "typescript-eslint": "^8.61.0",
-    "vite": "^8.0.0",
+    "vite": "^8.1.3",
     "vitest": "^4.0.0"
   },
   "exports": {