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

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

@@ -0,0 +1,183 @@
+import "node:module";
+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-node/module-federation/native-browser-dev-runtime-plugin.mjs

@@ -0,0 +1,184 @@
+import "node:module";
+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 };

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

@@ -0,0 +1,230 @@
+import "node:module";
+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;