@bleedingdev/modern-js-renderer-core 3.9.3-ultramodern.8 → 3.9.3-ultramodern.9

package/dist/cjs/adapter.js

@@ -44,7 +44,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
     };
 }
 __webpack_require__.d(__webpack_exports__, {

package/dist/cjs/entry-client.js

@@ -101,6 +101,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/cjs/federation.js

@@ -27,6 +27,7 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+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.');
@@ -36,16 +37,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/cjs/server/worker.js

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

package/dist/cjs/worker-federation/contract.js

@@ -0,0 +1,298 @@
+"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__, {
+    WORKER_FEDERATION_METADATA_KEY: ()=>WORKER_FEDERATION_METADATA_KEY,
+    WORKER_FEDERATION_SCHEMA: ()=>WORKER_FEDERATION_SCHEMA,
+    WORKER_FEDERATION_VERSION: ()=>WORKER_FEDERATION_VERSION,
+    admitWorkerFederationExpose: ()=>admitWorkerFederationExpose,
+    readWorkerFederationEnvelope: ()=>readWorkerFederationEnvelope,
+    readWorkerFederationManifestUrl: ()=>readWorkerFederationManifestUrl,
+    readWorkerFederationPath: ()=>readWorkerFederationPath,
+    readWorkerFederationPublication: ()=>readWorkerFederationPublication,
+    readWorkerFederationStyles: ()=>readWorkerFederationStyles,
+    workerFederationEnvelope: ()=>workerFederationEnvelope,
+    workerFederationRecord: ()=>workerFederationRecord,
+    workerFederationWireJson: ()=>workerFederationWireJson
+});
+const external_identity_js_namespaceObject = require("../identity.js");
+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];
+        (0, external_identity_js_namespaceObject.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 = (0, external_identity_js_namespaceObject.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;
+}
+exports.WORKER_FEDERATION_METADATA_KEY = __webpack_exports__.WORKER_FEDERATION_METADATA_KEY;
+exports.WORKER_FEDERATION_SCHEMA = __webpack_exports__.WORKER_FEDERATION_SCHEMA;
+exports.WORKER_FEDERATION_VERSION = __webpack_exports__.WORKER_FEDERATION_VERSION;
+exports.admitWorkerFederationExpose = __webpack_exports__.admitWorkerFederationExpose;
+exports.readWorkerFederationEnvelope = __webpack_exports__.readWorkerFederationEnvelope;
+exports.readWorkerFederationManifestUrl = __webpack_exports__.readWorkerFederationManifestUrl;
+exports.readWorkerFederationPath = __webpack_exports__.readWorkerFederationPath;
+exports.readWorkerFederationPublication = __webpack_exports__.readWorkerFederationPublication;
+exports.readWorkerFederationStyles = __webpack_exports__.readWorkerFederationStyles;
+exports.workerFederationEnvelope = __webpack_exports__.workerFederationEnvelope;
+exports.workerFederationRecord = __webpack_exports__.workerFederationRecord;
+exports.workerFederationWireJson = __webpack_exports__.workerFederationWireJson;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WORKER_FEDERATION_METADATA_KEY",
+    "WORKER_FEDERATION_SCHEMA",
+    "WORKER_FEDERATION_VERSION",
+    "admitWorkerFederationExpose",
+    "readWorkerFederationEnvelope",
+    "readWorkerFederationManifestUrl",
+    "readWorkerFederationPath",
+    "readWorkerFederationPublication",
+    "readWorkerFederationStyles",
+    "workerFederationEnvelope",
+    "workerFederationRecord",
+    "workerFederationWireJson"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/worker-federation/handler.js

@@ -0,0 +1,197 @@
+"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__, {
+    createWorkerFederationHandler: ()=>createWorkerFederationHandler
+});
+const external_contract_js_namespaceObject = require("./contract.js");
+const external_lease_js_namespaceObject = require("./lease.js");
+function createWorkerFederationHandler(options) {
+    if ('function' != typeof options.admitRendererContract || 'function' != typeof options.admitNativeRequest || 'function' != typeof options.releaseNativeRequest || 'function' != typeof options.renderNativeSnapshot) throw new Error('Worker federation requires canonical and native admission callbacks.');
+    const timeout = options.requestTimeout ?? 3000;
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Worker federation requires a positive request deadline.');
+    const renderer = options.admitRendererContract(options.publication.renderer);
+    const worker = (0, external_contract_js_namespaceObject.readWorkerFederationPublication)(options.publication.worker, renderer.identities);
+    const manifest = JSON.parse((0, external_contract_js_namespaceObject.workerFederationWireJson)({
+        metaData: {
+            ultramodernRenderer: renderer,
+            ultramodernWorkerFederation: worker
+        }
+    }));
+    const loaders = (0, external_contract_js_namespaceObject.workerFederationRecord)(options.exposes, 'compiled exposes');
+    if (Object.keys(loaders).length !== Object.keys(worker.exposes).length || Object.keys(loaders).some((expose)=>!Object.hasOwn(worker.exposes, expose) || 'function' != typeof loaders[expose])) throw new Error('Worker federation registry conflicts with its own publication.');
+    const pinnedLoaders = {
+        ...options.exposes
+    };
+    const endpoints = new Map();
+    for (const [expose, coordinate] of Object.entries(worker.exposes))for (const locale of Object.keys(coordinate.paths)){
+        const admitted = (0, external_contract_js_namespaceObject.admitWorkerFederationExpose)({
+            manifest,
+            manifestUrl: options.manifestUrl,
+            remote: worker.remote,
+            expose,
+            locale,
+            admitRendererContract: options.admitRendererContract
+        });
+        endpoints.set(admitted.path, admitted);
+    }
+    const admitNativeRequest = options.admitNativeRequest;
+    const releaseNativeRequest = options.releaseNativeRequest;
+    const renderNativeSnapshot = options.renderNativeSnapshot;
+    return async (request)=>{
+        const deadlineAt = performance.now() + timeout;
+        const url = new URL(request.url);
+        const admitted = endpoints.get(url.pathname);
+        if (!admitted) return;
+        if ('POST' !== request.method || url.href !== admitted.endpoint || request.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') {
+            request.body?.cancel().catch(()=>void 0);
+            return new Response('Worker federation endpoint coordinate conflicts with its publication.', {
+                status: 400
+            });
+        }
+        if (request.signal.aborted) {
+            request.body?.cancel().catch(()=>void 0);
+            throw (0, external_lease_js_namespaceObject.workerAbortReason)(request.signal);
+        }
+        const controller = new AbortController();
+        const signal = AbortSignal.any([
+            request.signal,
+            controller.signal
+        ]);
+        const checkDeadline = ()=>(0, external_lease_js_namespaceObject.checkWorkerFederationDeadline)(deadlineAt, signal, controller);
+        const execution = Object.freeze({
+            admitted,
+            signal
+        });
+        const deadline = setTimeout(()=>{
+            controller.abort(new Error('Worker federation request deadline exceeded.'));
+        }, Math.max(0, deadlineAt - performance.now()));
+        let executing = false;
+        let admittedRequest;
+        let release;
+        let response;
+        let failedRequest;
+        const releaseOnce = (value)=>{
+            if (!release) try {
+                release = Promise.resolve(releaseNativeRequest(value));
+            } catch (error) {
+                release = Promise.reject(error);
+            }
+            return release ?? Promise.resolve();
+        };
+        try {
+            if (!request.body) throw new Error('Worker federation request has no native payload.');
+            const envelope = await (0, external_lease_js_namespaceObject.readWorkerFederationJsonBody)(request.body, signal, request.headers.get('content-length'), checkDeadline);
+            checkDeadline();
+            const payload = (0, external_contract_js_namespaceObject.readWorkerFederationEnvelope)(envelope, 'request', admitted);
+            checkDeadline();
+            const preparing = Promise.resolve().then(()=>{
+                checkDeadline();
+                return admitNativeRequest(payload, execution);
+            });
+            preparing.then((value)=>{
+                if (signal.aborted) releaseOnce(value).catch(()=>void 0);
+            }, ()=>void 0);
+            const nativeRequest = await (0, external_lease_js_namespaceObject.workerAbortable)(preparing, signal);
+            admittedRequest = {
+                value: nativeRequest
+            };
+            checkDeadline();
+            executing = true;
+            const module = await (0, external_lease_js_namespaceObject.workerAbortable)(pinnedLoaders[admitted.expose](), signal);
+            checkDeadline();
+            const snapshot = await (0, external_lease_js_namespaceObject.workerAbortable)(Promise.resolve(renderNativeSnapshot(module, nativeRequest, execution)), signal);
+            checkDeadline();
+            if ('string' == typeof snapshot) (0, external_lease_js_namespaceObject.assertWorkerFederationBodySize)(snapshot);
+            const body = (0, external_lease_js_namespaceObject.assertWorkerFederationBodySize)((0, external_contract_js_namespaceObject.workerFederationWireJson)((0, external_contract_js_namespaceObject.workerFederationEnvelope)('response', admitted, snapshot)));
+            checkDeadline();
+            response = new Response(body, {
+                headers: {
+                    'content-type': 'application/json'
+                }
+            });
+        } catch (error) {
+            let failure = error;
+            try {
+                checkDeadline();
+            } catch (deadlineError) {
+                failure = deadlineError;
+            }
+            failedRequest = {
+                error: failure
+            };
+            response = new Response((0, external_lease_js_namespaceObject.workerFederationErrorMessage)(failure, 'Worker federation request failed.'), {
+                status: signal.aborted ? 504 : executing ? 502 : failure instanceof external_lease_js_namespaceObject.WorkerFederationBodyTooLargeError ? 413 : 400
+            });
+        } finally{
+            try {
+                if (admittedRequest) {
+                    const releasing = releaseOnce(admittedRequest.value);
+                    if (signal.aborted) releasing.catch(()=>void 0);
+                    else try {
+                        await (0, external_lease_js_namespaceObject.workerAbortable)(releasing, signal);
+                        checkDeadline();
+                    } catch (error) {
+                        response?.body?.cancel().catch(()=>void 0);
+                        let releaseFailure = error;
+                        try {
+                            checkDeadline();
+                        } catch (deadlineError) {
+                            releaseFailure = new AggregateError([
+                                error,
+                                deadlineError
+                            ], `${(0, external_lease_js_namespaceObject.workerFederationErrorMessage)(error, 'Native request release failed.', 384)}; ${(0, external_lease_js_namespaceObject.workerFederationErrorMessage)(deadlineError, 'Worker federation deadline exceeded.', 384)}`);
+                        }
+                        const failure = failedRequest ? new AggregateError([
+                            failedRequest.error,
+                            releaseFailure
+                        ], `${(0, external_lease_js_namespaceObject.workerFederationErrorMessage)(failedRequest.error, 'Worker federation request failed.', 384)}; native request release failed: ${(0, external_lease_js_namespaceObject.workerFederationErrorMessage)(releaseFailure, 'Native request release failed.', 384)}`) : releaseFailure;
+                        response = new Response((0, external_lease_js_namespaceObject.workerFederationErrorMessage)(failure, 'Worker federation native request release failed.'), {
+                            status: signal.aborted ? 504 : 502
+                        });
+                    }
+                }
+            } finally{
+                clearTimeout(deadline);
+            }
+        }
+        if (request.signal.aborted) {
+            response?.body?.cancel().catch(()=>void 0);
+            throw (0, external_lease_js_namespaceObject.workerAbortReason)(request.signal);
+        }
+        return response;
+    };
+}
+exports.createWorkerFederationHandler = __webpack_exports__.createWorkerFederationHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWorkerFederationHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/worker-federation/index.js

