@softarc/native-federation-orchestrator 4.8.0 → 4.9.0

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

@@ -21,6 +21,7 @@ export type SharedVersionMeta = {
     name: RemoteName;
     bundle?: string;
     pool?: string;
+    dense?: true;
     entries: Record<string, string>;
     servedBy?: RemoteName;
     poolCause?: PoolCause;

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

@@ -1,5 +1,5 @@
 import type { ExternalName, RemoteName, VersionName } from '..';
-import { type Specifier, SpecifierTags } from '../externals/specifier';
+import { type PackageOf, type Specifier, SpecifierTags } from '../externals/specifier';
 import type { PoolMember } from './membership';
 export type Copy = {
     member: ExternalName;
@@ -17,4 +17,4 @@ export type Build = {
 };
 export declare function copiesByRemote(members: readonly PoolMember[]): Map<RemoteName, Copy[]>;
 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-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

@@ -2,8 +2,11 @@ import type { SharedVersionAction } from '../externals/version.contract';
 import type { RemoteEntryUrl } from './manifest.contract';
 import type { 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, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, RemoteSharedInfo, SharedInfoActions, };

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

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

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

@@ -5,9 +5,9 @@ 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.
+ * 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;

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/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/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/utils/union-find.d.ts

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