@softarc/native-federation-orchestrator 4.7.0 → 4.8.0

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

@@ -1,22 +1,9 @@
+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 versionDemands(version: SharedVersion): SharedVersionMeta[];
-export declare function findVersionForTag(versions: SharedVersion[], tag: string): SharedVersion | undefined;
-export declare function versionEntries(version: SharedVersion): Map<string, SharedVersionMeta>;
-export declare function committedEntries(version: SharedVersion): Map<string, SharedVersionMeta>;
-/**
- * The walk both of those keep the first claim of: which copies of a version may publish a specifier, in basis
- * precedence. Exposed so a caller that models the same fill order without needing the map — the pooling gates
- * ask which build a consumer lands on, per specifier — reads the `servedBy` rule from here instead of
- * restating it. It deliberately does not dedup: the callers do, and this way the walk allocates nothing.
- *
- * `accepts` is for a caller with a further reason to discount a copy (pooling islands one, so it self-serves).
- * Filtering the *result* is not the same thing — that drops the specifier instead of letting the next copy
- * claim it.
- */
-export declare function forEachVersionEntry(version: SharedVersion, accepts: ((remote: SharedVersionMeta) => boolean) | undefined, visit: (entrypoint: string, remote: SharedVersionMeta) => void): void;
+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'>;
-export declare function uncoveredEntrypoints(remote: SharedVersionMeta, covered: Covered): string[];
 export declare function countUncoveredEntrypoints(remote: SharedVersionMeta, covered: Covered): number;
 export {};

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

