@softarc/native-federation 4.1.3 → 4.2.0

package/dist/lib/core/build/build-result-map.js

@@ -0,0 +1,39 @@
+import path from "path";
+function stripHash(fileName) {
+  const start = fileName.lastIndexOf("-");
+  const end = fileName.lastIndexOf(".");
+  if (start < 0 || end < 0 || start > end) return fileName;
+  return fileName.substring(0, start) + fileName.substring(end);
+}
+function createBuildResultMap(buildResult, isHashed, expectedNames = []) {
+  const expected = new Set(expectedNames.map((n) => path.basename(n)));
+  const map = {};
+  for (const item of buildResult) {
+    const resultName = path.basename(item.fileName);
+    const requestName = isHashed && expected.has(stripHash(resultName)) ? stripHash(resultName) : resultName;
+    map[requestName] = item.fileName;
+  }
+  return map;
+}
+function requireEntry(map, key) {
+  const value = map[key];
+  if (value === void 0) {
+    throw new Error(`No build result found for '${key}'.`);
+  }
+  return value;
+}
+function lookupInResultMap(map, requestName) {
+  const key = path.basename(requestName);
+  return path.basename(requireEntry(map, key));
+}
+function popFromResultMap(map, requestName) {
+  const key = path.basename(requestName);
+  const out = requireEntry(map, key);
+  delete map[key];
+  return out;
+}
+export {
+  createBuildResultMap,
+  lookupInResultMap,
+  popFromResultMap
+};

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

@@ -0,0 +1,13 @@
+import type { ArtifactInfo, ExposesInfo, SharedInfo } 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';
+import type { NFBuildAdapter } from '../../domain/core/build-adapter.contract.js';
+export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
+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

@@ -0,0 +1,178 @@
+import path from "path";
+import { createBuildResultMap, popFromResultMap } from "./build-result-map.js";
+import { computeIntegrityMap } from "./compute-integrity.js";
+import { logger } from "../../utils/logger.js";
+import { normalize } from "../../utils/normalize.js";
+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";
+async function bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal) {
+  return bundleExposedAndMappingsCore(
+    { adapter: getBuildAdapter() },
+    config,
+    fedOptions,
+    externals,
+    modifiedFiles,
+    signal
+  );
+}
+async function bundleExposedAndMappingsCore(deps, config, fedOptions, externals, modifiedFiles, signal) {
+  if (signal?.aborted) {
+    throw new AbortedError("[bundle-exposed-and-mappings] Aborted before bundling");
+  }
+  const shared = Object.entries(config.sharedMappings).map(
+    ([entryPoint, mappedImport]) => {
+      return {
+        fileName: entryPoint,
+        outName: mappedImport.replace(/[^A-Za-z0-9]/g, "_") + ".js",
+        key: mappedImport
+      };
+    }
+  );
+  const exposes = Object.entries(config.exposes).map(
+    ([key, expose]) => {
+      const outFilePath = key + ".js";
+      return { fileName: expose.file, outName: outFilePath, key, element: expose.element };
+    }
+  );
+  const entryPoints = [...shared, ...exposes];
+  const hash = !fedOptions.dev;
+  let result;
+  try {
+    if (!modifiedFiles) {
+      await deps.adapter.setup("mapping-or-exposed", {
+        entryPoints,
+        outdir: fedOptions.outputPath,
+        tsConfigPath: fedOptions.tsConfig,
+        external: externals,
+        dev: !!fedOptions.dev,
+        watch: fedOptions.watch,
+        mappedPaths: config.sharedMappings,
+        chunks: config.chunks,
+        hash,
+        optimizedMappings: config.features.ignoreUnusedDeps,
+        isMappingOrExposed: true,
+        cache: fedOptions.federationCache
+      });
+    }
+    result = await deps.adapter.build("mapping-or-exposed", {
+      signal,
+      modifiedFiles
+    });
+    if (signal?.aborted) {
+      throw new AbortedError("[bundle-exposed-and-mappings] Aborted after bundle");
+    }
+  } catch (error) {
+    if (!(error instanceof AbortedError)) {
+      logger.error("Error building federation artifacts");
+    }
+    throw error;
+  }
+  const resultMap = createBuildResultMap(result, hash, [
+    ...shared.map((s) => s.outName),
+    ...exposes.map((e) => e.outName)
+  ]);
+  const sharedResult = [];
+  const entryFiles = [];
+  for (const item of shared) {
+    const distEntryFile = popFromResultMap(resultMap, item.outName);
+    sharedResult.push(
+      toSharedMappingInfo(item.fileName, item.key, path.basename(distEntryFile), config, fedOptions)
+    );
+    entryFiles.push(distEntryFile);
+  }
+  const exposedResult = [];
+  for (const item of exposes) {
+    const distEntryFile = popFromResultMap(resultMap, item.outName);
+    exposedResult.push({
+      key: item.key,
+      outFileName: path.basename(distEntryFile),
+      ...item.element && { element: item.element },
+      dev: !fedOptions.dev ? void 0 : {
+        entryPoint: normalize(path.join(fedOptions.workspaceRoot, item.fileName))
+      }
+    });
+    entryFiles.push(distEntryFile);
+  }
+  Object.keys(resultMap).filter((f) => f.endsWith(".map")).forEach((f) => popFromResultMap(resultMap, f));
+  let exportedChunks = void 0;
+  const chunkPaths = [];
+  if (config.chunks && config.features.denseChunking) {
+    for (const entryFile of entryFiles) rewriteChunkImports(entryFile);
+    chunkPaths.push(...Object.values(resultMap));
+    exportedChunks = {
+      ["mapping-or-exposed"]: chunkPaths.map((chunk) => path.basename(chunk))
+    };
+  }
+  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) : "";
+  return {
+    packageName: mappedImport,
+    outFileName,
+    requiredVersion: mappingVersion.length > 0 ? "~" + mappingVersion : "",
+    singleton: true,
+    strictVersion: config.features.mappingVersion,
+    version: mappingVersion,
+    dev: !fedOptions.dev ? void 0 : {
+      entryPoint: normalize(path.normalize(mappedPath))
+    }
+  };
+}
+function getMappingVersionCore(io, fileName, workspaceRoot) {
+  const resolvedRoot = path.resolve(workspaceRoot);
+  let dir = path.dirname(path.resolve(fileName));
+  while (true) {
+    const candidate = path.join(dir, "package.json");
+    if (io.isFile(candidate)) {
+      try {
+        const json = JSON.parse(io.readText(candidate));
+        if (typeof json.version === "string" && json.version) return json.version;
+      } catch (err) {
+        logger.warn(`[getMappingVersion] Failed to parse ${candidate}: ${err.message}`);
+      }
+    }
+    const parent = path.dirname(dir);
+    if (dir === resolvedRoot || parent === dir) return "";
+    dir = parent;
+  }
+}
+function getMappingVersion(fileName, workspaceRoot) {
+  return getMappingVersionCore(nodeIo, fileName, workspaceRoot);
+}
+export {
+  bundleExposedAndMappings,
+  bundleExposedAndMappingsCore,
+  describeExposed,
+  describeSharedMappings,
+  getMappingVersion,
+  getMappingVersionCore
+};

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

