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

package/dist/esm/module-federation/native-browser-dev-client.mjs

@@ -0,0 +1,276 @@
+import { isNativeBrowserDevCommitError } from "./native-browser-dev-refresh.mjs";
+import { hasNativeBrowserDevPublisher, readNativeBrowserDevPublication, replaceNativeBrowserDevRemote } from "./native-browser-dev-runtime-plugin.mjs";
+const CLIENTS = Symbol.for('ultramodern.federation.browser-dev-clients.v1');
+const clients = ()=>{
+    const root = globalThis;
+    if (!root[CLIENTS]) Object.defineProperty(root, CLIENTS, {
+        value: new Map()
+    });
+    return root[CLIENTS];
+};
+function commitClient(remoteName, graph) {
+    const state = clients().get(remoteName);
+    const next = state?.candidates.get(graph.runtimeHash)?.deref();
+    if (!state || !next) throw new Error('Accepted native graph has no matching fresh HMR runtime.');
+    if (state.active === next) return;
+    state.active?.stop();
+    state.active = next;
+    next.start();
+}
+function prepareNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    const candidate = hash && clients().get(remoteName)?.candidates.get(hash)?.deref();
+    if (!candidate) throw new Error('Native graph has no loaded standby HMR runtime.');
+    return candidate.lease();
+}
+function releaseNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    if (!hash) return;
+    const state = clients().get(remoteName);
+    const candidate = state?.candidates.get(hash)?.deref();
+    if (!state || !candidate) return;
+    candidate.releaseStandby();
+}
+function startNativeBrowserDevClient(options) {
+    const state = clients().get(options.remoteName) ?? {
+        candidates: new Map()
+    };
+    clients().set(options.remoteName, state);
+    const initialHash = options.hash();
+    let socket;
+    let ping;
+    let reconnect;
+    let reconnectCount = 0;
+    let lastHash;
+    let running = false;
+    let applying;
+    let lifetime;
+    let removeCustom;
+    const custom = new Map();
+    const queued = [];
+    const leases = new Set();
+    const base = options.serverBase.endsWith('/') ? options.serverBase : `${options.serverBase}/`;
+    const report = (error)=>{
+        console.error('[ultramodern] Native federation development update failed:', error);
+        if (false !== options.config.overlay && ('object' != typeof options.config.overlay || false !== options.config.overlay.errors)) options.overlay()?.create('Native federation update failed', String(error));
+    };
+    const send = (message)=>{
+        if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
+        else queued.push(message);
+    };
+    const errorMessage = (error)=>error instanceof Error ? error.message : String(error);
+    const onError = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: event.message,
+            name: event.error?.name,
+            stack: event.error?.stack
+        });
+    const onRejected = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: `Uncaught (in promise) ${errorMessage(event.reason)}`,
+            name: event.reason?.name,
+            stack: event.reason?.stack
+        });
+    const fullReload = (data)=>{
+        if (!options.liveReload) return;
+        if (data?.path?.endsWith('.html')) {
+            const pathname = decodeURI(location.pathname);
+            const target = base + data.path.slice(1);
+            if (pathname !== target && pathname !== target.slice(0, -5) && !(pathname.endsWith('/') && `${pathname}index.html` === target)) return;
+        }
+        location.reload();
+    };
+    const apply = ()=>{
+        if (!running || applying || !lastHash || lastHash === options.hash()) return;
+        const signal = lifetime.signal;
+        const targetHash = lastHash;
+        applying = (async ()=>{
+            if (hasNativeBrowserDevPublisher(options.remoteName)) {
+                const graph = await readNativeBrowserDevPublication(options.remoteName, {
+                    signal: AbortSignal.any([
+                        signal,
+                        AbortSignal.timeout(3000)
+                    ]),
+                    revisionHeader: options.revisionHeader
+                });
+                if (signal.aborted) throw signal.reason;
+                if (graph.buildId !== options.buildId) {
+                    try {
+                        await replaceNativeBrowserDevRemote(graph);
+                    } catch (error) {
+                        if (running && !signal.aborted && hasNativeBrowserDevPublisher(options.remoteName) && isNativeBrowserDevCommitError(error, graph.revision)) {
+                            state.failure = {
+                                runtimeHash: graph.runtimeHash,
+                                error
+                            };
+                            report(error);
+                            commitClient(options.remoteName, graph);
+                        }
+                        throw error;
+                    }
+                    if (!running || signal.aborted || !hasNativeBrowserDevPublisher(options.remoteName)) return;
+                    commitClient(options.remoteName, graph);
+                    return;
+                }
+            }
+            if (!options.hot) return fullReload();
+            if ('idle' !== options.hot.status()) return;
+            try {
+                const updated = await options.hot.check(true);
+                if (!updated) fullReload();
+            } catch (error) {
+                console.error('[rsbuild] HMR update failed, performing full reload:', error);
+                fullReload();
+            }
+        })().catch((error)=>{
+            if (!signal.aborted) report(error);
+        }).finally(()=>{
+            applying = void 0;
+            if (running && !signal.aborted && lastHash !== targetHash) apply();
+        });
+    };
+    const clearOverlayForBuild = ()=>{
+        if (state.failure) {
+            if (!lastHash || lastHash === state.failure.runtimeHash) return;
+            state.failure = void 0;
+        }
+        options.overlay()?.clear();
+    };
+    const message = (event)=>{
+        let value;
+        try {
+            value = JSON.parse(event.data);
+        } catch (error) {
+            report(error);
+            return;
+        }
+        switch(value.type){
+            case 'hash':
+                lastHash = value.data;
+                break;
+            case 'ok':
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'warnings':
+                for (const warning of value.data?.text ?? [])console.warn(warning);
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'errors':
+                for (const error of value.data?.text ?? [])console.error(error);
+                if (value.data?.html) options.overlay()?.create('Build failed', value.data.html);
+                break;
+            case 'full-reload':
+                fullReload(value.data);
+                break;
+            case 'static-changed':
+                fullReload();
+                break;
+            case 'custom':
+                for (const listener of custom.get(value.data?.event) ?? [])listener(value.data.data);
+                break;
+            case 'resolved-client-error':
+                options.overlay()?.create('Runtime errors', String(value.data?.message ?? ''));
+                break;
+        }
+    };
+    const socketUrl = (fallback)=>{
+        const url = new URL('http://localhost');
+        url.hostname = (fallback ? options.serverHost : options.config.host) || location.hostname;
+        url.port = String((fallback ? options.serverPort : options.config.port) || location.port);
+        url.protocol = options.config.protocol || ('https:' === location.protocol ? 'wss:' : 'ws:');
+        url.pathname = options.config.path;
+        url.searchParams.set('token', options.token);
+        return options.resolveWebSocketUrl?.(url.href) ?? url.href;
+    };
+    const detachSocket = ()=>{
+        clearInterval(ping);
+        ping = void 0;
+        const previous = socket;
+        socket = void 0;
+        if (!previous) return;
+        previous.onopen = previous.onclose = previous.onmessage = previous.onerror = null;
+        previous.close();
+    };
+    const connect = (fallback = false)=>{
+        if (!running) return;
+        socket = new WebSocket(socketUrl(fallback));
+        socket.onopen = ()=>{
+            reconnectCount = 0;
+            ping = setInterval(()=>send({
+                    type: 'ping'
+                }), 30000);
+            for (const item of queued.splice(0))send(item);
+        };
+        socket.onmessage = message;
+        socket.onclose = ()=>{
+            detachSocket();
+            if (!running || reconnectCount >= options.config.reconnect) return;
+            reconnectCount++;
+            reconnect = setTimeout(()=>connect(), 1000 * 1.5 ** reconnectCount);
+        };
+        socket.onerror = ()=>{
+            if (options.resolveWebSocketUrl || fallback || socketUrl(false) === socketUrl(true)) return;
+            detachSocket();
+            connect(true);
+        };
+    };
+    const client = {
+        arm () {
+            removeCustom ??= options.installCustomListeners(custom);
+        },
+        lease () {
+            const lease = {};
+            leases.add(lease);
+            client.arm();
+            return ()=>{
+                if (!leases.delete(lease)) return;
+                client.releaseStandby();
+            };
+        },
+        releaseStandby () {
+            if (state.active !== client && !leases.size) client.stop();
+        },
+        start () {
+            if (running) return;
+            running = true;
+            lifetime = new AbortController();
+            client.arm();
+            if (options.browserLogs) {
+                window.addEventListener('error', onError);
+                window.addEventListener('unhandledrejection', onRejected);
+            }
+            connect();
+        },
+        stop () {
+            if (!running && !removeCustom) return;
+            running = false;
+            lifetime?.abort(new Error('Native browser HMR runtime retired.'));
+            clearTimeout(reconnect);
+            reconnect = void 0;
+            detachSocket();
+            window.removeEventListener('error', onError);
+            window.removeEventListener('unhandledrejection', onRejected);
+            removeCustom?.();
+            removeCustom = void 0;
+            custom.clear();
+            queued.length = 0;
+        }
+    };
+    client.arm();
+    state.candidates.set(initialHash, new WeakRef(client));
+    if (!state.active) {
+        state.active = client;
+        client.start();
+    }
+    return ()=>{
+        client.stop();
+        if (state.active === client) state.active = void 0;
+        if (state.candidates.get(initialHash)?.deref() === client) state.candidates.delete(initialHash);
+        if (!state.active && !state.candidates.size) clients().delete(options.remoteName);
+    };
+}
+export { prepareNativeBrowserDevClient, releaseNativeBrowserDevClient, startNativeBrowserDevClient };

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

