@bleedingdev/modern-js-federation-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/esm/module-federation/native-dev-refresh-runtime-plugin.mjs

@@ -0,0 +1,229 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const LOAD_WITH_CAPTURE = Symbol.for('ultramodern.federation.load-with-capture');
+function nativeDevRefreshRuntimePlugin(options) {
+    if (!options.revisionHeader || !Number.isSafeInteger(options.requestTimeout) || options.requestTimeout <= 0) throw new TypeError('Native federation dev refresh requires a bounded revision probe.');
+    const hosts = new WeakMap();
+    const calls = new AsyncLocalStorage();
+    const probe = (host, lane, expose)=>{
+        if (lane.probe) return lane.probe;
+        const info = lane.info;
+        if (!info) throw new Error('Native federation dev remote has no admitted entry.');
+        const pending = (async ()=>{
+            const init = {
+                method: 'HEAD',
+                cache: 'no-store',
+                signal: AbortSignal.timeout(options.requestTimeout)
+            };
+            let clearDeadline;
+            const signal = init.signal;
+            const deadline = new Promise((_resolve, reject)=>{
+                const abort = ()=>reject(signal.reason);
+                signal.addEventListener('abort', abort, {
+                    once: true
+                });
+                clearDeadline = ()=>signal.removeEventListener('abort', abort);
+            });
+            const request = (async ()=>{
+                const hooked = await host.loaderHook.lifecycle.fetch.emit(info.entry, init, info, {
+                    initiator: 'loadRemote',
+                    id: expose && '.' !== expose ? `${info.name}/${expose.replace(/^\.\//u, '')}` : info.name,
+                    resourceType: 'remoteEntry',
+                    url: info.entry,
+                    expose
+                });
+                const response = hooked instanceof Response ? hooked : await globalThis.fetch(info.entry, init);
+                if (signal.aborted) {
+                    response.body?.cancel().catch(()=>{});
+                    throw signal.reason;
+                }
+                return response;
+            })();
+            let response;
+            try {
+                response = await Promise.race([
+                    request,
+                    deadline
+                ]);
+            } finally{
+                clearDeadline();
+            }
+            response.body?.cancel().catch(()=>{});
+            if (!response.ok) throw Object.assign(new Error(`Native federation dev revision request failed: ${response.status} ${info.entry}`), {
+                status: response.status
+            });
+            const revision = response.headers.get(options.revisionHeader);
+            if (null !== revision && !/^[a-f0-9]{64}$/u.test(revision)) throw new Error('Native federation dev remote returned an invalid graph revision.');
+            if (null === revision && 'string' == typeof lane.revision) throw new Error('Native federation dev remote lost its completed graph revision.');
+            return revision;
+        })();
+        lane.probe = pending;
+        const clear = ()=>{
+            if (lane.probe === pending) lane.probe = void 0;
+        };
+        pending.then(clear, clear);
+        return pending;
+    };
+    return {
+        name: 'ultramodern-native-federation-dev-refresh',
+        beforeInit (args) {
+            const host = args.origin;
+            if (hosts.has(host)) return args;
+            const lanes = new Map(options.remotes.map((remote)=>[
+                    remote.name,
+                    {
+                        remote: {
+                            ...remote
+                        },
+                        active: new Set()
+                    }
+                ]));
+            hosts.set(host, lanes);
+            const load = host.loadRemote.bind(host);
+            const loadWithCapture = async (id, loadOptions, capture)=>{
+                const parent = calls.getStore();
+                const lease = {
+                    host,
+                    ...parent?.host === host ? {
+                        parent
+                    } : {}
+                };
+                return calls.run(lease, async ()=>{
+                    let success = false;
+                    try {
+                        const module = await load(id, loadOptions);
+                        const captured = capture?.(module, lease.resolution);
+                        success = null !== module && true === lease.admitted;
+                        return {
+                            module,
+                            captured
+                        };
+                    } finally{
+                        lease.active = false;
+                        lease.release?.(success);
+                    }
+                });
+            };
+            host.loadRemote = async (id, loadOptions)=>(await loadWithCapture(id, loadOptions)).module;
+            host[LOAD_WITH_CAPTURE] = (id, capture)=>loadWithCapture(id, void 0, capture);
+            return args;
+        },
+        async beforeRequest (args) {
+            const lease = calls.getStore();
+            if (!lease || lease.host !== args.origin) return args;
+            const lane = [
+                ...hosts.get(args.origin)?.values() ?? []
+            ].find(({ remote })=>[
+                    remote.alias,
+                    remote.name
+                ].some((name)=>args.id === name || args.id.startsWith(`${name}/`)));
+            if (!lane || lease.lane) return args;
+            lease.lane = lane;
+            const prefix = [
+                lane.remote.alias,
+                lane.remote.name
+            ].find((name)=>args.id === name || args.id.startsWith(`${name}/`));
+            const expose = args.id === prefix ? '.' : `./${args.id.slice(prefix.length + 1)}`;
+            for(let ancestor = lease.parent; ancestor; ancestor = ancestor.parent)if (ancestor.lane === lane && ancestor.active) {
+                let release;
+                const finished = new Promise((resolve)=>{
+                    release = resolve;
+                });
+                lane.active.add(finished);
+                lease.active = true;
+                lease.snapshot = ancestor.snapshot;
+                lease.release = ()=>{
+                    lane.active.delete(finished);
+                    release();
+                };
+                return args;
+            }
+            for(;;){
+                if (lane.transition) {
+                    await lane.transition;
+                    continue;
+                }
+                const revision = void 0 === lane.revision ? void 0 : null === lane.revision ? null : await probe(args.origin, lane, expose);
+                if (lane.transition) {
+                    await lane.transition;
+                    continue;
+                }
+                let finish;
+                const finished = new Promise((resolve)=>{
+                    finish = resolve;
+                });
+                if (void 0 === lane.revision || revision !== lane.revision) {
+                    lane.transition = finished;
+                    lease.release = (success)=>{
+                        if (success) lane.revision = lane.candidate ?? null;
+                        if (lane.transition === finished) lane.transition = void 0;
+                        finish();
+                    };
+                    while(lane.active.size)await Promise.allSettled([
+                        ...lane.active
+                    ]);
+                    lane.candidate = revision;
+                    if (void 0 !== lane.revision) {
+                        lease.active = true;
+                        lease.snapshot = lane.snapshot;
+                        const retained = new Set();
+                        for (const scope of Object.values(args.origin.shareScopeMap ?? {}))for (const [pkgName, versions] of Object.entries(scope))if (options.shared?.some((key)=>key === pkgName || key.endsWith('/') && pkgName.startsWith(key)) && Object.values(versions).some((shared)=>shared.loaded || shared.loading || shared.lib)) retained.add(pkgName);
+                        for (const pkgName of retained){
+                            if (!args.origin.loadShare) throw new TypeError('Native federation dev refresh requires the host share lifecycle.');
+                            await args.origin.loadShare(pkgName);
+                        }
+                        while(lane.active.size)await Promise.allSettled([
+                            ...lane.active
+                        ]);
+                        args.origin.registerRemotes([
+                            {
+                                ...lane.remote
+                            }
+                        ], {
+                            force: true
+                        });
+                        lease.snapshot = void 0;
+                    }
+                } else {
+                    lane.active.add(finished);
+                    lease.release = ()=>{
+                        lane.active.delete(finished);
+                        finish();
+                    };
+                }
+                lease.active = true;
+                return args;
+            }
+        },
+        loadSnapshot (args) {
+            const lease = calls.getStore();
+            if (!lease || args.options !== lease.host.options || args.moduleInfo.name !== lease.lane?.remote.name) return args;
+            if (void 0 !== lease.snapshot) return {
+                ...args,
+                remoteSnapshot: lease.snapshot
+            };
+            lease.snapshot = args.remoteSnapshot;
+            return args;
+        },
+        afterLoadSnapshot (args) {
+            const lease = calls.getStore();
+            if (lease?.host === args.host && args.moduleInfo.name === lease.lane?.remote.name) lease.snapshot = args.remoteSnapshot;
+            return args;
+        },
+        async afterResolve (args) {
+            const lane = hosts.get(args.origin)?.get(args.remote.name);
+            const lease = calls.getStore();
+            if (!lane || lease?.host !== args.origin || lease.lane !== lane || !lease.active) return args;
+            if (lane.info?.entry !== args.remoteInfo.entry) lane.candidate = void 0;
+            lane.info = args.remoteInfo;
+            if (void 0 === lane.candidate) lane.candidate = await probe(args.origin, lane, args.expose);
+            lease.admitted = true;
+            lane.snapshot = args.remoteSnapshot;
+            lease.resolution = {
+                remoteSnapshot: args.remoteSnapshot,
+                expose: args.expose
+            };
+            return args;
+        }
+    };
+}
+export default nativeDevRefreshRuntimePlugin;