@@ -0,0 +1,34 @@
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+import type { PackageJsonRepository } from '../../domain/utils/package-json.contract.js';
+import type { IntegrityMap, SharedInfo } from '../../domain/core/federation-info.contract.js';
+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';
+export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
+    platform: 'browser' | 'node';
+    bundleName: string;
+    chunks: boolean;
+}): Promise<{
+    externals: SharedInfo[];
+    chunks?: Record<string, string[]>;
+    integrity?: IntegrityMap;
+}>;
+interface BundleSharedDeps {
+    io: IoPort;
+    repo: PackageJsonRepository;
+    adapter: NFBuildAdapter;
+}
+export declare function bundleSharedCore(deps: BundleSharedDeps, sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
+    platform: 'browser' | 'node';
+    bundleName: string;
+    chunks: boolean;
+}): Promise<{
+    externals: SharedInfo[];
+    chunks?: Record<string, string[]>;
+    integrity?: IntegrityMap;
+}>;
+export declare function readBuilderPackageJson(io: IoPort, fromFile: string): string;
+export declare function parseBuilderVersion(packageJson: string): string;
+export declare function calcHashCore(hash: HashPort, hashBase: string): string;
+export {};

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

@@ -0,0 +1,261 @@
+import * as path from "path";
+import {
+  sharedPackageJsonRepository,
+  getPackageInfo
+} from "../../utils/package/package-info.js";
+import { logger } from "../../utils/logger.js";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+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 { computeIntegrityMapCore } from "./compute-integrity.js";
+import { fileURLToPath } from "url";
+import { getBuildAdapter } from "./build-adapter.js";
+async function bundleShared(sharedBundles, config, fedOptions, externals, buildOptions) {
+  return bundleSharedCore(
+    { io: nodeIo, repo: sharedPackageJsonRepository, adapter: getBuildAdapter() },
+    sharedBundles,
+    config,
+    fedOptions,
+    externals,
+    buildOptions
+  );
+}
+async function bundleSharedCore(deps, sharedBundles, config, fedOptions, externals, buildOptions) {
+  const builderPackageJson = readBuilderPackageJson(deps.io, fileURLToPath(import.meta.url));
+  const builderVersion = parseBuilderVersion(builderPackageJson);
+  const checksum = getChecksumCore(
+    deps.io,
+    sharedBundles,
+    fedOptions.dev ? "1" : "0",
+    builderVersion
+  );
+  const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
+  const bundleCache = cacheEntryCore(
+    deps.io,
+    fedOptions.federationCache.cachePath,
+    getFilename(buildOptions.bundleName, fedOptions.dev)
+  );
+  if (fedOptions?.cacheExternalArtifacts) {
+    const cacheMetadata = bundleCache.getMetadata(checksum);
+    if (cacheMetadata) {
+      logger.info(`Checksum of ${buildOptions.bundleName} matched, re-using cached externals.`);
+      bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
+      let integrity2 = cacheMetadata.integrity;
+      if (config.features.integrityHashes && !integrity2) {
+        integrity2 = computeIntegrityMapCore(
+          deps.io,
+          cacheMetadata.files,
+          fedOptions.federationCache.cachePath
+        );
+      }
+      return {
+        externals: cacheMetadata.externals,
+        chunks: cacheMetadata.chunks,
+        integrity: integrity2
+      };
+    }
+  }
+  bundleCache.clear();
+  const inferredPackageInfos = Object.keys(sharedBundles).filter((packageName) => !sharedBundles[packageName]?.packageInfo).map((packageName) => getPackageInfo(packageName, folder, deps.repo)).filter((pi) => !!pi);
+  const configuredPackageInfos = Object.keys(sharedBundles).filter((packageName) => !!sharedBundles[packageName]?.packageInfo).map((packageName) => ({
+    packageName,
+    ...sharedBundles[packageName]?.packageInfo
+  }));
+  const packageInfos = [...inferredPackageInfos, ...configuredPackageInfos];
+  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 fullOutputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
+  const useDefaultExternalList = buildOptions.platform === "browser" && !config.features.ignoreUnusedDeps;
+  const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
+  let bundleResult;
+  try {
+    await deps.adapter.setup(buildOptions.bundleName, {
+      entryPoints,
+      tsConfigPath: fedOptions.tsConfig,
+      external: [...additionalExternals, ...externals],
+      outdir: fedOptions.federationCache.cachePath,
+      mappedPaths: config.sharedMappings,
+      dev: fedOptions.dev,
+      isMappingOrExposed: false,
+      hash: false,
+      chunks: buildOptions.chunks,
+      platform: buildOptions.platform,
+      optimizedMappings: config.features.ignoreUnusedDeps,
+      cache: fedOptions.federationCache
+    });
+    bundleResult = await deps.adapter.build(buildOptions.bundleName);
+    await deps.adapter.dispose(buildOptions.bundleName);
+    const cachedFiles = bundleResult.map((br) => path.basename(br.fileName));
+    const hashEntries = fedOptions.dev ? /* @__PURE__ */ new Set() : new Set(entryPoints.map((ep) => ep.outName));
+    const renamed = rewriteImports(
+      deps.io,
+      cachedFiles,
+      fedOptions.federationCache.cachePath,
+      hashEntries
+    );
+    applyRenames(bundleResult, entryPoints, renamed);
+  } catch (e) {
+    logger.error("Error bundling shared npm package ");
+    if (e instanceof Error) {
+      logger.error(e.message);
+    }
+    logger.error("For more information, run in verbose mode");
+    logger.notice("");
+    logger.notice("");
+    logger.notice("** Important Information: ***");
+    logger.notice("The error message above shows an issue with bundling a node_module.");
+    logger.notice("In most cases this is because you (indirectly) shared a Node.js package,");
+    logger.notice("while Native Federation builds for the browser.");
+    logger.notice(
+      "You can move such packages into devDependencies or skip them in your federation.config.js."
+    );
+    logger.notice("");
+    logger.notice("More Details: https://bit.ly/nf-issue");
+    logger.notice("");
+    logger.notice("");
+    logger.verbose(e);
+    throw e;
+  }
+  const outFileNames = entryPoints.map((ep) => path.join(fullOutputPath, ep.outName));
+  const result = buildResult(packageInfos, sharedBundles, outFileNames);
+  const chunks = bundleResult.filter(
+    (br) => !br.fileName.endsWith(".map") && !result.find((r) => r.outFileName === path.basename(br.fileName))
+  );
+  let exportedChunks = void 0;
+  if (buildOptions.chunks && config.features.denseChunking) {
+    result.forEach((external) => {
+      external.bundle = buildOptions.bundleName;
+    });
+    if (chunks.length > 0) {
+      exportedChunks = { [buildOptions.bundleName]: getChunkFileNames(chunks) };
+    }
+  } else {
+    addChunksToResult(chunks, result);
+  }
+  const persistedFiles = bundleResult.map((r) => r.fileName.split(path.sep).pop() ?? r.fileName);
+  const integrity = config.features.integrityHashes ? computeIntegrityMapCore(deps.io, persistedFiles, fedOptions.federationCache.cachePath) : void 0;
+  bundleCache.persist({
+    checksum,
+    externals: result,
+    files: persistedFiles,
+    chunks: exportedChunks,
+    integrity
+  });
+  bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
+  return { externals: result, chunks: exportedChunks, integrity };
+}
+function rewriteImports(io, cachedFiles, cachePath, hashEntries) {
+  const renamed = /* @__PURE__ */ new Map();
+  for (const file of cachedFiles.filter(isSourceFile)) {
+    const filePath = path.join(cachePath, file);
+    const rewritten = transformChunkImports(io.readText(filePath), file);
+    if (hashEntries.has(file)) {
+      const hashedName = `${file.split(".")[0]}.${calcHashCore(io, rewritten)}.js`;
+      io.writeText(path.join(cachePath, hashedName), rewritten);
+      io.remove(filePath);
+      renamed.set(file, hashedName);
+    } else {
+      io.writeText(filePath, rewritten);
+    }
+  }
+  return renamed;
+}
+function applyRenames(bundleResult, entryPoints, renamed) {
+  if (renamed.size === 0) return;
+  for (const br of bundleResult) {
+    const next = renamed.get(path.basename(br.fileName));
+    if (next) br.fileName = path.join(path.dirname(br.fileName), next);
+  }
+  for (const ep of entryPoints) {
+    const next = renamed.get(ep.outName);
+    if (next) ep.outName = next;
+  }
+}
+function createOutName(io, pi, configState, fedOptions, encName) {
+  const hashBase = pi.version + "_" + pi.entryPoint + "_" + configState;
+  const hash = calcHashCore(io, hashBase);
+  const outName = fedOptions.dev ? `${encName}.${hash}-dev.js` : `${encName}.${hash}.js`;
+  return outName;
+}
+function buildResult(packageInfos, sharedBundles, outFileNames) {
+  return packageInfos.map((pi) => {
+    const shared = sharedBundles[pi.packageName];
+    return {
+      packageName: pi.packageName,
+      outFileName: path.basename(outFileNames.shift() || ""),
+      requiredVersion: shared?.requiredVersion,
+      singleton: shared?.singleton,
+      strictVersion: shared?.strictVersion,
+      version: pi.version,
+      ...shared?.shareScope && { shareScope: shared.shareScope }
+      // TODO: Decide whether/when we need debug infos
+      // dev: !fedOptions.dev
+      //   ? undefined
+      //   : {
+      //       entryPoint: normalize(pi.entryPoint),
+      //     },
+    };
+  });
+}
+function getChunkFileNames(chunks) {
+  return chunks.map((chunk) => path.basename(chunk.fileName));
+}
+function addChunksToResult(chunks, result) {
+  for (const item of chunks) {
+    const fileName = path.basename(item.fileName);
+    result.push({
+      singleton: false,
+      strictVersion: false,
+      // Here, the version does not matter because
+      // a) a chunk split off by the bundler does
+      // not have a version and b) it gets a hash
+      // code as part of the file name to be unique
+      // when requested via a _versioned_ package.
+      //
+      // For the same reason, we don't need to
+      // take care of singleton and strictVersion.
+      version: "0.0.0",
+      requiredVersion: "0.0.0",
+      packageName: toChunkImport(fileName),
+      outFileName: fileName
+      // dev: dev
+      //   ? undefined
+      //   : {
+      //       entryPoint: normalize(fileName),
+      //     },
+    });
+  }
+}
+function readBuilderPackageJson(io, fromFile) {
+  let dir = path.dirname(fromFile);
+  for (; ; ) {
+    const candidate = path.join(dir, "package.json");
+    if (io.exists(candidate)) return io.readText(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir || path.basename(parent) === "node_modules") return "{}";
+    dir = parent;
+  }
+}
+function parseBuilderVersion(packageJson) {
+  try {
+    return JSON.parse(packageJson).version ?? "";
+  } catch {
+    return "";
+  }
+}
+function calcHashCore(hash, hashBase) {
+  return hash.hash("sha256", hashBase).base64().replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "").substring(0, 10);
+}
+export {
+  bundleShared,
+  bundleSharedCore,
+  calcHashCore,
+  parseBuilderVersion,
+  readBuilderPackageJson
+};