@@ -0,0 +1,182 @@
+const COMMIT_ERROR = Symbol.for('ultramodern.federation.browser-dev-commit-error.v1');
+class NativeBrowserDevCommitError extends Error {
+    constructor(revision, cause){
+        super(`Native browser refresh failed after ownership transfer began: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause
+        }), this[COMMIT_ERROR] = true;
+        this.name = 'NativeBrowserDevCommitError';
+        Object.defineProperty(this, 'revision', {
+            value: revision,
+            enumerable: true
+        });
+    }
+}
+function isNativeBrowserDevCommitError(error, revision) {
+    return error instanceof Error && true === Reflect.get(error, COMMIT_ERROR) && Reflect.get(error, 'revision') === revision;
+}
+function nativeBrowserDevCommitFailure(revision, cause) {
+    return new NativeBrowserDevCommitError(revision, cause);
+}
+const selectedShares = (host)=>Object.entries(host.shareScopeMap).flatMap(([scope, packages])=>Object.entries(packages).flatMap(([name, versions])=>Object.entries(versions).filter(([, provider])=>provider.loaded || provider.loading).map(([version, provider])=>({
+                    scope,
+                    name,
+                    version,
+                    provider,
+                    lib: provider.lib,
+                    get: provider.get
+                }))));
+function assertSelectedShares(host, shares) {
+    for (const share of shares){
+        const provider = host.shareScopeMap[share.scope]?.[share.name]?.[share.version];
+        if (provider !== share.provider || provider.lib !== share.lib || provider.get !== share.get) throw new Error(`Native browser refresh changed the selected shared provider ${share.name}.`);
+    }
+}
+function createNativeBrowserDevRefresh(options) {
+    let active;
+    let pending;
+    let disposed = false;
+    const consumed = new Set();
+    const recovery = new Set();
+    const released = new WeakSet();
+    const release = (stage)=>{
+        if (released.has(stage)) return;
+        released.add(stage);
+        try {
+            stage.release();
+        } finally{
+            stage.host.moduleCache.clear();
+        }
+    };
+    return {
+        replace (graph) {
+            if (disposed) return Promise.reject(new Error('Native browser refresh is disposed.'));
+            if (pending) return Promise.reject(new Error('Native browser refresh already has an active replacement.'));
+            if (!/^[a-f0-9]{64}$/u.test(graph.revision)) return Promise.reject(new Error('Native browser graph revision is invalid.'));
+            if (consumed.has(graph.revision)) return Promise.reject(new Error('Native browser graph was already consumed; rebuild before retrying.'));
+            const commitErrors = new WeakSet();
+            const task = (async ()=>{
+                const host = options.host;
+                const shares = selectedShares(host);
+                const replacement = options.prepareReplacement(options.boundary);
+                const stage = options.createHost({
+                    ...host.options,
+                    name: `${host.name}:native-dev:${graph.revision}`,
+                    id: `${host.name}:native-dev:${graph.revision}`,
+                    remotes: [
+                        {
+                            ...graph.remote
+                        }
+                    ],
+                    shared: {}
+                });
+                if (stage.host === host || stage.host === active?.host) throw new Error('Native browser refresh requires an isolated staging host.');
+                let accepted = false;
+                let module;
+                let failed = false;
+                let failure;
+                try {
+                    for (const [name, scope] of Object.entries(host.shareScopeMap)){
+                        stage.host.initShareScopeMap(name, scope, {
+                            hostShareScopeMap: host.shareScopeMap
+                        });
+                        if (stage.host.shareScopeMap[name] !== scope) throw new Error('Native browser refresh lost the actual shared scope.');
+                    }
+                    const factory = await stage.host.loadRemote(options.id, {
+                        loadFactory: false
+                    });
+                    if (disposed) throw new Error('Native browser refresh was disposed while loading.');
+                    if ('function' != typeof factory) throw new Error('Native browser refresh did not receive an exposed factory.');
+                    assertSelectedShares(host, shares);
+                    stage.prepareFactory?.();
+                    consumed.add(graph.revision);
+                    try {
+                        module = replacement.execute(factory);
+                    } catch (error) {
+                        if (replacement.commitStarted) {
+                            if (active) recovery.add(active);
+                            active = stage;
+                            accepted = true;
+                        }
+                        throw error;
+                    }
+                    const previous = active;
+                    active = stage;
+                    accepted = true;
+                    assertSelectedShares(host, shares);
+                    const retired = new Set(recovery);
+                    recovery.clear();
+                    if (previous) retired.add(previous);
+                    const errors = [];
+                    for (const retained of retired)try {
+                        release(retained);
+                    } catch (error) {
+                        errors.push(error);
+                    }
+                    if (errors.length) throw new AggregateError(errors, 'Native browser refresh retirement failed.');
+                } catch (error) {
+                    failed = true;
+                    failure = error;
+                }
+                const retired = new Set();
+                if (disposed && active === stage) {
+                    active = void 0;
+                    for (const retained of recovery)retired.add(retained);
+                    recovery.clear();
+                    retired.add(stage);
+                } else if (!accepted) retired.add(stage);
+                const cleanupErrors = [];
+                for (const retained of retired)try {
+                    release(retained);
+                } catch (error) {
+                    cleanupErrors.push(error);
+                }
+                if (cleanupErrors.length) {
+                    failure = new AggregateError(failed ? [
+                        failure,
+                        ...cleanupErrors
+                    ] : cleanupErrors, 'Native browser refresh cleanup failed.');
+                    failed = true;
+                }
+                if (failed) {
+                    if (accepted) {
+                        const committedFailure = nativeBrowserDevCommitFailure(graph.revision, failure);
+                        commitErrors.add(committedFailure);
+                        throw committedFailure;
+                    }
+                    throw failure;
+                }
+                return module;
+            })().catch((error)=>{
+                if (error instanceof Error && true === Reflect.get(error, COMMIT_ERROR) && !commitErrors.has(error)) throw new Error(`Native browser graph failed before its own ownership transfer: ${error.message}`, {
+                    cause: error
+                });
+                throw error;
+            });
+            pending = task;
+            task.finally(()=>{
+                if (pending === task) pending = void 0;
+            }).catch(()=>{});
+            return task;
+        },
+        get activeHost () {
+            return active?.host ?? options.host;
+        },
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            const previous = active;
+            active = void 0;
+            const retained = new Set(recovery);
+            recovery.clear();
+            if (previous) retained.add(previous);
+            const errors = [];
+            for (const stage of retained)try {
+                release(stage);
+            } catch (error) {
+                errors.push(error);
+            }
+            if (errors.length) throw new AggregateError(errors, 'Native browser refresh cleanup failed.');
+        }
+    };
+}
+export { createNativeBrowserDevRefresh, isNativeBrowserDevCommitError, nativeBrowserDevCommitFailure };

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

@@ -0,0 +1,183 @@
+import { createNativeBrowserDevRefresh, isNativeBrowserDevCommitError, nativeBrowserDevCommitFailure } from "./native-browser-dev-refresh.mjs";
+import { readRendererFederationContract } from "./renderer-contract.mjs";
+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: 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 && !isNativeBrowserDevCommitError(error, graph.revision)) throw 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 = 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);
+}
+export { NATIVE_BROWSER_DEV_BOUNDARY, createNativeBrowserDevRuntimePlugin, hasNativeBrowserDevPublisher, readNativeBrowserDevPublication, replaceNativeBrowserDevRemote };