@bleedingdev/modern-js-renderer-core 3.9.3-ultramodern.1 → 3.9.3-ultramodern.10

package/dist/esm/worker-federation/transport.mjs

@@ -0,0 +1,234 @@
+import { admitWorkerFederationExpose, readWorkerFederationEnvelope, readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationStyles, workerFederationEnvelope, workerFederationWireJson } from "./contract.mjs";
+import { assertWorkerFederationBodySize, checkWorkerFederationDeadline, readWorkerFederationJsonBody, workerAbortReason, workerAbortable } from "./lease.mjs";
+async function readResponseJson(response, expectedUrl, signal, checkDeadline) {
+    const cancelBody = ()=>{
+        response.body?.cancel().catch(()=>void 0);
+    };
+    if (signal.aborted) {
+        cancelBody();
+        throw workerAbortReason(signal);
+    }
+    try {
+        checkDeadline();
+    } catch (error) {
+        cancelBody();
+        throw error;
+    }
+    if (!response.ok || response.redirected || response.url && response.url !== expectedUrl) {
+        cancelBody();
+        throw new Error(`Worker federation publication request failed (${response.status}).`);
+    }
+    if (!response.body) throw new Error('Worker federation response has no body.');
+    return readWorkerFederationJsonBody(response.body, signal, response.headers.get('content-length'), checkDeadline);
+}
+async function fetchJson(fetchResponse, request, signal, checkDeadline) {
+    checkDeadline();
+    if (signal.aborted) throw workerAbortReason(signal);
+    const pending = fetchResponse(request);
+    pending.then((response)=>{
+        if (signal.aborted) response.body?.cancel().catch(()=>void 0);
+    }, ()=>void 0);
+    return readResponseJson(await workerAbortable(pending, signal), request.url, signal, checkDeadline);
+}
+function createWorkerFederationTransport(options) {
+    const timeout = options.requestTimeout ?? 3000;
+    const admitRendererContract = options.admitRendererContract;
+    if ('function' != typeof admitRendererContract) throw new Error('Worker federation requires canonical renderer admission.');
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Worker federation requires a positive request deadline.');
+    const services = new Map();
+    for (const service of options.services){
+        if (!service.remote || services.has(service.remote)) throw new Error('Worker federation service remotes must be unique.');
+        const exposes = new Set();
+        for (const fragment of service.fragments){
+            Object.values(fragment.paths).forEach(readWorkerFederationPath);
+            if (!fragment.boundaryId || exposes.has(fragment.expose)) throw new Error('Worker federation service exposes must be explicit and unique.');
+            exposes.add(fragment.expose);
+        }
+        const captured = {
+            ...service,
+            manifestUrl: readWorkerFederationManifestUrl(service.manifestUrl).href,
+            fetch: service.fetch.bind(service),
+            fragments: service.fragments.map((fragment)=>Object.freeze({
+                    ...fragment,
+                    paths: Object.freeze({
+                        ...fragment.paths
+                    })
+                }))
+        };
+        services.set(service.remote, captured);
+        if (service.alias && service.alias !== service.remote) {
+            if (services.has(service.alias)) throw new Error('Worker federation service aliases must be unique.');
+            services.set(service.alias, captured);
+        }
+    }
+    const snapshots = new Map();
+    const admissions = new Map();
+    const fetchManifest = options.fetchManifest;
+    let retired;
+    const onOwnerAbort = ()=>dispose(workerAbortReason(options.signal));
+    function checkDocumentLiveness() {
+        if (retired) throw retired.reason;
+    }
+    function dispose(reason = new DOMException('The Worker federation document was disposed', 'AbortError')) {
+        if (retired) return;
+        retired = {
+            reason
+        };
+        options.signal?.removeEventListener('abort', onOwnerAbort);
+        for (const pending of [
+            ...snapshots.values(),
+            ...admissions.values()
+        ])pending.controller.abort(reason);
+        snapshots.clear();
+        admissions.clear();
+    }
+    if (options.signal?.aborted) onOwnerAbort();
+    else options.signal?.addEventListener('abort', onOwnerAbort, {
+        once: true
+    });
+    function serviceCoordinate(remote, expose, locale) {
+        const service = services.get(remote);
+        const fragment = service?.fragments.find((value)=>value.expose === expose);
+        if (!service || !fragment || !Object.hasOwn(fragment.paths, locale)) throw new Error('Worker federation remote/expose has no configured service binding.');
+        return {
+            service,
+            fragment
+        };
+    }
+    async function shared(cache, key, operation, signal, deadlineAt = performance.now() + timeout, retainFulfilled = true) {
+        checkDocumentLiveness();
+        if (signal?.aborted) throw workerAbortReason(signal);
+        let pending = cache.get(key);
+        if (!pending) {
+            const controller = new AbortController();
+            const checkDeadline = ()=>checkWorkerFederationDeadline(deadlineAt, controller.signal, controller);
+            const deadline = setTimeout(()=>controller.abort(new Error('Worker federation request deadline exceeded.')), Math.max(0, deadlineAt - performance.now()));
+            const promise = operation(controller.signal, checkDeadline);
+            pending = {
+                controller,
+                promise,
+                waiters: 0,
+                settled: false
+            };
+            const captured = pending;
+            cache.set(key, captured);
+            promise.then(()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (!retainFulfilled && cache.get(key) === captured) cache.delete(key);
+            }, ()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (cache.get(key) === captured) cache.delete(key);
+            });
+        }
+        const captured = pending;
+        captured.waiters++;
+        try {
+            const value = await (signal ? workerAbortable(captured.promise, signal) : captured.promise);
+            checkDocumentLiveness();
+            checkWorkerFederationDeadline(deadlineAt, signal);
+            return value;
+        } finally{
+            captured.waiters--;
+            if (!captured.settled && 0 === captured.waiters) {
+                captured.controller.abort(new Error('Worker federation request has no active consumers.'));
+                if (cache.get(key) === captured) cache.delete(key);
+            }
+        }
+    }
+    function admitWithin({ remote, expose, locale, signal }, deadlineAt = performance.now() + timeout) {
+        const { service, fragment } = serviceCoordinate(remote, expose, locale);
+        const key = workerFederationWireJson([
+            service.remote,
+            expose,
+            locale
+        ]);
+        const promise = shared(admissions, key, async (signal, checkDeadline)=>{
+            checkDeadline();
+            const request = new Request(service.manifestUrl, {
+                redirect: 'manual',
+                signal
+            });
+            const manifest = await fetchJson(fetchManifest ?? service.fetch, request, signal, checkDeadline);
+            const styles = readWorkerFederationStyles({
+                manifest,
+                manifestUrl: request.url,
+                expose
+            });
+            const admitted = admitWorkerFederationExpose({
+                manifest,
+                manifestUrl: request.url,
+                remote: service.remote,
+                expose,
+                locale,
+                admitRendererContract
+            });
+            checkDeadline();
+            if (admitted.coordinate.boundaryId !== fragment.boundaryId || admitted.path !== fragment.paths[locale]) throw new Error('Worker federation publication conflicts with its service coordinate.');
+            return Object.freeze({
+                ...admitted,
+                styles
+            });
+        }, signal, deadlineAt);
+        return {
+            promise,
+            key,
+            pending: admissions.get(key)
+        };
+    }
+    return {
+        dispose,
+        admit: (options)=>admitWithin(options).promise,
+        async request ({ remote, expose, locale, payload, signal }) {
+            const deadlineAt = performance.now() + timeout;
+            checkDocumentLiveness();
+            if (signal?.aborted) throw workerAbortReason(signal);
+            const { service } = serviceCoordinate(remote, expose, locale);
+            if ('string' == typeof payload) assertWorkerFederationBodySize(payload);
+            const encodedPayload = assertWorkerFederationBodySize(workerFederationWireJson(payload));
+            const key = workerFederationWireJson([
+                service.remote,
+                expose,
+                locale,
+                encodedPayload
+            ]);
+            checkWorkerFederationDeadline(deadlineAt, signal);
+            return shared(snapshots, key, async (signal, checkDeadline)=>{
+                checkDeadline();
+                const admission = admitWithin({
+                    remote,
+                    expose,
+                    locale,
+                    signal
+                }, deadlineAt);
+                const admitted = await admission.promise;
+                checkDeadline();
+                try {
+                    const body = assertWorkerFederationBodySize(workerFederationWireJson(workerFederationEnvelope('request', admitted, JSON.parse(encodedPayload))));
+                    checkDeadline();
+                    const response = await fetchJson(service.fetch, new Request(admitted.endpoint, {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json'
+                        },
+                        body,
+                        redirect: 'manual',
+                        signal
+                    }), signal, checkDeadline);
+                    checkDeadline();
+                    const decodedPayload = readWorkerFederationEnvelope(response, 'response', admitted);
+                    checkDeadline();
+                    return {
+                        admitted,
+                        payload: decodedPayload
+                    };
+                } catch (error) {
+                    if (!signal.aborted && admissions.get(admission.key) === admission.pending) admissions.delete(admission.key);
+                    throw error;
+                }
+            }, signal, deadlineAt, false);
+        }
+    };
+}
+export { createWorkerFederationTransport };