package/dist/lib/core/build/compute-integrity.d.ts

@@ -0,0 +1,11 @@
+import type { FileReaderPort, HashPort } from '../../domain/utils/io-port.contract.js';
+import type { IntegrityMap } from '../../domain/core/federation-info.contract.js';
+type IntegrityDeps = FileReaderPort & HashPort;
+/**
+ * Build an SRI map for `files` (resolved against `baseDir`), skipping sourcemaps
+ * and files that no longer exist on disk. Keyed by basename. Must run after any
+ * post-bundle rewriting so the hashes match the final on-disk bytes.
+ */
+export declare function computeIntegrityMapCore(io: IntegrityDeps, files: string[], baseDir: string): IntegrityMap;
+export declare function computeIntegrityMap(files: string[], baseDir: string): IntegrityMap;
+export {};

package/dist/lib/core/build/compute-integrity.js

@@ -0,0 +1,20 @@
+import * as path from "path";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+import { integrityForFileCore } from "../../utils/hash-file.js";
+function computeIntegrityMapCore(io, files, baseDir) {
+  const integrity = {};
+  for (const file of files) {
+    if (file.endsWith(".map")) continue;
+    const fullPath = path.join(baseDir, file);
+    if (!io.exists(fullPath)) continue;
+    integrity[path.basename(file)] = integrityForFileCore(io, fullPath);
+  }
+  return integrity;
+}
+function computeIntegrityMap(files, baseDir) {
+  return computeIntegrityMapCore(nodeIo, files, baseDir);
+}
+export {
+  computeIntegrityMap,
+  computeIntegrityMapCore
+};

