@softarc/native-federation-orchestrator 4.8.0 → 4.10.0

package/types/lib/core/1.domain/externals/basis.d.ts

@@ -1,7 +1,7 @@
 import type { DeepReadonly } from '../../../utils/deep-readonly';
 import type { SharedVersion, SharedVersionMeta } from './version.contract';
-export declare function isBetterBasis(candidate: SharedVersionMeta, basis: SharedVersionMeta): boolean;
-export declare function addRemoteToVersion(version: SharedVersion, remote: SharedVersionMeta, isHost?: boolean): void;
+export declare function isBetterBasis(candidate: SharedVersionMeta, basis: SharedVersionMeta, preferDev?: boolean): boolean;
+export declare function addRemoteToVersion(version: SharedVersion, remote: SharedVersionMeta, isHost?: boolean, preferDev?: boolean): void;
 export declare function versionDemands(version: SharedVersion): SharedVersionMeta[];
 export declare function forEachVersionEntry(version: DeepReadonly<SharedVersion>, accepts: ((remote: SharedVersionMeta) => boolean) | undefined, visit: (entrypoint: string, remote: SharedVersionMeta) => void): void;
 type Covered = Pick<ReadonlySet<string>, 'has'>;

package/types/lib/core/1.domain/externals/claims.d.ts

@@ -2,7 +2,7 @@ import type { DeepReadonly } from '../../../utils/deep-readonly';
 import type { RemoteName } from '../remote/remote-info.contract';
 import { type ExternalName, type SharedExternal } from './external.contract';
 import type { SharedVersion, SharedVersionMeta, VersionName } from './version.contract';