package/dist/esm-node/adapter.mjs

@@ -16,7 +16,7 @@ function defineRendererAdapter(adapter) {
 function nativeRendererDependencies(profile) {
     return {
         ...Object.fromEntries(Object.entries(profile.dependencies).filter(([name])=>!name.startsWith('@modern-js/'))),
-        [profile.router.coreName]: profile.router.coreVersion
+        [profile.router.coreName]: profile.dependencies[profile.router.coreName] ?? profile.router.coreVersion
     };
 }
 export { defineRendererAdapter, nativeRendererDependencies };

package/dist/esm-node/data/codec.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import { fromJSON, toJSON } from "seroval";
 import { validateSerializedData } from "./tree.mjs";
-const DATA_CODEC = 'seroval-json@1.6.8';
+const DATA_CODEC = 'seroval-json@1.6.9';
 const MAX_DATA_BYTES = 1048576;
 const MAX_DEPTH = 100;
 const MAX_NODES = 20000;

package/dist/esm-node/entry-client.mjs

@@ -70,6 +70,11 @@ function startNativeClientEntry(options, adapter) {
                 rewrite: i18n.rewrite(()=>current.language)
             } : {}
         });
+        const releaseRouter = ()=>adapter.disposeRouter(router);
+        if (signal.aborted) releaseRouter();
+        else signal.addEventListener('abort', releaseRouter, {
+            once: true
+        });
         const stopSync = i18n && current ? i18n.syncWithRouter(router, current) : void 0;
         if (stopSync) signal.addEventListener('abort', stopSync, {
             once: true

package/dist/esm-node/federation.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+const LOAD_WITH_CAPTURE = Symbol.for('ultramodern.federation.load-with-capture');
 function getFederationHost(binding) {
     if (void 0 === binding) return;
     if ('function' != typeof binding?.instance) throw new TypeError('The native federation host binding is invalid.');
@@ -8,16 +9,24 @@ function getFederationHost(binding) {
 }
 async function loadFederatedModule(instance, id) {
     if (!instance) throw new Error(`Cannot load ${id}: this application has no Module Federation runtime. Add module-federation.config.ts with its remotes.`);
-    const module = await instance.loadRemote(id);
+    const coupledLoad = instance[LOAD_WITH_CAPTURE];
+    const result = coupledLoad ? await coupledLoad(id, (_module, resolution)=>remoteBrowserAssets(instance, id, resolution)) : {
+        module: await instance.loadRemote(id),
+        captured: remoteBrowserAssets(instance, id)
+    };
+    const module = result.module;
     if (!module) throw new Error(`Remote module ${id} is unavailable`);
-    return module;
+    return {
+        module,
+        assets: result.captured
+    };
 }
-function remoteBrowserAssets(instance, id) {
+function remoteBrowserAssets(instance, id, resolution) {
     const target = instance.remoteHandler?.idToRemoteMap?.[id];
     const loaded = target && instance.moduleCache?.get(target.name);
-    const snapshot = loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
+    const snapshot = resolution ? resolution.remoteSnapshot : loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
     if (!snapshot || 'string' != typeof snapshot.publicPath || !snapshot.publicPath || 'string' != typeof snapshot.remoteEntry || !snapshot.remoteEntry) return;
-    const expose = snapshot.modules?.find((module)=>module.modulePath === target.expose);
+    const expose = snapshot.modules?.find((module)=>module.modulePath === (resolution?.expose ?? target?.expose));
     if (!expose?.assets) return;
     const publicPath = snapshot.publicPath;
     const url = (file)=>/^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;

package/dist/esm-node/server/worker.mjs

@@ -29,7 +29,8 @@ function dispatchNativeWorkerRequest(request, options) {
                 ...resources.serverConfig,
                 forceCSR
             },
-            nonce: resources.nonce
+            nonce: resources.nonce,
+            workerFederation: options.workerFederation
         }
     });
 }

package/dist/esm-node/worker-federation/contract.mjs

@@ -0,0 +1,228 @@
+import "node:module";
+import { identityCacheKey, readRendererIdentity } from "../identity.mjs";
+const WORKER_FEDERATION_METADATA_KEY = 'ultramodernWorkerFederation';
+const WORKER_FEDERATION_SCHEMA = 'ultramodern.worker-federation';
+const WORKER_FEDERATION_VERSION = 1;
+function workerFederationRecord(value, label) {
+    if (!value || 'object' != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value))) throw new Error(`Worker federation ${label} must be a plain record.`);
+    return value;
+}
+function exactFields(value, fields, label) {
+    if (Object.keys(value).length !== fields.length || Object.keys(value).some((key)=>!fields.includes(key))) throw new Error(`Worker federation ${label} has unsupported fields.`);
+}
+function requiredString(value, label) {
+    if ('string' != typeof value || 0 === value.length || value.trim() !== value || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error(`Worker federation requires ${label}.`);
+    return value;
+}
+function readWorkerFederationPath(value) {
+    const path = requiredString(value, 'an endpoint path');
+    let decoded;
+    try {
+        decoded = decodeURIComponent(path);
+    } catch  {
+        throw new Error('Worker federation endpoint path has invalid encoding.');
+    }
+    if (!path.startsWith('/') || path.startsWith('//') || /[\\?#\s\u0000-\u001f\u007f]/u.test(decoded) || /%[0-9a-f]{2}/iu.test(decoded) || decoded.split('/').some((segment)=>'.' === segment || '..' === segment) || new URL(path, 'https://worker.invalid').pathname !== path) throw new Error('Worker federation endpoint must be an exact root path.');
+    return path;
+}
+function readWorkerFederationManifestUrl(value) {
+    const url = new URL(value);
+    if (![
+        'http:',
+        'https:'
+    ].includes(url.protocol) || url.username || url.password || url.hash) throw new Error('Worker federation manifest requires an HTTP(S) publication URL.');
+    return url;
+}
+function readWorkerFederationPublication(value, identities) {
+    const record = workerFederationRecord(value, 'publication');
+    exactFields(record, [
+        'schema',
+        'schemaVersion',
+        'remote',
+        'exposes'
+    ], 'publication');
+    if (record.schema !== WORKER_FEDERATION_SCHEMA || record.schemaVersion !== WORKER_FEDERATION_VERSION) throw new Error('Unsupported Worker federation publication protocol.');
+    const remote = requiredString(record.remote, 'a remote');
+    const entries = workerFederationRecord(record.exposes, 'exposes');
+    if (0 === Object.keys(entries).length) throw new Error('Worker federation publication has no exposes.');
+    const paths = new Set();
+    const exposes = Object.fromEntries(Object.entries(entries).map(([expose, raw])=>{
+        if (!/^\.\/[A-Za-z0-9_$@.-]+(?:\/[A-Za-z0-9_$@.-]+)*$/u.test(expose) || expose.slice(2).split('/').some((segment)=>'.' === segment || '..' === segment)) throw new Error(`Unsupported Worker federation expose ${expose}.`);
+        const coordinate = workerFederationRecord(raw, 'expose coordinate');
+        exactFields(coordinate, [
+            'entryName',
+            'boundaryId',
+            'paths',
+            'native'
+        ], 'expose coordinate');
+        const entryName = requiredString(coordinate.entryName, 'an entry name');
+        if (!Object.hasOwn(identities, entryName)) throw new Error(`Worker federation expose ${expose} has no built entry.`);
+        const identity = identities[entryName];
+        identityCacheKey(identity);
+        if (identity.entryName !== entryName) throw new Error('Worker federation entry identity conflicts with its key.');
+        const rawPaths = workerFederationRecord(coordinate.paths, 'locale paths');
+        const native = workerFederationRecord(coordinate.native, 'native authority');
+        exactFields(native, [
+            'publisherBuildId',
+            'runtimeABI'
+        ], 'native authority');
+        if (1 !== native.runtimeABI) throw new Error('Unsupported native Worker federation runtime ABI.');
+        if (0 === Object.keys(rawPaths).length) throw new Error('Worker federation expose has no locale endpoints.');
+        const locales = Object.keys(rawPaths);
+        if (new Set(locales.map((locale)=>locale.toLowerCase())).size !== locales.length || locales.includes('default') && 1 !== locales.length) throw new Error('Worker federation requires unique locales or only default.');
+        const localePaths = Object.fromEntries(Object.entries(rawPaths).map(([locale, rawPath])=>{
+            if (!/^[a-zA-Z0-9]+(?:[-_][a-zA-Z0-9]+)*$/u.test(locale)) throw new Error('Worker federation endpoint has an invalid locale.');
+            const path = readWorkerFederationPath(rawPath);
+            if (paths.has(path)) throw new Error('Worker federation exposes have conflicting endpoint paths.');
+            paths.add(path);
+            return [
+                locale,
+                path
+            ];
+        }));
+        return [
+            expose,
+            Object.freeze({
+                entryName,
+                boundaryId: requiredString(coordinate.boundaryId, 'a boundary ID'),
+                paths: Object.freeze(localePaths),
+                native: Object.freeze({
+                    publisherBuildId: requiredString(native.publisherBuildId, 'a native publisher build ID'),
+                    runtimeABI: 1
+                })
+            })
+        ];
+    }));
+    return Object.freeze({
+        schema: WORKER_FEDERATION_SCHEMA,
+        schemaVersion: WORKER_FEDERATION_VERSION,
+        remote,
+        exposes: Object.freeze(exposes)
+    });
+}
+function workerFederationWireJson(value) {
+    const encode = (input)=>{
+        if (null === input || 'string' == typeof input || 'boolean' == typeof input) return input;
+        if ('number' == typeof input && Number.isFinite(input)) return input;
+        if (Array.isArray(input)) return input.map(encode);
+        const record = workerFederationRecord(input, 'wire value');
+        return Object.fromEntries(Object.keys(record).toSorted().map((key)=>[
+                key,
+                encode(record[key])
+            ]));
+    };
+    return JSON.stringify(encode(value));
+}
+function freezeWireValue(value) {
+    const copy = JSON.parse(workerFederationWireJson(value));
+    const freeze = (input)=>{
+        if (input && 'object' == typeof input) {
+            Object.values(input).forEach(freeze);
+            Object.freeze(input);
+        }
+    };
+    freeze(copy);
+    return copy;
+}
+function readWorkerFederationStyles(options) {
+    const manifest = workerFederationRecord(options.manifest, 'manifest');
+    const metadata = workerFederationRecord(manifest.metaData, 'manifest metadata');
+    const manifestUrl = readWorkerFederationManifestUrl(options.manifestUrl);
+    if (!Array.isArray(manifest.exposes)) throw new Error('Worker federation manifest exposes must be an array.');
+    const selected = manifest.exposes.map((value)=>workerFederationRecord(value, 'manifest expose')).filter((value)=>value.path === options.expose);
+    if (1 !== selected.length) throw new Error('Worker federation styles require one exact manifest expose.');
+    if (void 0 === selected[0].assets) return Object.freeze([]);
+    const assets = workerFederationRecord(selected[0].assets, 'expose assets');
+    if (void 0 === assets.css) return Object.freeze([]);
+    const css = workerFederationRecord(assets.css, 'expose CSS assets');
+    const files = [
+        'sync',
+        'async'
+    ].flatMap((kind)=>{
+        const values = css[kind];
+        if (void 0 === values) return [];
+        if (!Array.isArray(values)) throw new Error('Worker federation CSS assets must be string arrays.');
+        return values.map((value)=>requiredString(value, 'a CSS asset URL'));
+    });
+    if (0 === files.length) return Object.freeze([]);
+    if (void 0 === metadata.publicPath || 'auto' === metadata.publicPath) throw new Error('Worker federation CSS requires a completed static publicPath; auto and getPublicPath cannot resolve styles in a Worker.');
+    const publicPath = requiredString(metadata.publicPath, 'a completed public path');
+    const explicitScheme = /^[a-z][a-z0-9+.-]*:/iu;
+    const isHttpScheme = /^https?:/iu;
+    const assertScheme = (value)=>{
+        if (explicitScheme.test(value) && !isHttpScheme.test(value)) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+    };
+    assertScheme(publicPath);
+    const publicUrl = new URL(publicPath, manifestUrl);
+    if (![
+        'http:',
+        'https:'
+    ].includes(publicUrl.protocol) || publicUrl.username || publicUrl.password || publicUrl.hash) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+    const styles = files.map((file)=>{
+        assertScheme(file);
+        const resolved = /^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;
+        const url = new URL(resolved, manifestUrl);
+        if (![
+            'http:',
+            'https:'
+        ].includes(url.protocol) || url.username || url.password || url.hash) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+        return resolved;
+    });
+    return Object.freeze([
+        ...new Set(styles)
+    ]);
+}
+function admitWorkerFederationExpose(options) {
+    const url = readWorkerFederationManifestUrl(options.manifestUrl);
+    const manifest = workerFederationRecord(options.manifest, 'manifest');
+    const metadata = workerFederationRecord(manifest.metaData, 'manifest metadata');
+    const renderer = freezeWireValue(options.admitRendererContract(metadata.ultramodernRenderer));
+    const worker = readWorkerFederationPublication(metadata[WORKER_FEDERATION_METADATA_KEY], renderer.identities);
+    if (worker.remote !== options.remote) throw new Error('Worker federation publication names another remote.');
+    if (!Object.hasOwn(worker.exposes, options.expose)) throw new Error(`Worker federation expose ${options.expose} is not published.`);
+    const coordinate = worker.exposes[options.expose];
+    if (!Object.hasOwn(coordinate.paths, options.locale)) throw new Error('Worker federation locale has no published endpoint.');
+    const path = coordinate.paths[options.locale];
+    const identity = readRendererIdentity(renderer.identities[coordinate.entryName], renderer.identities[coordinate.entryName]);
+    return Object.freeze({
+        authority: Object.freeze({
+            origin: url.origin,
+            renderer,
+            worker
+        }),
+        expose: options.expose,
+        locale: options.locale,
+        coordinate,
+        path,
+        identity,
+        endpoint: new URL(path, url.origin).href,
+        styles: Object.freeze([])
+    });
+}
+function workerFederationEnvelope(kind, admitted, payload) {
+    return {
+        schema: `ultramodern.worker-federation-${kind}`,
+        schemaVersion: 1,
+        authority: admitted.authority,
+        expose: admitted.expose,
+        locale: admitted.locale,
+        payload
+    };
+}
+function readWorkerFederationEnvelope(value, kind, admitted) {
+    const record = workerFederationRecord(value, `${kind} envelope`);
+    exactFields(record, [
+        'schema',
+        'schemaVersion',
+        'authority',
+        'expose',
+        'locale',
+        'payload'
+    ], `${kind} envelope`);
+    if (record.schema !== `ultramodern.worker-federation-${kind}` || 1 !== record.schemaVersion || record.expose !== admitted.expose || record.locale !== admitted.locale || workerFederationWireJson(record.authority) !== workerFederationWireJson(admitted.authority)) throw new Error(`Worker federation ${kind} conflicts with the admitted publication.`);
+    return record.payload;
+}
+export { WORKER_FEDERATION_METADATA_KEY, WORKER_FEDERATION_SCHEMA, WORKER_FEDERATION_VERSION, admitWorkerFederationExpose, readWorkerFederationEnvelope, readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationPublication, readWorkerFederationStyles, workerFederationEnvelope, workerFederationRecord, workerFederationWireJson };