package/dist/lib/core/build/default-external-list.js

@@ -0,0 +1,32 @@
+const NODE_PACKAGES = [
+  "assert",
+  "buffer",
+  "child_process",
+  "cluster",
+  "crypto",
+  "dgram",
+  "dns",
+  "events",
+  "fs",
+  "http",
+  "https",
+  "module",
+  "net",
+  "os",
+  "path",
+  "querystring",
+  "readline",
+  "stream",
+  "timers",
+  "tls",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "zlib"
+];
+const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap((p) => [p, "node:" + p]);
+export {
+  DEFAULT_EXTERNAL_LIST
+};

package/dist/lib/core/build/get-externals.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedFederationConfig } from '../../domain/config/federation-config.contract.js';
+export declare function getExternals(config: NormalizedFederationConfig): string[];

package/dist/lib/core/build/get-externals.js

@@ -0,0 +1,9 @@
+function getExternals(config) {
+  const shared = Object.keys(config.shared);
+  const sharedMappings = Object.values(config.sharedMappings);
+  const externals = [...shared, ...sharedMappings, ...config.externals];
+  return externals;
+}
+export {
+  getExternals
+};

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

@@ -0,0 +1,4 @@
+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';
+export declare function rebuildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -0,0 +1,52 @@
+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 { logger } from "../../utils/logger.js";
+import { AbortedError } from "../../utils/errors.js";
+async function rebuildForFederation(config, fedOptions, externals, modifiedFiles, signal) {
+  const federationCache = fedOptions.federationCache;
+  logger.info(`Re-bundling all internal libraries and exposed modules..'`);
+  const start = process.hrtime();
+  const artifactInfo = await bundleExposedAndMappings(
+    config,
+    fedOptions,
+    externals,
+    modifiedFiles,
+    signal
+  );
+  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);
+  return federationInfo;
+}
+export {
+  rebuildForFederation
+};

package/dist/lib/core/build/rewrite-chunk-imports.d.ts

@@ -0,0 +1,5 @@
+import type { FileReaderPort, FileWriterPort } from '../../domain/utils/io-port.contract.js';
+export declare function rewriteChunkImports(filePath: string): void;
+export declare function rewriteChunkImportsCore(io: FileReaderPort & FileWriterPort, filePath: string): void;
+export declare function transformChunkImports(sourceCode: string, fileName: string): string;
+export declare function isSourceFile(fileName: string): boolean;