-import { type Specifier } from './specifier';
+import type { Specifier } from './specifier';
 export type Claim = {
     external: ExternalName;
     tag: VersionName;
@@ -18,5 +18,4 @@ export declare function committedClaims(externals: Iterable<readonly [ExternalNa
     shareScope: string;
     without?: RemoteName;
 }): Map<Specifier, Claim>;
-export declare const claimsByPackage: (claims: ReadonlyMap<Specifier, Claim>) => Map<ExternalName, [Specifier, Claim][]>;
 export declare function versionClaims(version: DeepReadonly<SharedVersion>, servingBuild: RemoteName | undefined): Map<Specifier, SharedVersionMeta>;

package/types/lib/core/1.domain/externals/serving.d.ts

@@ -23,7 +23,7 @@ type Placed = {
 export declare const byServingRank: (a: ServingCandidate, b: ServingCandidate) => number;
 export declare const packagesOf: (scope: DeepReadonly<shareScope>) => Map<ExternalName, ExternalName[]>;
 export declare const isPooled: (externals: PackageExternals) => boolean;
-export declare function servingBuildOf(externals: PackageExternals, accepts: AcceptsTag): ServingBuild | undefined;
+export declare function servingBuildOf(pkg: ExternalName, externals: PackageExternals, accepts: AcceptsTag): ServingBuild | undefined;
 export declare function shareServingCopies(external: SharedExternal, serving: ServingBuild): void;
 export type ServingObjector = {
     copy: SharedVersionMeta;
@@ -43,7 +43,7 @@ export declare function strictObjectorOf(externals: PackageExternals, serving: S
     external: ExternalName;
 }) | undefined;
 export declare const SCANNED_SURFACES_PER_TAG = 8;
-export declare function loadSplitsPackage(copies: readonly {
+export declare function loadSplitsPackage(pkg: ExternalName, copies: readonly {
     tag: VersionName;
     copy: SharedVersionMeta;
 }[], claims: readonly (readonly [Specifier, {

package/types/lib/core/1.domain/externals/specifier.d.ts

@@ -1,13 +1,18 @@
-import type { ExternalName } from './external.contract';
-import type { VersionName } from './version.contract';
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+import type { ExternalName, shareScope } from './external.contract';
+import type { SharedVersionMeta, VersionName } from './version.contract';
 export type Specifier = string;
-export declare function owningPackage(name: ExternalName): ExternalName | undefined;
-export declare const packageOf: (name: ExternalName) => ExternalName;
+export declare function npmPackageOf(name: ExternalName): ExternalName;
+export type PackageOf = (specifier: Specifier) => ExternalName;
+type StoredCopy = readonly [ExternalName, DeepReadonly<SharedVersionMeta>];
+export declare function packageOfIn(scope: DeepReadonly<shareScope>, loading?: readonly StoredCopy[]): PackageOf;
 export declare class SpecifierTags extends Map<Specifier, VersionName> {
+    private readonly packageOf;
     private readonly packages;
-    constructor(entries?: Iterable<readonly [Specifier, VersionName]>);
+    constructor(packageOf: PackageOf, entries?: Iterable<readonly [Specifier, VersionName]>);
     set(specifier: Specifier, tag: VersionName): this;
     clear(): void;
     pinnedTag(specifier: Specifier): VersionName | undefined;
 }
-export declare function groupByPackage<T>(items: Iterable<T>, nameOf: (item: T) => ExternalName): Map<ExternalName, T[]>;
+export declare function groupByPackage<T>(items: Iterable<T>, nameOf: (item: T) => ExternalName, packageOf: PackageOf): Map<ExternalName, T[]>;
+export {};

package/types/lib/core/1.domain/externals/version.contract.d.ts

@@ -6,6 +6,7 @@ export type Version = {
 export type ScopedVersion = Version & {
     bundle?: string;
     entries: Record<string, string>;
+    preload?: true;
 };
 export type SharedVersion = Version & {
     host: boolean;
@@ -21,7 +22,10 @@ export type SharedVersionMeta = {
     name: RemoteName;
     bundle?: string;
     pool?: string;
+    dense?: true;
     entries: Record<string, string>;
     servedBy?: RemoteName;
     poolCause?: PoolCause;
+    preload?: true;
+    dev?: true;
 };

package/types/lib/core/1.domain/import-map/eager-preloads.d.ts

@@ -0,0 +1,10 @@
+import type { ImportMap } from './import-map.contract';
+export type PreloadCandidate = {
+    scopeUrl: string;
+    entryFiles: string[];
+    bundle?: {
+        name: string;
+        chunkFiles: string[];
+    };
+};
+export declare function eagerPreloadUrls(importMap: ImportMap, candidates: Iterable<PreloadCandidate>): string[];

package/types/lib/core/1.domain/pooling/builds.d.ts

@@ -1,5 +1,6 @@
-import type { ExternalName, RemoteName, VersionName } from '..';
-import { type Specifier, SpecifierTags } from '../externals/specifier';
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+import type { ExternalName, RemoteName, SharedVersion, SharedVersionMeta, VersionName } from '..';
+import { type PackageOf, type Specifier, SpecifierTags } from '../externals/specifier';
 import type { PoolMember } from './membership';
 export type Copy = {
     member: ExternalName;
@@ -16,5 +17,10 @@ export type Build = {
     host: boolean;
 };
 export declare function copiesByRemote(members: readonly PoolMember[]): Map<RemoteName, Copy[]>;
+export type RemoteRecord = DeepReadonly<{
+    version: SharedVersion;
+    meta: SharedVersionMeta;
+}>;
+export declare function recordsByRemote(member: PoolMember): Map<RemoteName, RemoteRecord[]>;
 export declare const specifierCount: (copies: readonly Copy[]) => number;
-export declare function buildOf(owner: RemoteName, copies: readonly Copy[]): Build;
+export declare function buildOf(owner: RemoteName, copies: readonly Copy[], packageOf: PackageOf): Build;

package/types/lib/core/1.domain/pooling/election.d.ts

@@ -1,9 +1,10 @@
 import type { ExternalName, PoolCause, RemoteName, VersionName } from '..';
 import type { AcceptsTag } from '../externals/compatibility';
-import { type Specifier, SpecifierTags } from '../externals/specifier';
+import { type PackageOf, type Specifier, SpecifierTags } from '../externals/specifier';
 import type { PoolMember } from './membership';
 type ElectionInput = {
     members: readonly PoolMember[];
+    packageOf: PackageOf;
     acceptsTag: AcceptsTag;
     compare: (a: VersionName, b: VersionName) => number;
     previousWinner?: RemoteName;

package/types/lib/core/1.domain/pooling/gate.d.ts

@@ -1,7 +1,7 @@
 import { type ExternalName, type RemoteName, type VersionName } from '..';
 import type { LoadActions } from '../remote-entry/load-actions.contract';
 import type { AcceptsTag } from '../externals/compatibility';
-import { type Specifier } from '../externals/specifier';
+import { type PackageOf, type Specifier } from '../externals/specifier';
 import { type Build, type Copy } from './builds';
 import type { PoolMember } from './membership';
 type Served = {
@@ -10,6 +10,7 @@ type Served = {
     file: string;
 };
 type CommittedView = {
+    packageOf: PackageOf;
     builds: Map<RemoteName, Build>;
     global: Map<Specifier, Served>;
     runsOffMap: Map<RemoteName, Map<Specifier, Served>>;
@@ -39,9 +40,10 @@ type MapPolicy = {
     shareScope: string;
     scopeUrlOf: (remote: RemoteName) => string | undefined;
 };
-export declare function committedView(members: PoolMember[], shipped: ReadonlyMap<RemoteName, readonly Copy[]>, recordOrder: ExternalName[], { shareScope, without }: {
+export declare function committedView(members: PoolMember[], shipped: ReadonlyMap<RemoteName, readonly Copy[]>, recordOrder: ExternalName[], { shareScope, without, packageOf, }: {
     shareScope: string;
     without?: RemoteName;
+    packageOf: PackageOf;
 }): CommittedView;
 export declare function judgeRemote(copies: readonly Copy[], view: CommittedView, accepts: AcceptsTag): 'global' | GateMiss;
 type Binding = {

package/types/lib/core/1.domain/pooling/membership.d.ts

@@ -1,4 +1,5 @@
 import type { ExternalName, SharedExternal, shareScope } from '..';
+import { type PackageOf } from '../externals/specifier';
 import type { DeepReadonly } from '../../../utils/deep-readonly';
 export type PoolName = string;
 export type PoolMember = {
@@ -8,10 +9,11 @@ export type PoolMember = {
 export type Membership = {
     pools: Map<PoolName, PoolMember[]>;
     labelledAlone: ExternalName[];
+    packageOf: PackageOf;
 };
 export type LabelledCopy = {
     name: ExternalName;
     pool?: string;
 };
-export declare function buildPools(sharedExternals: DeepReadonly<shareScope>): Membership;
-export declare function pooledPackagesWith(sharedExternals: DeepReadonly<shareScope>, copies: readonly LabelledCopy[]): Set<ExternalName>;
+export declare function buildPools(sharedExternals: DeepReadonly<shareScope>, packageOf?: PackageOf): Membership;
+export declare function pooledPackagesWith(sharedExternals: DeepReadonly<shareScope>, copies: readonly LabelledCopy[], packageOf: PackageOf): Set<ExternalName>;

package/types/lib/core/1.domain/pooling/plan.d.ts

@@ -1,9 +1,11 @@
 import type { ExternalName, SharedExternal, shareScope } from '../externals/external.contract';
 import { type PoolMember, type PoolName } from './membership';
 import type { DeepReadonly } from '../../../utils/deep-readonly';
+import { type PackageOf } from '../externals/specifier';
 export type ElectionPlan = {
     pools: Map<PoolName, PoolMember[]>;
     stripped: Map<ExternalName, SharedExternal>;
     labelledAlone: ExternalName[];
+    packageOf: PackageOf;
 };
 export declare function planElection(scope: DeepReadonly<shareScope>, poolable: boolean): ElectionPlan;

package/types/lib/core/1.domain/remote/remote-module.contract.d.ts

@@ -1,4 +1,5 @@
 export type RemoteModule = {
     moduleName: string;
     file: string;
+    chunks?: string[];
 };

package/types/lib/core/1.domain/remote-entry/mark-dense.d.ts

@@ -0,0 +1,2 @@
+import type { DenseSharedInfo, RemoteSharedInfo, SharedInfo } from './remote-entry.contract';
+export declare function markDense(shared: (SharedInfo | DenseSharedInfo)[]): (SharedInfo | RemoteSharedInfo)[];

package/types/lib/core/1.domain/remote-entry/remote-entry.contract.d.ts

@@ -1,9 +1,12 @@
 import type { SharedVersionAction } from '../externals/version.contract';
 import type { RemoteEntryUrl } from './manifest.contract';
-import type { DenseSharedInfo, ExposesInfo, FederationInfo, SharedInfo } from '@softarc/native-federation/domain';
+import type { ChunkMap, DenseSharedInfo, ExposesInfo, FederationInfo, SharedInfo } from '@softarc/native-federation/domain';
 type RawRemoteEntry = FederationInfo;
+type RemoteSharedInfo = DenseSharedInfo & {
+    dense?: true;
+};
 type RemoteEntry = Omit<FederationInfo, 'shared'> & {
-    shared: DenseSharedInfo[];
+    shared: RemoteSharedInfo[];
     url: RemoteEntryUrl;
     host?: boolean;
     override?: boolean;
@@ -12,4 +15,4 @@ type SharedInfoActions = Record<string, {
     action: SharedVersionAction;
     override?: Record<string, string>;
 }>;
-export { RawRemoteEntry, RemoteEntry, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, SharedInfoActions, };
+export { RawRemoteEntry, RemoteEntry, ChunkMap, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, RemoteSharedInfo, SharedInfoActions, };

package/types/lib/core/2.app/config/import-map.contract.d.ts

@@ -3,19 +3,16 @@ export type ImportMapConfig = {
     loadModuleFn: (url: string) => Promise<unknown>;
     setImportMapFn: SetImportMap;
     reloadBrowserFn: () => void;
+    preloadModulesFn?: PreloadModules;
 };
+export type PreloadModules = (urls: string[]) => void;
 export type SetImportMap = (importMap: ImportMap, opts?: {
     override?: boolean;
 }) => Promise<ImportMap>;
 export type ImportMapOptions = Partial<ImportMapConfig> & {
     /**
-     * Name of the Trusted Types policy used to wrap import-map content and
-     * dynamic-import URLs in the default `setImportMapFn` and `loadModuleFn`.
-     * Pass `false` to disable the policy (e.g. when the host owns its own
-     * Trusted Types pipeline). Defaults to `'nfo'`.
-     *
-     * Has no effect on browsers that do not support Trusted Types — the wrapper
-     * falls back to a transparent pass-through in that case.
+     * Trusted Types policy wrapping the default `setImportMapFn` and `loadModuleFn`; `false` opts out.
+     * Defaults to `'nfo'`. No effect on browsers without Trusted Types.
      */
     trustedTypesPolicyName?: string | false;
 };

package/types/lib/core/2.app/config/index.d.ts

@@ -1,6 +1,6 @@
-export { ImportMapOptions, ImportMapConfig } from './import-map.contract';
+export { ImportMapOptions, ImportMapConfig, PreloadModules } from './import-map.contract';
 export { LoggingOptions, LogLevel, LogType, LoggingConfig, LogHandler, Logger, } from './log.contract';
-export { StorageOptions, StorageEntry, StorageEntryKey, StorageConfig, StorageType, StorageKey, } from './storage.contract';
+export { StorageOptions, StorageEntry, StorageEntryKey, StorageConfig, StorageEntryCreator, StorageEntryHandler, StorageType, StorageKey, } from './storage.contract';
 export { NFOrchestratorGlobal, NFOrchestratorStorageInfo } from './orchestrator-global.contract';
 export { ModeOptions, ModeConfig } from './mode.contract';
 export { HostOptions, HostConfig } from './host.contract';

package/types/lib/core/2.app/config/mode.contract.d.ts

@@ -4,6 +4,8 @@ export type ModeProfileConfig = {
     overrideCachedRemotes: 'always' | 'never' | 'init-only';
     overrideCachedRemotesIfURLMatches: boolean;
     cacheTag?: string;
+    mergeManifests?: boolean;
+    enableDebugging?: boolean;
 };
 export type ModeFeatureConfig = {
     convertFlatSharedInfo: boolean;

package/types/lib/core/2.app/driver-ports/init/flow.contract.d.ts

@@ -1,8 +1,6 @@
 import type { FederationManifest } from '../../../1.domain';
-import type { LoadRemoteModule } from '../../../init-federation.contract';
-export type InitResult = {
-    loadRemoteModule: LoadRemoteModule;
-};
+import type { RemoteModuleAccess } from './for-exposing-module-loader.port';
+export type InitResult = RemoteModuleAccess;
 export type InitFlow = (remotesOrManifestUrl: string | FederationManifest) => Promise<InitResult>;
 export type RemoteRef = string | {
     name?: string;

package/types/lib/core/2.app/driver-ports/init/for-exposing-module-loader.port.d.ts

@@ -1,2 +1,6 @@
-import type { LoadRemoteModule } from '../../../init-federation.contract';
-export type ForExposingModuleLoader = () => Promise<LoadRemoteModule>;
+import type { LoadRemoteModule, PreloadRemoteModule } from '../../../init-federation.contract';
+export type RemoteModuleAccess = {
+    loadRemoteModule: LoadRemoteModule;
+    preloadRemoteModule: PreloadRemoteModule;
+};
+export type ForExposingModuleLoader = () => Promise<RemoteModuleAccess>;

package/types/lib/core/2.app/driving-ports/for-browser-tasks.d.ts

@@ -4,4 +4,5 @@ export type ForBrowserTasks = {
         override?: boolean;
     }) => Promise<ImportMap>;
     importModule: (url: string) => Promise<unknown>;
+    preloadModules?: (urls: string[]) => void;
 };

package/types/lib/core/2.app/driving-ports/for-remote-info-storage.port.d.ts

@@ -5,6 +5,7 @@ export type ForRemoteInfoStorage = {
     tryGet: (remoteName: RemoteName) => Optional<RemoteInfo>;
     remove: (remoteName: RemoteName) => ForRemoteInfoStorage;
     tryGetModule: (remoteName: RemoteName, exposedModule: string) => Optional<string>;
+    getModuleChunkUrls: (remoteName: RemoteName, exposedModule: string) => string[];
     addOrUpdate: (remoteName: string, remote: RemoteInfo) => ForRemoteInfoStorage;
     getAll: () => Remotes;
     commit: () => ForRemoteInfoStorage;

package/types/lib/core/2.app/steps/collect-eager-preloads.d.ts

@@ -0,0 +1,4 @@
+import type { DrivingContract } from '../driving-ports/driving.contract';
+import type { ImportMap } from '../../1.domain';
+export type CollectEagerPreloads = (importMap: ImportMap) => string[];
+export declare function createCollectEagerPreloads(ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'sharedChunksRepo'>): CollectEagerPreloads;

package/types/lib/core/2.app/steps/get-remote-entries.d.ts

@@ -3,4 +3,4 @@ import type { DrivingContract } from '../driving-ports/driving.contract';
 import type { LoggingConfig } from '../config/log.contract';
 import type { ModeConfig } from '../config/mode.contract';
 import type { HostConfig } from '../config/host.contract';
-export declare function createGetRemoteEntries(config: LoggingConfig & ModeConfig & HostConfig, ports: Pick<DrivingContract, 'remoteEntryProvider' | 'manifestProvider' | 'remoteInfoRepo' | 'sse'>): ForGettingRemoteEntries;
+export declare function createGetRemoteEntries(config: LoggingConfig & ModeConfig & HostConfig, ports: Pick<DrivingContract, 'remoteEntryProvider' | 'manifestProvider' | 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'sharedChunksRepo' | 'sse'>): ForGettingRemoteEntries;

package/types/lib/core/2.app/steps/preload-hint.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from '../config/log.contract';
+import type { ForBrowserTasks } from '../driving-ports/for-browser-tasks';
+export type PreloadHint = (collectUrls: () => string[]) => void;
+export declare function createPreloadHint(log: Logger, browser: Pick<ForBrowserTasks, 'preloadModules'>, logStep: number): PreloadHint;

package/types/lib/core/2.app/steps/store-remote-entry.d.ts

@@ -4,11 +4,6 @@ import type { LoggingConfig } from '../config/log.contract';
 import type { ModeConfig } from '../config/mode.contract';
 export type StoreRemoteEntry = (remoteEntry: RemoteEntry, onSharedExternal: SharedExternalHandler) => void;
 export type RemoveCachedRemoteEntries = (remoteNames: ReadonlySet<RemoteName>) => void;
-/**
- * Evict overridden remotes before their replacements are merged in. Kept out of `storeRemoteEntry`
- * because `removeFromAllScopes` costs a full traversal of the shared-externals graph: the init
- * pipeline evicts its whole override set at once, the dynamic pipeline passes a single name.
- */
 export declare function createRemoveCachedRemoteEntries(ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'sharedChunksRepo'>): RemoveCachedRemoteEntries;
 export type SharedExternalHandler = (remoteEntry: RemoteEntry, external: DenseSharedInfo, ctx: SharedExternalContext) => void;
 export type SharedExternalContext = {
@@ -19,13 +14,4 @@ export type SharedExternalContext = {
     assertSameVersionCompatibility: (matchingVersion: SharedVersion) => void;
     write: () => void;
 };
-/**
- * Not a pipeline step but the template both storage steps specialize: it owns the merge sequence
- * for a remoteEntry, and only the resolution of a singleton external differs between the init
- * pipeline (process-remote-entries, step 2) and the dynamic pipeline (update-cache, step 8),
- * injected per call. Evicting an overridden remote is the caller's job, see
- * `createRemoveCachedRemoteEntries` — every entry reaching here is merged additively. The
- * pipelines must not be merged, see docs/version-resolver.md "Dynamic Init". If a change ever
- * needs a flag or parameter here to serve only one caller, inline this back into the steps instead.
- */
 export declare function createStoreRemoteEntry(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'sharedChunksRepo' | 'versionCheck'>, logStep: number): StoreRemoteEntry;

package/types/lib/core/3.adapters/remote-entry/normalize-remote-entry.d.ts

@@ -0,0 +1,4 @@
+import type { RawRemoteEntry, RemoteEntry } from '../../1.domain/remote-entry/remote-entry.contract';
+import type { ModeConfig } from '../../2.app/config/mode.contract';
+declare const normalizeRemoteEntry: (raw: RawRemoteEntry, remoteEntryUrl: string, config: ModeConfig) => RemoteEntry;
+export { normalizeRemoteEntry };

package/types/lib/core/4.config/import-map/index.d.ts

@@ -1,3 +1,5 @@
 export * from './use-import-shim';
 export * from './use-default';
 export * from './replace-in-dom';
+export * from './preload-in-dom';
+export * from './no-preload';

package/types/lib/core/4.config/import-map/no-preload.d.ts

@@ -0,0 +1,2 @@
+import type { PreloadModules } from '../../2.app/config/import-map.contract';
+export declare const noPreload: PreloadModules;

package/types/lib/core/4.config/import-map/preload-in-dom.d.ts

@@ -0,0 +1,2 @@
+import type { PreloadModules } from '../../2.app/config/import-map.contract';
+export declare const preloadInDOM: (rel: "modulepreload" | "modulepreload-shim") => PreloadModules;

package/types/lib/core/4.config/storage/storage.config.d.ts

@@ -1,2 +1,3 @@
 import { type StorageConfig, type StorageOptions } from '../../2.app/config/storage.contract';
-export declare const createStorageConfig: (override: StorageOptions) => StorageConfig;
+import type { LogHandler } from '../../2.app/config/log.contract';
+export declare const createStorageConfig: (override: StorageOptions, log: LogHandler) => StorageConfig;

package/types/lib/core/5.di/federation-result.factory.d.ts

@@ -1,12 +1,13 @@
 import type { ConfigContract } from '../2.app/config/config.contract';
 import type { DrivingContract } from '../2.app/driving-ports/driving.contract';
 import type { InitRemoteEntryFlow } from '../2.app/driver-ports/init/flow.contract';
-import type { LoadRemoteModule, NativeFederationResult } from '../init-federation.contract';
+import type { LoadRemoteModule, NativeFederationResult, PreloadRemoteModule } from '../init-federation.contract';
 export { createStateDump } from '../2.app/steps/rollback-changes';
-export declare const createFederationResult: ({ config, adapters, loadRemoteModule, initRemoteEntryFlow, afterInitRemoteEntry, }: {
+export declare const createFederationResult: ({ config, adapters, loadRemoteModule, preloadRemoteModule, initRemoteEntryFlow, afterInitRemoteEntry, }: {
     config: ConfigContract;
     adapters: DrivingContract;
     loadRemoteModule: LoadRemoteModule;
+    preloadRemoteModule?: PreloadRemoteModule;
     initRemoteEntryFlow: InitRemoteEntryFlow;
     afterInitRemoteEntry?: () => Promise<unknown>;
 }) => NativeFederationResult;

package/types/lib/core/init-federation.contract.d.ts

@@ -2,12 +2,14 @@ import type { ConfigContract } from './2.app/config/config.contract';
 import type { DrivingContract } from './2.app/driving-ports/driving.contract';
 import type { DynamicInitResult } from './2.app/driver-ports/init/flow.contract';
 export type LoadRemoteModule = <TModule = unknown>(remoteName: string, exposedModule: string) => Promise<TModule>;
+export type PreloadRemoteModule = (remoteName: string, exposedModule: string) => void;
 export type LoadRemoteModuleOf<TModule> = (remoteName: string, exposedModule: string) => Promise<TModule>;
 export type NativeFederationResult = DynamicInitResult<{
     config: ConfigContract;
     adapters: DrivingContract;
     loadRemoteModule: LoadRemoteModule;
     load: LoadRemoteModule;
+    preloadRemoteModule: PreloadRemoteModule;
     as: <TModule = unknown>() => {
         loadRemoteModule: LoadRemoteModuleOf<TModule>;
         load: LoadRemoteModuleOf<TModule>;

package/types/lib/index.d.ts

@@ -1,6 +1,6 @@
 export { initFederation } from './core/init-federation';
 export { NFError } from './core/native-federation.error';
-export { LoadRemoteModule, LoadRemoteModuleOf, NativeFederationResult, } from './core/init-federation.contract';
+export { LoadRemoteModule, LoadRemoteModuleOf, NativeFederationResult, PreloadRemoteModule, } from './core/init-federation.contract';
 export { FederationManifest } from './core/1.domain/remote-entry/manifest.contract';
 export { createConfigHandlers } from './core/5.di/config.factory';
 export { createDriving } from './core/5.di/driving.factory';

package/types/lib/node/adapters/fs-remote-entry-provider.d.ts

@@ -1,3 +1,4 @@
+import type { ModeConfig } from '../../core/2.app/config/mode.contract';
 import type { ForProvidingRemoteEntries } from '../../core/2.app/driving-ports/for-providing-remote-entries.port';
-declare const createFsRemoteEntryProvider: () => ForProvidingRemoteEntries;
+declare const createFsRemoteEntryProvider: (config: ModeConfig) => ForProvidingRemoteEntries;
 export { createFsRemoteEntryProvider };

package/types/lib/node/init-federation.node.d.ts

@@ -18,13 +18,8 @@ export type InitNodeFederationOptions = NFOptions & {
      * - **`{ include, exclude }`** — auto-derive, filtered by exact/prefix match,
      *   e.g. `{ include: ['@angular/', 'rxjs', 'zone.js'] }`.
      *
-     * This is an escape hatch that bypasses the version resolver, the import map,
-     * and integrity checks entirely. Exports are value snapshots, not live
-     * bindings — fine for packages whose exports are stable refs (Angular's
-     * classes/functions), not for packages that reassign their exports after init.
-     *
-     * Omit in production: with no `hostInstances`, nothing is published and the
-     * loader never routes to the bridge — resolution is import-map only.
+     * Bypasses the version resolver, the import map and integrity checks. Exports are value snapshots, not
+     * live bindings, so not for packages that reassign their exports after init. Omit in production.
      */
     hostInstances?: HostInstancesOption;
 };

package/types/lib/node.index.d.ts

@@ -1,5 +1,5 @@
 export { initNodeFederation } from './node/init-federation.node';
 export type { InitNodeFederationOptions, HostInstancesOption, HostInstancesAuto, } from './node/init-federation.node';
 export { NFError } from './core/native-federation.error';
-export type { LoadRemoteModule, LoadRemoteModuleOf, NativeFederationResult, } from './core/init-federation.contract';
+export type { LoadRemoteModule, LoadRemoteModuleOf, NativeFederationResult, PreloadRemoteModule, } from './core/init-federation.contract';
 export type { FederationManifest } from './core/1.domain/remote-entry/manifest.contract';

package/types/lib/utils/union-find.d.ts

@@ -0,0 +1,4 @@
+export declare function unionFind(): {
+    find: (node: string) => string;
+    union: (a: string, b: string) => void;
+};