@@ -0,0 +1,22 @@
+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';
+export type Claim = {
+    external: ExternalName;
+    tag: VersionName;
+    copy: SharedVersionMeta;
+};
+export type ClaimTable = {
+    claims: Map<Specifier, Claim>;
+    duplicates: Set<DeepReadonly<SharedVersion>>;
+    shareClaims: Map<Specifier, Claim>;
+};
+export declare function claimTable(externals: Iterable<readonly [ExternalName, DeepReadonly<SharedExternal>]>, publishes?: (copy: SharedVersionMeta) => boolean): ClaimTable;
+export declare function committedClaims(externals: Iterable<readonly [ExternalName, DeepReadonly<SharedExternal>]>, { shareScope, without }: {
+    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/compatibility.d.ts

@@ -0,0 +1,9 @@
+import type { SharedExternal } from './external.contract';
+import type { SharedVersion, SharedVersionMeta } from './version.contract';
+export type AcceptsTag = (offered: string, ownTag: string, requiredVersion: string) => boolean;
+export declare function createAcceptsTag(isCompatible: (tag: string, requiredVersion: string) => boolean, compare: (a: string, b: string) => number): AcceptsTag;
+export type VersionAcceptance = {
+    accepts: (version: SharedVersion, tag: string) => boolean;
+    objector: (version: SharedVersion, tag: string) => SharedVersionMeta | undefined;
+};
+export declare function versionAcceptance(external: SharedExternal, acceptsTag: AcceptsTag): VersionAcceptance;

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

@@ -1,3 +1,4 @@
+import type { RemoteName } from '../remote/remote-info.contract';
 import type { SharedVersion, ScopedVersion } from './version.contract';
 export type ExternalName = string;
 export type ScopedExternals = Record<string, ScopedExternal>;
@@ -6,6 +7,8 @@ export declare const STRICT_SCOPE = "strict";
 export type SharedExternal = {
     dirty: boolean;
     poolName?: string;
+    poolWinner?: RemoteName;
+    servingBuild?: RemoteName;
     versions: SharedVersion[];
 };
 export type shareScope = Record<string, SharedExternal>;

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

@@ -0,0 +1,9 @@
+import type { RemoteName } from '../remote/remote-info.contract';
+import type { AcceptsTag } from './compatibility';
+import type { SharedVersion, SharedVersionAction, VersionName } from './version.contract';
+export declare const byTag: (compare: (a: VersionName, b: VersionName) => number) => (a: SharedVersion, b: SharedVersion) => number;
+export declare const rowAt: (versions: readonly SharedVersion[], tag: VersionName, action: SharedVersionAction) => SharedVersion | undefined;
+export declare function mergeRows(versions: SharedVersion[], lead?: SharedVersion): SharedVersion[];
+export declare function findVersionForTag(versions: SharedVersion[], tag: string): SharedVersion | undefined;
+export declare function redirectRow(version: SharedVersion, tag: VersionName, acceptsTag: AcceptsTag): SharedVersion[];
+export declare function scopeRemotes(versions: SharedVersion[], remotes: readonly RemoteName[]): SharedVersion[];

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

@@ -0,0 +1,52 @@
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+import type { RemoteName } from '../remote/remote-info.contract';
+import type { AcceptsTag } from './compatibility';
+import type { ExternalName, SharedExternal, shareScope } from './external.contract';
+import { type Specifier } from './specifier';
+import type { SharedVersion, SharedVersionMeta, VersionName } from './version.contract';
+export type ServingBuild = {
+    remote: RemoteName;
+    tag: VersionName;
+};
+export type ServingCandidate = ServingBuild & {
+    host: boolean;
+    downloads: number;
+    fallbacks: number;
+    rootBasis: boolean;
+};
+export type PackageExternals = readonly (readonly [ExternalName, DeepReadonly<SharedExternal>])[];
+type Row = DeepReadonly<SharedVersion>;
+type Placed = {
+    row: Row;
+    copy: DeepReadonly<SharedVersionMeta>;
+};
+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 shareServingCopies(external: SharedExternal, serving: ServingBuild): void;
+export type ServingObjector = {
+    copy: SharedVersionMeta;
+    tag: VersionName;
+};
+export declare function followServingBuild(external: SharedExternal, serving: ServingBuild, accepts: AcceptsTag): {
+    external: SharedExternal;
+    objector?: ServingObjector;
+};
+export declare const servedScopes: (scope: shareScope, strict: boolean) => shareScope[];
+export declare function consumersOf(externals: PackageExternals): Map<RemoteName, Placed[]>;
+type Cost = Pick<ServingCandidate, 'downloads' | 'fallbacks'>;
+export declare function costTable(consumers: Map<RemoteName, Placed[]>, accepts: AcceptsTag): (build: ServingBuild) => Cost;
+export declare function fallbacksOf(externals: PackageExternals, serving: ServingBuild | undefined, accepts: AcceptsTag): RemoteName[];
+export declare function scopeFallbacks(externals: readonly (readonly [ExternalName, SharedExternal])[], serving: ServingBuild | undefined, accepts: AcceptsTag): void;
+export declare function strictObjectorOf(externals: PackageExternals, serving: ServingBuild, accepts: AcceptsTag): (ServingObjector & {
+    external: ExternalName;
+}) | undefined;
+export declare const SCANNED_SURFACES_PER_TAG = 8;
+export declare function loadSplitsPackage(copies: readonly {
+    tag: VersionName;
+    copy: SharedVersionMeta;
+}[], claims: readonly (readonly [Specifier, {
+    tag: VersionName;
+}])[], accepts: AcceptsTag): boolean;
+export {};

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

@@ -0,0 +1,13 @@
+import type { ExternalName } from './external.contract';
+import type { 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 class SpecifierTags extends Map<Specifier, VersionName> {
+    private readonly packages;
+    constructor(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[]>;

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

@@ -13,7 +13,7 @@ export type SharedVersion = Version & {
     remotes: SharedVersionMeta[];
 };
 export type SharedVersionAction = 'skip' | 'scope' | 'share';
-export type PoolCause = 'incompatible' | 'uncovered' | 'torn' | 'unshared';
+export type PoolCause = 'incompatible' | 'uncovered';
 export type SharedVersionMeta = {
     requiredVersion: string;
     strictVersion: boolean;

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

@@ -0,0 +1,20 @@
+import type { ExternalName, RemoteName, VersionName } from '..';
+import { type Specifier, SpecifierTags } from '../externals/specifier';
+import type { PoolMember } from './membership';
+export type Copy = {
+    member: ExternalName;
+    tag: VersionName;
+    requiredVersion: string;
+    strict: boolean;
+    host: boolean;
+    specifiers: Specifier[];
+};
+export type Build = {
+    owner: RemoteName;
+    tags: SpecifierTags;
+    tagByMember: Map<ExternalName, VersionName>;
+    host: boolean;
+};
+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;

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

@@ -0,0 +1,40 @@
+import type { ExternalName, PoolCause, RemoteName, VersionName } from '..';
+import type { AcceptsTag } from '../externals/compatibility';
+import { type Specifier, SpecifierTags } from '../externals/specifier';
+import type { PoolMember } from './membership';
+type ElectionInput = {
+    members: readonly PoolMember[];
+    acceptsTag: AcceptsTag;
+    compare: (a: VersionName, b: VersionName) => number;
+    previousWinner?: RemoteName;
+    latestFirst: boolean;
+};
+export type PoolMiss = {
+    cause: 'incompatible';
+    member: ExternalName;
+    tag: VersionName;
+    strict: boolean;
+} | {
+    cause: 'uncovered';
+    gap: Specifier;
+    unshipped?: true;
+};
+export type Placement = {
+    kind: 'global';
+} | {
+    kind: 'subpool';
+    owner: RemoteName;
+} | {
+    kind: 'self';
+    cause: PoolCause;
+};
+export type Election = {
+    winner: RemoteName;
+    winnerIsHost: boolean;
+    globalTags: SpecifierTags;
+    placements: ReadonlyMap<RemoteName, Placement>;
+    misses: ReadonlyMap<RemoteName, PoolMiss | undefined>;
+};
+export declare function elect(input: ElectionInput): Election;
+export declare function previousWinner(members: PoolMember[]): RemoteName | undefined;
+export {};

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

@@ -0,0 +1,62 @@
+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 Build, type Copy } from './builds';
+import type { PoolMember } from './membership';
+type Served = {
+    tag: VersionName;
+    remote: RemoteName;
+    file: string;
+};
+type CommittedView = {
+    builds: Map<RemoteName, Build>;
+    global: Map<Specifier, Served>;
+    runsOffMap: Map<RemoteName, Map<Specifier, Served>>;
+};
+export type GateMiss = {
+    cause: 'incompatible';
+    specifier: Specifier;
+    tag: VersionName;
+} | {
+    cause: 'uncovered';
+    specifier: Specifier;
+} | {
+    cause: 'uncovered';
+    unshipped: true;
+} | {
+    cause: 'uncovered';
+    owner: RemoteName;
+    specifier: Specifier;
+    tag: VersionName;
+};
+type MapCover = {
+    name: ExternalName;
+    toSkip: boolean;
+    override: Record<Specifier, string>;
+};
+type MapPolicy = {
+    shareScope: string;
+    scopeUrlOf: (remote: RemoteName) => string | undefined;
+};
+export declare function committedView(members: PoolMember[], shipped: ReadonlyMap<RemoteName, readonly Copy[]>, recordOrder: ExternalName[], { shareScope, without }: {
+    shareScope: string;
+    without?: RemoteName;
+}): CommittedView;
+export declare function judgeRemote(copies: readonly Copy[], view: CommittedView, accepts: AcceptsTag): 'global' | GateMiss;
+type Binding = {
+    owner: RemoteName;
+    specifier: Specifier;
+    tag: VersionName;
+};
+export type CoverResult = {
+    covers: MapCover[];
+} | {
+    unmapped: RemoteName;
+} | {
+    gap: Specifier;
+} | {
+    bound: Binding;
+};
+export declare function coverFromMap(remote: RemoteName, mine: readonly PoolMember[], view: CommittedView, actions: Readonly<LoadActions>, policy: MapPolicy): CoverResult;
+export {};

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

@@ -0,0 +1,17 @@
+import type { ExternalName, SharedExternal, shareScope } from '..';
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+export type PoolName = string;
+export type PoolMember = {
+    name: ExternalName;
+    external: DeepReadonly<SharedExternal>;
+};
+export type Membership = {
+    pools: Map<PoolName, PoolMember[]>;
+    labelledAlone: ExternalName[];
+};
+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>;

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

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

package/types/lib/core/1.domain/pooling/pool-state.d.ts

@@ -0,0 +1,4 @@
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+import type { SharedExternal, shareScope } from '../externals/external.contract';
+export declare function hasPoolResults(external: DeepReadonly<SharedExternal>): boolean;
+export declare function scopeHasPoolState(scope: DeepReadonly<shareScope>): boolean;

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

@@ -0,0 +1,16 @@
+import type { DeepReadonly } from '../../../utils/deep-readonly';
+import type { ExternalName, PoolCause, RemoteName, SharedExternal, shareScope, VersionName } from '..';
+import type { Election } from './election';
+import type { PoolMember, PoolName } from './membership';
+export type PlacedPool = Election & {
+    poolName: PoolName;
+};
+export declare function memberRecord(member: PoolMember, pool: PlacedPool, compare: (a: VersionName, b: VersionName) => number): SharedExternal;
+export type CopyMove = {
+    cause: PoolCause;
+} | {
+    fromMap: true;
+};
+export declare function movedRecord(external: SharedExternal, remote: RemoteName, move: CopyMove, compare: (a: VersionName, b: VersionName) => number): SharedExternal;
+export declare function withoutPoolResults(external: DeepReadonly<SharedExternal>): SharedExternal;
+export declare function renamedRecords(scope: shareScope, pools: ReadonlyMap<PoolName, readonly PoolMember[]>): [ExternalName, SharedExternal][];

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

@@ -0,0 +1,6 @@
+import type { AcceptsTag } from '../externals/compatibility';
+import type { Specifier, SpecifierTags } from '../externals/specifier';
+import type { Build, Copy } from './builds';
+export declare function agrees(copies: readonly Copy[], tags: SpecifierTags): boolean;
+export declare function serves(copies: readonly Copy[], tags: SpecifierTags, acceptsTag: AcceptsTag): boolean;
+export declare function unwitnessedGap(copies: readonly Copy[], tags: SpecifierTags, builds: Iterable<Build>): Specifier | undefined;

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

@@ -0,0 +1,4 @@
+import type { SharedInfoActions } from './remote-entry.contract';
+export type LoadActions = Record<string, SharedInfoActions[string] & {
+    covered?: string[];
+}>;

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

@@ -11,7 +11,5 @@ type RemoteEntry = Omit<FederationInfo, 'shared'> & {
 type SharedInfoActions = Record<string, {
     action: SharedVersionAction;
     override?: Record<string, string>;
-    covered?: string[];
-    sameVersion?: boolean;
 }>;
 export { RawRemoteEntry, RemoteEntry, FederationInfo, ExposesInfo, SharedInfo, DenseSharedInfo, SharedInfoActions, };

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

@@ -1,7 +1,6 @@
 export type ModeProfileConfig = {
     latestSharedExternal: boolean;
     skipInvalidExternalVersions: boolean;
-    scopeUncoveredEntrypoints: boolean;
     overrideCachedRemotes: 'always' | 'never' | 'init-only';
     overrideCachedRemotesIfURLMatches: boolean;
     cacheTag?: string;
@@ -15,7 +14,6 @@ export type ModeStrictnessConfig = {
     strictExternalSameVersionCompatibility: boolean;
     strictExternalVersion: boolean;
     strictImportMap: boolean;
-    strictEntryPointCoverage: boolean;
 };
 export type ModeConfig = {
     strict: ModeStrictnessConfig;
@@ -23,7 +21,13 @@ export type ModeConfig = {
     feature: ModeFeatureConfig;
 };
 export type ModeOptions = {
-    strict?: Partial<ModeStrictnessConfig> | boolean;
-    profile?: Partial<ModeProfileConfig>;
+    strict?: (Partial<ModeStrictnessConfig> & {
+        /** @deprecated Removed in 4.8.0 and ignored: a package always runs from one build. */
+        strictEntryPointCoverage?: boolean;
+    }) | boolean;
+    profile?: Partial<ModeProfileConfig> & {
+        /** @deprecated Removed in 4.8.0 and ignored: a package always runs from one build. */
+        scopeUncoveredEntrypoints?: boolean;
+    };
     feature?: Partial<ModeFeatureConfig>;
 };

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

@@ -14,8 +14,13 @@ declare const STORAGE_KEYS: {
     readonly sharedExternals: "shared-externals";
     readonly scopedExternals: "scoped-externals";
     readonly sharedChunks: "shared-chunks";
+    readonly cacheState: "cache-state";
 };
 type StorageKey = (typeof STORAGE_KEYS)[keyof typeof STORAGE_KEYS];
+type CacheState = {
+    version: string;
+    undecidedScopes: string[];
+};
 type StorageEntryHandler = <TValue>(key: string, initialValue: TValue) => StorageEntry<TValue>;
 type StorageConfig = {
     storage: StorageEntryHandler;
@@ -27,4 +32,4 @@ type StorageOptions = {
     storageNamespace?: string;
     exposeStorageGetter?: boolean;
 };
-export { StorageEntry, StorageEntryKey, StorageEntryHandler, StorageConfig, StorageOptions, StorageEntryCreator, StorageType, StorageKey, STORAGE_KEYS, };
+export { StorageEntry, StorageEntryKey, StorageEntryHandler, StorageConfig, StorageOptions, StorageEntryCreator, StorageType, StorageKey, STORAGE_KEYS, CacheState, };

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

@@ -1,8 +1,9 @@
 import type { ForCommittingChanges } from './for-committing-changes.port';
+import type { ForRollingBackChanges } from './for-rolling-back-changes.port';
 import type { ForDeterminingSharedExternals } from './for-determining-shared-externals.port';
 import type { ForPoolingSharedExternals } from './for-pooling-shared-externals.port';
-import type { ForMarkingPoolsForReelection } from './for-marking-pools-for-reelection.port';
 import type { ForPoolingDynamicExternals } from './for-pooling-dynamic-externals.port';
+import type { ForDecidingServingBuilds } from './for-deciding-serving-builds.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';
@@ -15,11 +16,12 @@ import type { DrivingContract } from '../../driving-ports/driving.contract';
 export type InitDriversContract = {
     getRemoteEntries: ForGettingRemoteEntries;
     processRemoteEntries: ForProcessingRemoteEntries;
-    markPoolsForReelection: ForMarkingPoolsForReelection;
     determineSharedExternals: ForDeterminingSharedExternals;
     poolSharedExternals: ForPoolingSharedExternals;
+    decideServingBuilds: ForDecidingServingBuilds;
     generateImportMap: ForGeneratingImportMap;
     commitChanges: ForCommittingChanges;
+    rollbackChanges: ForRollingBackChanges;
     exposeModuleLoader: ForExposingModuleLoader;
     getRemoteEntry: ForGettingRemoteEntry;
     updateCache: ForUpdatingCache;

package/types/lib/core/2.app/driver-ports/init/for-committing-changes.port.d.ts

@@ -2,5 +2,6 @@ import type { ImportMap } from '../../../1.domain/import-map/import-map.contract
 export type CommitOptions = {
     /** Replace the DOM importmap instead of appending a partial one to it. */
     override?: boolean;
+    markUndecided?: boolean;
 };
 export type ForCommittingChanges = (importMap: ImportMap, opts?: CommitOptions) => Promise<void>;

package/types/lib/core/2.app/driver-ports/init/for-deciding-serving-builds.port.d.ts

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

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

@@ -1,8 +1 @@
-import type { ExternalName } from '../../../1.domain';
-/**
- * The externals this pass re-elected, per shareScope. Determine clears `dirty` before pooling runs,
- * so this is the only signal left of what changed; a scope with nothing re-elected is absent rather
- * than empty.
- */
-export type TouchedExternals = ReadonlyMap<string, ReadonlySet<ExternalName>>;
-export type ForDeterminingSharedExternals = () => Promise<TouchedExternals>;
+export type ForDeterminingSharedExternals = () => Promise<void>;

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

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

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

@@ -1,3 +1 @@
-import type { TouchedExternals } from './for-determining-shared-externals.port';
-/** Omitting `touched` means "no signal": every pool is processed, as before W2. */
-export type ForPoolingSharedExternals = (touched?: TouchedExternals) => Promise<void>;
+export type ForPoolingSharedExternals = () => Promise<void>;

package/types/lib/core/2.app/driver-ports/init/for-rolling-back-changes.port.d.ts

@@ -0,0 +1 @@
+export type ForRollingBackChanges = (label: string) => Promise<void>;

package/types/lib/core/2.app/driver-ports/init/for-updating-cache.d.ts

@@ -1,5 +1,6 @@
-import type { RemoteEntry, SharedInfoActions } from '../../../1.domain/remote-entry/remote-entry.contract';
+import type { RemoteEntry } from '../../../1.domain/remote-entry/remote-entry.contract';
+import type { LoadActions } from '../../../1.domain/remote-entry/load-actions.contract';
 export type ForUpdatingCache = (remoteEntries: RemoteEntry) => Promise<{
     entry: RemoteEntry;
-    actions: SharedInfoActions;
+    actions: LoadActions;
 }>;

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

@@ -3,8 +3,10 @@ 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-deciding-serving-builds.port';
 export * from './for-generating-import-map';
 export * from './for-committing-changes.port';
+export * from './for-rolling-back-changes.port';
 export * from './for-exposing-module-loader.port';
 export * from './for-getting-remote-entry.port';
 export * from './for-updating-cache';

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

@@ -8,4 +8,5 @@ export type ForRemoteInfoStorage = {
     addOrUpdate: (remoteName: string, remote: RemoteInfo) => ForRemoteInfoStorage;
     getAll: () => Remotes;
     commit: () => ForRemoteInfoStorage;
+    rollback: () => ForRemoteInfoStorage;
 };

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

@@ -6,4 +6,5 @@ export type ForScopedExternalsStorage = {
     tryGet: (remoteName: string) => Optional<ScopedExternal>;
     getAll: () => ScopedExternals;
     commit: () => ForScopedExternalsStorage;
+    rollback: () => ForScopedExternalsStorage;
 };

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

@@ -3,5 +3,6 @@ export type ForSharedChunksStorage = {
     addOrReplace: (remote: string, bundleName: string, chunks: string[]) => ForSharedChunksStorage;
     remove: (remote: string) => ForSharedChunksStorage;
     commit: () => ForSharedChunksStorage;
+    rollback: () => ForSharedChunksStorage;
     tryGet: (remote: string, bundleName: string) => Optional<string[]>;
 };

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

@@ -9,6 +9,10 @@ export type ForSharedExternalsStorage = {
     scopeType: (shareScope?: string) => 'global' | 'strict' | 'shareScope';
     removeFromAllScopes: (remoteNames: ReadonlySet<RemoteName>) => void;
     addOrUpdate: (name: string, external: SharedExternal, shareScope?: string) => ForSharedExternalsStorage;
-    hasPoolState: (shareScope?: string) => boolean;
+    uncommittedScopes: () => string[];
+    markUndecided: (shareScope: string) => void;
+    isUndecided: (shareScope: string) => boolean;
+    markDecided: (shareScope: string) => void;
     commit: () => ForSharedExternalsStorage;
+    rollback: () => ForSharedExternalsStorage;
 };

package/types/lib/core/2.app/steps/apply-winner.d.ts

@@ -1,18 +1,11 @@
 import type { SharedExternal, SharedVersion, SharedVersionMeta } from '../../1.domain';
+import type { AcceptsTag, VersionAcceptance } from '../../1.domain/externals/compatibility';
 import type { LoggingConfig } from '../config/log.contract';
 import type { ModeConfig } from '../config/mode.contract';
-export type IsCompatible = (tag: string, requiredVersion: string) => boolean;
-export type VersionAcceptance = {
-    accepts: (version: SharedVersion, tag: string) => boolean;
-    objector: (version: SharedVersion, tag: string) => SharedVersionMeta | undefined;
-};
-export declare function versionAcceptance(external: SharedExternal, isCompatible: IsCompatible): VersionAcceptance;
+export declare function rejectIncompatible(config: LoggingConfig, copy: SharedVersionMeta, rejected: string, servedAt: string): never;
 /**
- * The tail of winner election: derive every other version's verdict from the chosen one, apply the
- * entrypoint coverage policy, clear `dirty`. `determine` is the only caller, and passes its memoized
- * `isCompatible` plus the `acceptance` it already built for the election.
- *
- * A hazard for anyone who ever adds a second caller that re-points a winner: `findTears` keys off the
- * winner's merged entries, so moving the winner moves the surface coverage is measured against.
+ * The tail of winner election: derive every other version's verdict from the chosen one, clear `dirty`.
+ * `determine` is the only caller, and passes its `acceptsTag` plus the `acceptance` it already built for
+ * the election.
  */
-export declare function createApplyWinner(config: LoggingConfig & ModeConfig): (externalName: string, external: SharedExternal, winner: SharedVersion, isCompatible: IsCompatible, acceptance?: VersionAcceptance) => SharedExternal;
+export declare function createApplyWinner(config: LoggingConfig & ModeConfig): (externalName: string, external: SharedExternal, winner: SharedVersion, acceptsTag: AcceptsTag, acceptance: VersionAcceptance) => SharedExternal;

package/types/lib/core/2.app/steps/decide-serving-builds.d.ts

@@ -0,0 +1,5 @@
+import type { ForDecidingServingBuilds } from '../driver-ports/init/for-deciding-serving-builds.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 createDecideServingBuilds(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'versionCheck' | 'sharedExternalsRepo'>): ForDecidingServingBuilds;

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

@@ -1,34 +1,5 @@
 import type { ForPoolingSharedExternals } from '../../driver-ports/init/for-pooling-shared-externals.port';
-import type { ExternalName, RemoteName } 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';
-import type { Islanded, PoolMember } from './pool.types';
-/**
- * Per remote, the members it must be served from a build other than that member's own basis — an anchor's,
- * or its own where it is an anchor for somebody else. Absent means the default: the copy resolves through
- * the global mapping, which is right whenever the shared tag is already the remote's own.
- */
-type Served = Map<RemoteName, Map<ExternalName, RemoteName>>;
-/**
- * The no-tear guarantee, checked on what is about to be written rather than argued from the gates: every
- * non-host remote must resolve a `(specifier → tag)` combination that some single build shipped. Which remote
- * serves a tag is free — two builds at one tag are interchangeable providers — so this compares tags only,
- * never origins. A host is never judged: it cannot be repointed onto another build.
- *
- * Keyed by specifier like everything else in the design, not by member: a specifier no copy of the winning
- * version bundles is published from a `skip` copy at that version's tag (`selfFillUncovered`), so a
- * member-level check reads one tag for a package the remote really resolves at two. Copies of the winning
- * tag merging their entrypoints (`mergeVersionEntries`) never do this — one tag, nothing to tear.
- *
- * No portfolio is known to reach a tear through `poolFamily` — the gates leave it true — and it is checked
- * regardless, because it is the one thing pooling exists to prevent and because `rebuildMember`'s last rule
- * (a copy whose member lost its basis self-serves) is decided after gate 2 has stopped looking. Exported so
- * `find-torn-remotes.spec.ts` can pin the contract on hand-built input, the only way to reach it.
- */
-export declare function findTornRemotes(members: PoolMember[], islanded: Islanded, basis: Map<ExternalName, RemoteName>, served: Served, hosts: ReadonlySet<RemoteName>): {
-    remote: RemoteName;
-    combination: string;
-}[];
 export declare function createPoolSharedExternals(config: LoggingConfig & ModeConfig, ports: Pick<DrivingContract, 'sharedExternalsRepo' | 'versionCheck'>): ForPoolingSharedExternals;
-export {};

package/types/lib/core/2.app/steps/rollback-changes.d.ts

@@ -0,0 +1,5 @@
+import type { DrivingContract } from '../driving-ports/driving.contract';
+import type { ForRollingBackChanges } from '../driver-ports/init/for-rolling-back-changes.port';
+import type { LoggingConfig } from '../config/log.contract';
+export declare const createStateDump: (config: LoggingConfig, ports: Pick<DrivingContract, "remoteInfoRepo" | "sharedExternalsRepo" | "scopedExternalsRepo">) => (msg: string) => void;
+export declare function createRollbackChanges(config: LoggingConfig, ports: Pick<DrivingContract, 'remoteInfoRepo' | 'scopedExternalsRepo' | 'sharedExternalsRepo' | 'sharedChunksRepo'>): ForRollingBackChanges;