@softarc/native-federation-orchestrator 4.9.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/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;
@@ -25,4 +26,6 @@ export type SharedVersionMeta = {
     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,4 +1,5 @@
-import type { ExternalName, RemoteName, VersionName } from '..';
+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 = {
@@ -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[], packageOf: PackageOf): Build;

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/remote-entry.contract.d.ts

@@ -1,6 +1,6 @@
 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;
@@ -15,4 +15,4 @@ type SharedInfoActions = Record<string, {
     action: SharedVersionAction;
     override?: Record<string, string>;
 }>;
-export { RawRemoteEntry, RemoteEntry, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, RemoteSharedInfo, 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

@@ -5,6 +5,7 @@ export type ModeProfileConfig = {
     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/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 stored remotes: overridden ones before their replacements are merged in, and ones the manifest
- * doesn't list. Kept out of `storeRemoteEntry` because `removeFromAllScopes` costs a full traversal of the
- * shared-externals graph, so each caller evicts its whole set at once.
- */
 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/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/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/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';