@softarc/native-federation-orchestrator 4.4.1 → 4.5.0

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

@@ -4,8 +4,8 @@ export type Version = {
     tag: VersionName;
 };
 export type ScopedVersion = Version & {
-    file: string;
     bundle?: string;
+    entries: Record<string, string>;
 };
 export type SharedVersion = Version & {
     host: boolean;
@@ -14,10 +14,11 @@ export type SharedVersion = Version & {
 };
 export type SharedVersionAction = 'skip' | 'scope' | 'share';
 export type SharedVersionMeta = {
-    file: string;
     requiredVersion: string;
     strictVersion: boolean;
     cached: boolean;
     name: RemoteName;
     bundle?: string;
+    pool?: string;
+    entries: Record<string, string>;
 };

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

@@ -1,13 +1,17 @@
 import type { SharedVersionAction } from '../externals/version.contract';
 import type { RemoteEntryUrl } from './manifest.contract';
-import type { ExposesInfo, FederationInfo, SharedInfo } from '@softarc/native-federation/domain';
-type RemoteEntry = FederationInfo & {
+import type { DenseSharedInfo, ExposesInfo, FederationInfo, SharedInfo } from '@softarc/native-federation/domain';
+type RawRemoteEntry = FederationInfo;
+type RemoteEntry = Omit<FederationInfo, 'shared'> & {
+    shared: DenseSharedInfo[];
     url: RemoteEntryUrl;
     host?: boolean;
     override?: boolean;
 };
+declare function toDenseSharedInfoFormat(shared: Array<SharedInfo | DenseSharedInfo>): DenseSharedInfo[];
+declare function densifyExternals(shared: Array<SharedInfo | DenseSharedInfo>): Array<SharedInfo | DenseSharedInfo>;
 type SharedInfoActions = Record<string, {
     action: SharedVersionAction;
-    override?: string;
+    override?: Record<string, string>;
 }>;
-export { RemoteEntry, FederationInfo, ExposesInfo, SharedInfo, SharedInfoActions };
+export { RawRemoteEntry, RemoteEntry, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, SharedInfoActions, toDenseSharedInfoFormat, densifyExternals, };

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

@@ -5,6 +5,10 @@ export type ModeProfileConfig = {
     overrideCachedRemotesIfURLMatches: boolean;
     cacheTag?: string;
 };
+export type ModeFeatureConfig = {
+    convertFlatSharedInfo: boolean;
+    useAutoExternalPooling: boolean;
+};
 export type ModeStrictnessConfig = {
     strictRemoteEntry: boolean;
     strictExternalCompatibility: boolean;
@@ -15,8 +19,10 @@ export type ModeStrictnessConfig = {
 export type ModeConfig = {
     strict: ModeStrictnessConfig;
     profile: ModeProfileConfig;
+    feature: ModeFeatureConfig;
 };
 export type ModeOptions = {
     strict?: Partial<ModeStrictnessConfig> | boolean;
     profile?: Partial<ModeProfileConfig>;
+    feature?: Partial<ModeFeatureConfig>;
 };

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

@@ -1,5 +1,7 @@
 import type { ForCommittingChanges } from './for-committing-changes.port';
 import type { ForDeterminingSharedExternals } from './for-determining-shared-externals.port';
+import type { ForPoolingSharedExternals } from './for-pooling-shared-externals.port';
+import type { ForPoolingDynamicExternals } from './for-pooling-dynamic-externals.port';
 import type { ForExposingModuleLoader } from './for-exposing-module-loader.port';
 import type { ForGeneratingImportMap } from './for-generating-import-map';
 import type { ForGettingRemoteEntries } from './for-getting-remote-entries.port';
@@ -13,11 +15,13 @@ export type InitDriversContract = {
     getRemoteEntries: ForGettingRemoteEntries;
     processRemoteEntries: ForProcessingRemoteEntries;
     determineSharedExternals: ForDeterminingSharedExternals;
+    poolSharedExternals: ForPoolingSharedExternals;
     generateImportMap: ForGeneratingImportMap;
     commitChanges: ForCommittingChanges;
     exposeModuleLoader: ForExposingModuleLoader;
     getRemoteEntry: ForGettingRemoteEntry;
     updateCache: ForUpdatingCache;
+    poolDynamicExternals: ForPoolingDynamicExternals;
     convertToImportMap: ForConvertingToImportMap;
 };
 export type InitDriversFactory = (config: ConfigContract, adapters: DrivingContract) => InitDriversContract;

package/types/lib/core/2.app/driver-ports/init/for-pooling-dynamic-externals.port.d.ts

@@ -0,0 +1,8 @@
+import type { RemoteEntry, SharedInfoActions } from '../../../1.domain';
+export type ForPoolingDynamicExternals = (input: {
+    entry: RemoteEntry;
+    actions: SharedInfoActions;
+}) => Promise<{
+    entry: RemoteEntry;
+    actions: SharedInfoActions;
+}>;

package/types/lib/core/2.app/driver-ports/init/for-pooling-shared-externals.port.d.ts

@@ -0,0 +1 @@
+export type ForPoolingSharedExternals = () => Promise<void>;

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

@@ -1,6 +1,8 @@
 export * from './for-getting-remote-entries.port';
 export * from './for-processing-remote-entries.port';
 export * from './for-determining-shared-externals.port';
+export * from './for-pooling-shared-externals.port';
+export * from './for-pooling-dynamic-externals.port';
 export * from './for-generating-import-map';
 export * from './for-committing-changes.port';
 export * from './for-exposing-module-loader.port';

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

@@ -9,5 +9,7 @@ export type ForSharedExternalsStorage = {
     scopeType: (shareScope?: string) => 'global' | 'strict' | 'shareScope';
     removeFromAllScopes: (remoteName: RemoteName) => void;
     addOrUpdate: (name: string, external: SharedExternal, shareScope?: string) => ForSharedExternalsStorage;
+    markPoolTagPresent: () => void;
+    hasPoolTag: () => boolean;
     commit: () => ForSharedExternalsStorage;
 };

package/types/lib/core/2.app/steps/convert-to-import-map.d.ts

@@ -1,4 +1,5 @@
 import type { LoggingConfig } from '../config/log.contract';
+import type { ModeConfig } from '../config/mode.contract';
 import type { ForConvertingToImportMap } from '../driver-ports/init/for-converting-to-import-map';
 import type { DrivingContract } from '../driving-ports/driving.contract';
-export declare function createConvertToImportMap({ log }: LoggingConfig, ports: Pick<DrivingContract, 'sharedChunksRepo'>): ForConvertingToImportMap;
+export declare function createConvertToImportMap(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'sharedChunksRepo'>): ForConvertingToImportMap;

package/types/lib/core/2.app/steps/pooling/pool-dynamic-externals.d.ts

@@ -0,0 +1,3 @@
+import type { ForPoolingDynamicExternals } from '../../driver-ports/init/for-pooling-dynamic-externals.port';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createPoolDynamicExternals(config: ModeConfig): ForPoolingDynamicExternals;

package/types/lib/core/2.app/steps/pooling/pool-graph.d.ts

@@ -0,0 +1,25 @@
+import type { ExternalName, shareScope } from '../../../1.domain';
+import type { LogHandler } from '../../config/log.contract';
+import type { PoolMember, PoolName } from './pool.types';
+export type PoolEdge = {
+    remote: string;
+    tag: string;
+};
+export type PoolCandidate<T> = {
+    name: ExternalName;
+    scope?: string;
+    tags: readonly PoolEdge[];
+    value: T;
+};
+export declare function autoScope(name: string, useAutoExternalPooling: boolean): string | undefined;
+/**
+ * Group one shareScope's candidates into pools by shared membership: pool = connected component of a
+ * graph with edges from auto-pooling (`external -> scope`, global) and declared tags
+ * (`external -> tag@remote`, remote-local). See docs/version-resolver.md + plan.md. Returns only real
+ * pools (>=2 members), keyed by and iterated in order of their canonical name (smallest member —
+ * reload-stable). An explicit-tag member that pooled with nothing is warned (likely typo or missing
+ * sibling); auto-scope singletons stay silent.
+ */
+export declare function groupByMembership<T>(candidates: readonly PoolCandidate<T>[], log?: LogHandler): Map<PoolName, T[]>;
+/** Init-path grouping: build candidates from the stored shared externals of one shareScope. */
+export declare function buildPools(sharedExternals: shareScope, useAutoExternalPooling: boolean, log?: LogHandler): Map<PoolName, PoolMember[]>;

package/types/lib/core/2.app/steps/pooling/pool-shared-externals.d.ts

@@ -0,0 +1,5 @@
+import type { ForPoolingSharedExternals } from '../../driver-ports/init/for-pooling-shared-externals.port';
+import type { DrivingContract } from '../../driving-ports/driving.contract';
+import type { LoggingConfig } from '../../config/log.contract';
+import type { ModeConfig } from '../../config/mode.contract';
+export declare function createPoolSharedExternals(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'sharedExternalsRepo'>): ForPoolingSharedExternals;

package/types/lib/core/2.app/steps/pooling/pool.types.d.ts

@@ -0,0 +1,25 @@
+import type { ExternalName, RemoteName, SharedExternal, VersionName } from '../../../1.domain';
+export type PoolName = string;
+export type PoolMember = {
+    name: ExternalName;
+    external: SharedExternal;
+};
+/**
+ * The remote chosen to serve a whole pool, plus the version tag it provides for each member.
+ * The anchor may be partial: members absent from `tagPerMember` are orphans (no coherent shared
+ * build exists) and resolve scoped-only.
+ */
+export type PoolAnchor = {
+    anchorRemote: RemoteName;
+    tagPerMember: Partial<Record<ExternalName, VersionName>>;
+};
+/**
+ * How a remote is placed relative to the anchor, decided once for the whole pool:
+ *  - `follow`         — every member it uses is compatible with the anchor tag;
+ *  - `scope-incompat` — strict-incompatible on ≥1 member; the whole family scopes with no dedup
+ *                       (deduping would inject a foreign build via a shared intermediary).
+ *                       Dominates `scope-coverage`;
+ *  - `scope-coverage` — compatible where the anchor covers, but uses ≥1 member it does not provide;
+ *                       scoped for coverage, may still dedup same-version members.
+ */
+export type RemoteClassification = 'follow' | 'scope-incompat' | 'scope-coverage';

package/types/lib/core/2.app/steps/pooling/pool.util.d.ts

@@ -0,0 +1,4 @@
+import type { RemoteName, SharedVersion } from '../../../1.domain';
+import type { PoolMember } from './pool.types';
+export declare function versionForRemote(member: PoolMember, remote: RemoteName): SharedVersion | undefined;
+export declare function remotesInPool(members: PoolMember[]): RemoteName[];

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

@@ -1,9 +1,9 @@
-import type { RemoteEntry, SharedExternal, SharedInfo, SharedVersion, SharedVersionMeta } from '../../1.domain';
+import { type RemoteEntry, type SharedExternal, type DenseSharedInfo, type SharedVersion, type SharedVersionMeta } from '../../1.domain';
 import type { DrivingContract } from '../driving-ports/driving.contract';
 import type { LoggingConfig } from '../config/log.contract';
 import type { ModeConfig } from '../config/mode.contract';
 export type StoreRemoteEntry = (remoteEntry: RemoteEntry, onSharedExternal: SharedExternalHandler) => void;
-export type SharedExternalHandler = (remoteEntry: RemoteEntry, external: SharedInfo, ctx: SharedExternalContext) => void;
+export type SharedExternalHandler = (remoteEntry: RemoteEntry, external: DenseSharedInfo, ctx: SharedExternalContext) => void;
 export type SharedExternalContext = {
     tag: string;
     remote: SharedVersionMeta;

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

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