@bleedingdev/modern-js-federation-runtime 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

package/dist/cjs/module-federation/native-browser-dev-runtime-plugin.js

@@ -0,0 +1,233 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    NATIVE_BROWSER_DEV_BOUNDARY: ()=>NATIVE_BROWSER_DEV_BOUNDARY,
+    createNativeBrowserDevRuntimePlugin: ()=>createNativeBrowserDevRuntimePlugin,
+    hasNativeBrowserDevPublisher: ()=>hasNativeBrowserDevPublisher,
+    readNativeBrowserDevPublication: ()=>readNativeBrowserDevPublication,
+    replaceNativeBrowserDevRemote: ()=>replaceNativeBrowserDevRemote
+});
+const external_native_browser_dev_refresh_js_namespaceObject = require("./native-browser-dev-refresh.js");
+const external_renderer_contract_js_namespaceObject = require("./renderer-contract.js");
+const NATIVE_BROWSER_DEV_BOUNDARY = Symbol.for('ultramodern.federation.browser-dev-boundary.v1');
+const REGISTRY = Symbol.for('ultramodern.federation.browser-dev-routing.v1');
+function registry() {
+    const root = globalThis;
+    if (!root[REGISTRY]) Object.defineProperty(root, REGISTRY, {
+        value: {
+            sources: new WeakMap(),
+            bindings: new Set()
+        }
+    });
+    return root[REGISTRY];
+}
+function firstReference(binding) {
+    const reference = binding.references.values().next().value;
+    if (!reference) throw new Error('Native browser refresh has no mounted boundary owner.');
+    return reference;
+}
+function createNativeBrowserDevRuntimePlugin(options) {
+    return {
+        name: 'ultramodern-native-browser-dev-refresh',
+        beforeInit (args) {
+            const host = args.origin;
+            if (Object.hasOwn(host, NATIVE_BROWSER_DEV_BOUNDARY)) return args;
+            Object.defineProperty(host, NATIVE_BROWSER_DEV_BOUNDARY, {
+                value (id, source, boundary) {
+                    const remote = options.remotes.find((remote)=>id.startsWith(`${remote.alias}/`));
+                    if (!remote) throw new Error(`Native browser refresh has no registered remote for ${id}.`);
+                    const state = registry();
+                    let sources = state.sources.get(source);
+                    if (!sources) state.sources.set(source, sources = new Map());
+                    let binding = sources.get(id);
+                    if (binding && binding.remoteName !== remote.name) throw new Error('Native browser refresh source has conflicting remote ownership.');
+                    if (!binding) {
+                        const references = new Set();
+                        const current = ()=>firstReference(created);
+                        const created = {
+                            id,
+                            remoteName: remote.name,
+                            references,
+                            coordinator: (0, external_native_browser_dev_refresh_js_namespaceObject.createNativeBrowserDevRefresh)({
+                                get host () {
+                                    return current().host;
+                                },
+                                id,
+                                boundary: references,
+                                prepareReplacement () {
+                                    const reference = current();
+                                    return reference.prepare(reference.boundary);
+                                },
+                                createHost: options.createHost
+                            })
+                        };
+                        binding = created;
+                        sources.set(id, binding);
+                        state.bindings.add(binding);
+                    }
+                    const reference = {
+                        host,
+                        remote,
+                        boundary,
+                        prepare: options.prepareReplacement
+                    };
+                    binding.references.add(reference);
+                    const owned = binding;
+                    let released = false;
+                    return ()=>{
+                        if (released) return;
+                        released = true;
+                        owned.references.delete(reference);
+                        if (owned.references.size) return;
+                        sources.delete(id);
+                        state.bindings.delete(owned);
+                        owned.coordinator.dispose();
+                    };
+                }
+            });
+            return args;
+        }
+    };
+}
+async function replaceNativeBrowserDevRemote(graph) {
+    const bindings = [
+        ...registry().bindings
+    ].filter((binding)=>binding.remoteName === graph.remote.name);
+    if (!bindings.length) throw new Error('Native browser refresh has no mounted publisher for this remote.');
+    let committed = 0;
+    try {
+        for (const binding of bindings){
+            await binding.coordinator.replace(graph);
+            committed++;
+        }
+    } catch (error) {
+        if (committed && !(0, external_native_browser_dev_refresh_js_namespaceObject.isNativeBrowserDevCommitError)(error, graph.revision)) throw (0, external_native_browser_dev_refresh_js_namespaceObject.nativeBrowserDevCommitFailure)(graph.revision, error);
+        throw error;
+    }
+    return bindings.length;
+}
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+async function readNativeBrowserDevPublication(remoteName, options) {
+    const binding = [
+        ...registry().bindings
+    ].find((binding)=>binding.remoteName === remoteName);
+    if (!binding) throw new Error('Native browser refresh has no mounted publisher for discovery.');
+    const reference = firstReference(binding);
+    const remote = reference.remote;
+    const host = reference.host;
+    const init = {
+        cache: 'no-store',
+        signal: options.signal
+    };
+    const context = {
+        initiator: 'loadRemote',
+        id: binding.id,
+        resourceType: 'manifest',
+        url: remote.entry
+    };
+    const hook = host.loaderHook?.lifecycle.fetch;
+    const request = (async ()=>{
+        const hooked = await hook?.emit(remote.entry, init, remote, context);
+        const response = hooked instanceof Response ? hooked : await globalThis.fetch(remote.entry, init);
+        if (options.signal.aborted) {
+            response.body?.cancel().catch(()=>{});
+            throw options.signal.reason;
+        }
+        if (!response.ok) {
+            response.body?.cancel().catch(()=>{});
+            throw new Error(`Native browser manifest discovery failed: ${response.status}`);
+        }
+        const manifest = await response.json();
+        const revision = response.headers.get(options.revisionHeader);
+        const links = [
+            ...(response.headers.get('link') ?? '').matchAll(/<([^>]+)>\s*;([^,]*)/gu)
+        ].filter(([, , parameters])=>/\brel\s*=\s*"?ultramodern-completed-graph"?(?:\s|;|$)/u.test(parameters));
+        if (!revision || !/^[a-f0-9]{64}$/u.test(revision) || 1 !== links.length) throw new Error('Native browser manifest has no unique completed graph coordinate.');
+        const entry = new URL(links[0][1], remote.entry);
+        if (![
+            'http:',
+            'https:'
+        ].includes(entry.protocol) || entry.username || entry.password || entry.hash) throw new Error('Native browser completed graph URL is invalid.');
+        const namespace = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(entry.pathname);
+        if (!namespace) throw new Error('Native browser graph is not in the immutable runtime namespace.');
+        const metadata = record(manifest) && record(manifest.metaData) ? manifest.metaData.ultramodernRenderer : void 0;
+        const contract = (0, external_renderer_contract_js_namespaceObject.readRendererFederationContract)(metadata);
+        const buildIds = new Set(Object.values(contract.identities).map((identity)=>identity.buildId));
+        if (1 !== buildIds.size) throw new Error('Native browser graph has conflicting renderer build identities.');
+        return {
+            revision,
+            runtimeHash: namespace[1],
+            buildId: [
+                ...buildIds
+            ][0],
+            remote: {
+                ...remote,
+                entry: entry.href
+            }
+        };
+    })();
+    let removeAbort;
+    const aborted = new Promise((_resolve, reject)=>{
+        const abort = ()=>reject(options.signal.reason);
+        removeAbort = ()=>options.signal.removeEventListener('abort', abort);
+        if (options.signal.aborted) abort();
+        else options.signal.addEventListener('abort', abort, {
+            once: true
+        });
+    });
+    try {
+        return await Promise.race([
+            request,
+            aborted
+        ]);
+    } finally{
+        removeAbort();
+    }
+}
+function hasNativeBrowserDevPublisher(remoteName) {
+    return [
+        ...registry().bindings
+    ].some((binding)=>binding.remoteName === remoteName);
+}
+exports.NATIVE_BROWSER_DEV_BOUNDARY = __webpack_exports__.NATIVE_BROWSER_DEV_BOUNDARY;
+exports.createNativeBrowserDevRuntimePlugin = __webpack_exports__.createNativeBrowserDevRuntimePlugin;
+exports.hasNativeBrowserDevPublisher = __webpack_exports__.hasNativeBrowserDevPublisher;
+exports.readNativeBrowserDevPublication = __webpack_exports__.readNativeBrowserDevPublication;
+exports.replaceNativeBrowserDevRemote = __webpack_exports__.replaceNativeBrowserDevRemote;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NATIVE_BROWSER_DEV_BOUNDARY",
+    "createNativeBrowserDevRuntimePlugin",
+    "hasNativeBrowserDevPublisher",
+    "readNativeBrowserDevPublication",
+    "replaceNativeBrowserDevRemote"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/native-dev-refresh-runtime-plugin.js

@@ -0,0 +1,267 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>nativeDevRefreshRuntimePlugin
+});
+const external_node_async_hooks_namespaceObject = require("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 external_node_async_hooks_namespaceObject.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;
+        }
+    };
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/renderer-runtime-plugin.js

@@ -143,6 +143,9 @@ function createRendererFederationRuntimePlugin(options) {
     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) {
@@ -216,7 +219,7 @@ function createRendererFederationRuntimePlugin(options) {
             return args;
         },
         resolveShare (args) {
-            const version = versions.get(args.pkgName);
+            const version = sharedVersion(args.pkgName);
             if (void 0 === version) return args;
             const resolve = args.resolver;
             return {
@@ -241,7 +244,7 @@ function createRendererFederationRuntimePlugin(options) {
             };
         },
         afterLoadShare (args) {
-            if (versions.has(args.pkgName) && args.selectedShared) {
+            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,