package/dist/esm/module-federation/renderer-contract.mjs

@@ -0,0 +1,103 @@
+import { assertRendererProfileCompatibility, formatBackendFederationValidationErrors, validateRendererIdentity, validateRendererProfile } from "@modern-js/backend-federation-contracts";
+const RENDERER_FEDERATION_METADATA_KEY = 'ultramodernRenderer';
+const RENDERER_FEDERATION_SCHEMA = 'ultramodern.renderer-federation';
+const RENDERER_FEDERATION_SCHEMA_VERSION = 1;
+const rendererFederationError = (message)=>new Error(`Renderer federation manifest contract: ${message}`);
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const exactFields = (value, fields, label)=>{
+    const unknown = Object.keys(value).filter((key)=>!fields.includes(key));
+    const missing = fields.filter((key)=>!Object.hasOwn(value, key));
+    if (unknown.length || missing.length) throw rendererFederationError(`${label} fields differ (unknown=${unknown.join(',')}; missing=${missing.join(',')}).`);
+};
+const assertProfile = (value)=>{
+    const result = validateRendererProfile(value, 'rendererProfile');
+    if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+    const profile = value;
+    return Object.freeze({
+        ...profile,
+        compiler: Object.freeze({
+            ...profile.compiler
+        }),
+        hydration: Object.freeze({
+            ...profile.hydration
+        }),
+        router: Object.freeze({
+            ...profile.router
+        })
+    });
+};
+const assertPackage = (value, profile, label)=>{
+    const result = validateRendererProfile({
+        ...profile,
+        compiler: value
+    }, label);
+    if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+    return Object.freeze({
+        ...value
+    });
+};
+function readRendererFederationCompatibility(value) {
+    if (!record(value)) throw rendererFederationError('the consuming renderer tuple is absent.');
+    exactFields(value, [
+        'profile',
+        'runtime',
+        'bootstrap'
+    ], 'compatibility');
+    const profile = assertProfile(value.profile);
+    return Object.freeze({
+        profile,
+        runtime: assertPackage(value.runtime, profile, 'runtime'),
+        bootstrap: assertPackage(value.bootstrap, profile, 'bootstrap')
+    });
+}
+function readRendererFederationContract(value) {
+    if (!record(value)) throw rendererFederationError('renderer publication metadata is absent.');
+    exactFields(value, [
+        'schema',
+        'schemaVersion',
+        'profile',
+        'runtime',
+        'bootstrap',
+        'identities'
+    ], 'publication');
+    if (value.schema !== RENDERER_FEDERATION_SCHEMA || value.schemaVersion !== RENDERER_FEDERATION_SCHEMA_VERSION) throw rendererFederationError('unsupported renderer publication schema.');
+    const compatibility = readRendererFederationCompatibility({
+        profile: value.profile,
+        runtime: value.runtime,
+        bootstrap: value.bootstrap
+    });
+    if (!record(value.identities) || !Object.keys(value.identities).length) throw rendererFederationError('finalized application entry identities are absent.');
+    const identities = Object.create(null);
+    let appId;
+    for (const [entryName, valueIdentity] of Object.entries(value.identities)){
+        const result = validateRendererIdentity(valueIdentity, `identities.${entryName}`);
+        if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+        const identity = valueIdentity;
+        if (identity.entryName !== entryName || identity.renderer !== compatibility.profile.renderer || identity.protocolVersion !== compatibility.profile.protocolVersion || void 0 !== appId && identity.appId !== appId) throw rendererFederationError(`incoherent publication identity for ${entryName}.`);
+        appId = identity.appId;
+        identities[entryName] = Object.freeze({
+            ...identity
+        });
+    }
+    return Object.freeze({
+        schema: RENDERER_FEDERATION_SCHEMA,
+        schemaVersion: RENDERER_FEDERATION_SCHEMA_VERSION,
+        ...compatibility,
+        identities: Object.freeze(identities)
+    });
+}
+function assertRendererFederationCompatibility(expected, actual) {
+    try {
+        assertRendererProfileCompatibility(expected.profile, actual.profile);
+    } catch (error) {
+        throw rendererFederationError(error instanceof Error ? error.message : String(error));
+    }
+    for (const field of [
+        'runtime',
+        'bootstrap'
+    ])for (const key of [
+        'name',
+        'version'
+    ])if (expected[field][key] !== actual[field][key]) throw rendererFederationError(`${field}.${key} must match the consuming renderer tuple.`);
+}
+export { RENDERER_FEDERATION_METADATA_KEY, RENDERER_FEDERATION_SCHEMA, RENDERER_FEDERATION_SCHEMA_VERSION, assertRendererFederationCompatibility, readRendererFederationCompatibility, readRendererFederationContract, rendererFederationError };