@@ -0,0 +1,63 @@
+"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__, {
+    WORKER_FEDERATION_METADATA_KEY: ()=>external_contract_js_namespaceObject.WORKER_FEDERATION_METADATA_KEY,
+    WORKER_FEDERATION_SCHEMA: ()=>external_contract_js_namespaceObject.WORKER_FEDERATION_SCHEMA,
+    WORKER_FEDERATION_VERSION: ()=>external_contract_js_namespaceObject.WORKER_FEDERATION_VERSION,
+    createWorkerFederationHandler: ()=>external_handler_js_namespaceObject.createWorkerFederationHandler,
+    createWorkerFederationTransport: ()=>external_transport_js_namespaceObject.createWorkerFederationTransport,
+    readWorkerFederationManifestUrl: ()=>external_contract_js_namespaceObject.readWorkerFederationManifestUrl,
+    readWorkerFederationPath: ()=>external_contract_js_namespaceObject.readWorkerFederationPath,
+    readWorkerFederationPublication: ()=>external_contract_js_namespaceObject.readWorkerFederationPublication
+});
+const external_contract_js_namespaceObject = require("./contract.js");
+const external_handler_js_namespaceObject = require("./handler.js");
+const external_transport_js_namespaceObject = require("./transport.js");
+exports.WORKER_FEDERATION_METADATA_KEY = __webpack_exports__.WORKER_FEDERATION_METADATA_KEY;
+exports.WORKER_FEDERATION_SCHEMA = __webpack_exports__.WORKER_FEDERATION_SCHEMA;
+exports.WORKER_FEDERATION_VERSION = __webpack_exports__.WORKER_FEDERATION_VERSION;
+exports.createWorkerFederationHandler = __webpack_exports__.createWorkerFederationHandler;
+exports.createWorkerFederationTransport = __webpack_exports__.createWorkerFederationTransport;
+exports.readWorkerFederationManifestUrl = __webpack_exports__.readWorkerFederationManifestUrl;
+exports.readWorkerFederationPath = __webpack_exports__.readWorkerFederationPath;
+exports.readWorkerFederationPublication = __webpack_exports__.readWorkerFederationPublication;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WORKER_FEDERATION_METADATA_KEY",
+    "WORKER_FEDERATION_SCHEMA",
+    "WORKER_FEDERATION_VERSION",
+    "createWorkerFederationHandler",
+    "createWorkerFederationTransport",
+    "readWorkerFederationManifestUrl",
+    "readWorkerFederationPath",
+    "readWorkerFederationPublication"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});