package/dist/esm/module-federation/renderer-runtime-plugin.mjs

@@ -0,0 +1,225 @@
+import { getResourceUrl, isBrowserEnvValue, isReactNativeEnv } from "@module-federation/sdk";
+import { RENDERER_FEDERATION_METADATA_KEY, assertRendererFederationCompatibility, readRendererFederationCompatibility, readRendererFederationContract, rendererFederationError } from "./renderer-contract.mjs";
+const ATTESTATION = Symbol.for('ultramodern.renderer-federation.attestation.v1');
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const coordinates = (snapshot)=>JSON.stringify([
+        'globalName',
+        'buildVersion',
+        'remoteEntry',
+        'remoteEntryType',
+        'ssrRemoteEntry',
+        'ssrRemoteEntryType',
+        'publicPath',
+        'ssrPublicPath',
+        'getPublicPath'
+    ].map((key)=>[
+            key,
+            snapshot[key]
+        ]));
+function attestation(snapshot) {
+    const descriptor = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+    const value = descriptor?.value;
+    if (!descriptor || descriptor.writable || descriptor.configurable || !record(value) || 'string' != typeof value.coordinates || value.coordinates !== coordinates(snapshot)) throw rendererFederationError('cached remote snapshot is missing or has changed its attestation.');
+    return {
+        contract: readRendererFederationContract(value.contract),
+        coordinates: value.coordinates
+    };
+}
+const assertManifestRemote = (remote)=>{
+    if (!record(remote)) throw rendererFederationError('remote registration is absent.');
+    if ('entry' in remote && ('string' != typeof remote.entry || !remote.entry.includes('.json'))) throw rendererFederationError('renderer components require a native JSON manifest remote.');
+};
+function sameFactory(left, right) {
+    if (left === right) return true;
+    if ('function' == typeof left.lib && 'function' == typeof right.lib) return left.lib === right.lib;
+    return 'function' == typeof left.get && left.get === right.get;
+}
+const containerCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName',
+        'buildVersion'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+const entryCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+function rendererShareVersions(expected) {
+    const { profile, runtime, bootstrap } = expected;
+    if ('react' === profile.renderer) return new Map([
+        [
+            'react',
+            runtime.version
+        ],
+        [
+            'react-dom',
+            profile.hydration.version
+        ],
+        [
+            'react-dom/client',
+            profile.hydration.version
+        ],
+        [
+            '@modern-js/runtime',
+            bootstrap.version
+        ]
+    ]);
+    const versions = new Map();
+    for (const [name, version] of [
+        [
+            runtime.name,
+            runtime.version
+        ],
+        [
+            profile.hydration.name,
+            profile.hydration.version
+        ],
+        [
+            bootstrap.name,
+            bootstrap.version
+        ],
+        [
+            profile.router.name,
+            profile.router.version
+        ],
+        [
+            profile.router.coreName,
+            profile.router.coreVersion
+        ]
+    ]){
+        const prior = versions.get(name);
+        if (void 0 !== prior && prior !== version) throw rendererFederationError(`renderer tuple names ${name} with conflicting versions.`);
+        versions.set(name, version);
+    }
+    return versions;
+}
+function createRendererFederationRuntimePlugin(options) {
+    const expected = readRendererFederationCompatibility(options);
+    const selected = new Map();
+    const approvedRemoteInfos = new WeakMap();
+    const observedEntries = new WeakMap();
+    const acceptedEntries = new Set();
+    const versions = rendererShareVersions(expected);
+    const sharedVersion = (name)=>versions.get(name) ?? ('react' === expected.profile.renderer ? void 0 : [
+            ...versions
+        ].find(([owner])=>name.startsWith(`${owner}/`))?.[1]);
+    return {
+        name: 'ultramodern-renderer-federation-contract',
+        beforeRegisterRemote (args) {
+            assertManifestRemote(args.remote);
+            return args;
+        },
+        async afterMatchRemote (args) {
+            if (!args.error) assertManifestRemote(args.remote);
+            return args;
+        },
+        async loadRemoteSnapshot (args) {
+            const snapshot = args.remoteSnapshot;
+            if ('manifest' === args.from) {
+                const manifest = args.manifestJson;
+                const metadata = record(manifest) && record(manifest.metaData) ? manifest.metaData[RENDERER_FEDERATION_METADATA_KEY] : void 0;
+                const contract = readRendererFederationContract(metadata);
+                if (!record(snapshot) || 'string' != typeof snapshot.remoteEntry) throw rendererFederationError('native remote entry coordinates are absent.');
+                const existing = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+                if (existing) {
+                    const prior = attestation(snapshot);
+                    if (JSON.stringify(prior.contract) !== JSON.stringify(contract)) throw rendererFederationError('remote snapshot has conflicting publication ownership.');
+                } else Object.defineProperty(snapshot, ATTESTATION, {
+                    value: Object.freeze({
+                        contract,
+                        coordinates: coordinates(snapshot)
+                    })
+                });
+            } else assertRendererFederationCompatibility(expected, attestation(snapshot).contract);
+            return args;
+        },
+        async afterLoadSnapshot (args) {
+            assertRendererFederationCompatibility(expected, attestation(args.remoteSnapshot).contract);
+            const snapshot = args.remoteSnapshot;
+            const browser = isBrowserEnvValue || isReactNativeEnv() || !('ssrRemoteEntry' in snapshot);
+            const entry = browser ? snapshot.remoteEntry : snapshot.ssrRemoteEntry;
+            if ('string' != typeof entry || !entry) throw rendererFederationError('native projected remote entry is absent.');
+            let entryUrl = getResourceUrl(snapshot, entry);
+            if (!isBrowserEnvValue && !entryUrl.startsWith('http')) entryUrl = `https:${entryUrl}`;
+            acceptedEntries.add(entryCoordinates({
+                name: args.moduleInfo?.name ?? snapshot.globalName,
+                entry: entryUrl,
+                type: browser ? snapshot.remoteEntryType : snapshot.ssrRemoteEntryType || 'global',
+                entryGlobalName: snapshot.globalName
+            }));
+            return args;
+        },
+        async afterResolve (args) {
+            if (!args.remoteSnapshot) throw rendererFederationError('native remote resolution has no attested snapshot.');
+            assertRendererFederationCompatibility(expected, attestation(args.remoteSnapshot).contract);
+            const cached = args.origin.moduleCache.get(args.remote.name);
+            if (cached && (approvedRemoteInfos.get(cached.remoteInfo) !== containerCoordinates(cached.remoteInfo) || containerCoordinates(cached.remoteInfo) !== containerCoordinates(args.remoteInfo))) throw rendererFederationError('cached remote container has unattested or conflicting ownership.');
+            const priorCoordinates = approvedRemoteInfos.get(args.remoteInfo);
+            if (void 0 !== priorCoordinates && priorCoordinates !== containerCoordinates(args.remoteInfo)) throw rendererFederationError('native remote container coordinates changed after attestation.');
+            approvedRemoteInfos.set(args.remoteInfo, containerCoordinates(args.remoteInfo));
+            return args;
+        },
+        loadEntry (args) {
+            if (!acceptedEntries.has(entryCoordinates(args.remoteInfo))) throw rendererFederationError('remote entry coordinates differ from the attested native snapshot.');
+        },
+        async afterLoadEntry (args) {
+            if (args.error && !args.recovered) return args;
+            const binding = containerCoordinates(args.remoteInfo);
+            const entryBinding = entryCoordinates(args.remoteInfo);
+            if (args.cached && approvedRemoteInfos.get(args.remoteInfo) !== binding) throw rendererFederationError('remote entry has no attested native container resolution.');
+            if (!acceptedEntries.has(entryBinding)) throw rendererFederationError('remote entry coordinates differ from the attested native snapshot.');
+            const entry = args.remoteEntryExports;
+            if (('object' != typeof entry || null === entry) && 'function' != typeof entry) throw rendererFederationError('native container exports are absent.');
+            if (args.cached && observedEntries.get(entry) !== entryBinding) throw rendererFederationError('cached native container exports have unattested ownership.');
+            approvedRemoteInfos.set(args.remoteInfo, binding);
+            observedEntries.set(entry, entryBinding);
+            return args;
+        },
+        resolveShare (args) {
+            const version = sharedVersion(args.pkgName);
+            if (void 0 === version) return args;
+            const resolve = args.resolver;
+            return {
+                ...args,
+                resolver () {
+                    const result = resolve();
+                    if (!result) return result;
+                    const shared = result.useTreesShaking && record(result.shared.treeShaking) ? result.shared.treeShaking : result.shared;
+                    if (result.shared.version !== version) throw rendererFederationError(`shared ${args.pkgName} version must be ${version}.`);
+                    const prior = selected.get(args.pkgName);
+                    if (prior && !sameFactory(prior, shared)) throw rendererFederationError(`shared ${args.pkgName} has conflicting runtime ownership.`);
+                    for (const scope of Object.values(args.shareScopeMap))for (const candidate of Object.values(scope[args.pkgName] ?? {})){
+                        const active = record(candidate.treeShaking) && candidate.treeShaking.loaded ? candidate.treeShaking : candidate;
+                        if ((active.loaded || active.lib) && !sameFactory(active, shared)) throw rendererFederationError(`shared ${args.pkgName} has duplicate loaded runtime identities.`);
+                    }
+                    selected.set(args.pkgName, Object.freeze({
+                        lib: shared.lib,
+                        get: shared.get
+                    }));
+                    return result;
+                }
+            };
+        },
+        afterLoadShare (args) {
+            if (void 0 !== sharedVersion(args.pkgName) && args.selectedShared) {
+                const shared = record(args.selectedShared.treeShaking) && args.selectedShared.treeShaking.loaded ? args.selectedShared.treeShaking : args.selectedShared;
+                selected.set(args.pkgName, Object.freeze({
+                    lib: shared.lib,
+                    get: shared.get
+                }));
+            }
+        }
+    };
+}
+const renderer_runtime_plugin = createRendererFederationRuntimePlugin;
+export default renderer_runtime_plugin;
+export { createRendererFederationRuntimePlugin, rendererShareVersions };