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

package/dist/cjs/router-external-snapshot.js

@@ -0,0 +1,263 @@
+"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__, {
+    OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE: ()=>OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+    associateOctaneFileRouteSnapshot: ()=>associateOctaneFileRouteSnapshot,
+    captureOctaneRouterSnapshot: ()=>captureOctaneRouterSnapshot,
+    registerOctaneRouterWorkerContexts: ()=>registerOctaneRouterWorkerContexts
+});
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const external_worker_federation_contexts_js_namespaceObject = require("./worker-federation-contexts.js");
+const OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE = Object.freeze({
+    key: 'ultramodern.file-routes',
+    version: '1'
+});
+const origins = new WeakMap();
+let profileRegistered = false;
+function plainRecord(value) {
+    return null !== value && 'object' == typeof value && [
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value));
+}
+function record(value, fields) {
+    if (!plainRecord(value)) throw new TypeError('Worker router context requires a plain record');
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ('string' != typeof key || fields && !fields.includes(key) || !descriptor || !descriptor.enumerable || !('value' in descriptor)) throw new TypeError('Unknown Worker router context field or accessor');
+    }
+    return value;
+}
+function nonempty(value) {
+    if ('string' != typeof value || !value.trim() || value.length > 1024) throw new TypeError('Invalid Worker router identity');
+    return value;
+}
+function publicContext(value) {
+    const context = record(value, [
+        'ultramodern'
+    ]);
+    const metadata = record(context.ultramodern, [
+        'rendererIdentity'
+    ]);
+    const identity = record(metadata.rendererIdentity, [
+        'renderer',
+        'appId',
+        'entryName',
+        'protocolVersion',
+        'buildId'
+    ]);
+    if ('octane' !== identity.renderer || 1 !== identity.protocolVersion) throw new TypeError('Unsupported Worker router identity');
+    return Object.freeze({
+        ultramodern: Object.freeze({
+            rendererIdentity: Object.freeze({
+                renderer: 'octane',
+                appId: nonempty(identity.appId),
+                entryName: nonempty(identity.entryName),
+                protocolVersion: 1,
+                buildId: nonempty(identity.buildId)
+            })
+        })
+    });
+}
+function localizedUrls(value) {
+    if (void 0 === value || 'boolean' == typeof value) return value;
+    const input = record(value);
+    const result = {};
+    for (const [path, translations] of Object.entries(input)){
+        const names = {};
+        for (const [language, target] of Object.entries(record(translations)))names[nonempty(language)] = nonempty(target);
+        result[path] = names;
+    }
+    return result;
+}
+function rewriteDescriptor(value) {
+    if (void 0 === value) return;
+    const input = record(value, [
+        'language',
+        'languages',
+        'localisedUrls'
+    ]);
+    if (!Array.isArray(input.languages) || !input.languages.length || input.languages.length > 64) throw new TypeError('Invalid Worker router i18n languages');
+    const languages = input.languages.map(nonempty);
+    const language = nonempty(input.language);
+    if (new Set(languages).size !== languages.length || !languages.includes(language)) throw new TypeError('Invalid Worker router i18n language');
+    const urls = localizedUrls(input.localisedUrls);
+    return {
+        language,
+        languages,
+        ...void 0 === urls ? {} : {
+            localisedUrls: urls
+        }
+    };
+}
+function nativeRewriteDescriptor(router) {
+    if (!router.options.rewrite) return;
+    const known = (0, external_worker_federation_contexts_js_namespaceObject.getOctaneWorkerRouterRewrite)()?.capture(router.options.rewrite);
+    if (!known) throw new TypeError('Custom router rewrite requires an exact Worker profile');
+    const descriptor = rewriteDescriptor(known);
+    if (!descriptor) throw new TypeError('Missing native router rewrite provenance');
+    return {
+        language: descriptor.language,
+        languages: [
+            ...descriptor.languages
+        ],
+        ...void 0 === descriptor.localisedUrls ? {} : {
+            localisedUrls: descriptor.localisedUrls
+        }
+    };
+}
+function validateDefaultSnapshot(snapshot) {
+    publicContext(snapshot.publicContext);
+    rewriteDescriptor(snapshot.i18n);
+}
+function ensureDefaultProfile() {
+    if (profileRegistered) return;
+    (0, tanstack_router_namespaceObject.registerRouterRenderProfile)({
+        id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+        assertHost: (router, snapshot)=>{
+            const origin = origins.get(router);
+            if (!origin || origin.rewrite !== router.options.rewrite || JSON.stringify(publicContext(router.options.context)) !== JSON.stringify(origin.publicContext)) throw new TypeError('Generated Worker router origin changed');
+            (0, tanstack_router_namespaceObject.assertDefaultRouterRenderHost)(router, void 0 !== snapshot.i18n);
+            validateDefaultSnapshot(snapshot);
+            if (JSON.stringify(nativeRewriteDescriptor(router)) !== JSON.stringify(snapshot.i18n)) throw new TypeError('Worker router rewrite differs from its native provenance');
+        },
+        createRoutingTree: (snapshot)=>{
+            validateDefaultSnapshot(snapshot);
+            return (0, tanstack_router_namespaceObject.createRouterRenderRouteTree)(snapshot.routes);
+        },
+        routingOptions: (snapshot)=>{
+            const defaults = {
+                parseSearch: tanstack_router_namespaceObject.defaultParseSearch,
+                stringifySearch: tanstack_router_namespaceObject.defaultStringifySearch
+            };
+            const i18n = rewriteDescriptor(snapshot.i18n);
+            if (!i18n) return defaults;
+            const codec = (0, external_worker_federation_contexts_js_namespaceObject.getOctaneWorkerRouterRewrite)();
+            if (!codec) throw new TypeError('Missing owning Worker router i18n codec');
+            return {
+                ...defaults,
+                rewrite: codec.restore(i18n)
+            };
+        }
+    });
+    profileRegistered = true;
+}
+function associateOctaneFileRouteSnapshot(router) {
+    ensureDefaultProfile();
+    const context = publicContext(router.options.context);
+    origins.set(router, {
+        publicContext: context,
+        rewrite: router.options.rewrite
+    });
+    (0, tanstack_router_namespaceObject.associateRouterRenderProfile)(router, {
+        id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+        publicContext: context
+    });
+}
+function captureOctaneRouterSnapshot(router) {
+    const origin = origins.get(router);
+    const declared = (0, tanstack_router_namespaceObject.getRouterRenderProfile)(router);
+    if (origin && declared?.key === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.key && declared.version === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.version) {
+        const i18n = nativeRewriteDescriptor(router);
+        (0, tanstack_router_namespaceObject.associateRouterRenderProfile)(router, {
+            id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+            publicContext: origin.publicContext,
+            ...void 0 === i18n ? {} : {
+                i18n
+            }
+        });
+    }
+    return (0, tanstack_router_namespaceObject.captureRouterRenderSnapshot)(router);
+}
+let registrations = 0;
+let releaseContexts;
+function registerOctaneRouterWorkerContexts() {
+    ensureDefaultProfile();
+    if (!releaseContexts) {
+        const releaseRouter = (0, external_worker_federation_contexts_js_namespaceObject.registerOctaneWorkerContext)(tanstack_router_namespaceObject.routerContext, {
+            key: external_worker_federation_contexts_js_namespaceObject.OCTANE_WORKER_CONTEXT_KEYS.router,
+            encode: (value)=>{
+                if (!value) throw new TypeError('Missing native router provider');
+                return captureOctaneRouterSnapshot(value);
+            },
+            decode: (value, signal)=>(0, tanstack_router_namespaceObject.restoreRouterRenderSnapshot)(value, {
+                    signal
+                }),
+            dispose: (value)=>{
+                if (value) (0, tanstack_router_namespaceObject.disposeRouterRenderSnapshot)(value);
+            },
+            isProvided: (value)=>void 0 !== value
+        });
+        try {
+            const releaseMatch = (0, external_worker_federation_contexts_js_namespaceObject.registerOctaneWorkerContext)(tanstack_router_namespaceObject.matchContext, {
+                key: external_worker_federation_contexts_js_namespaceObject.OCTANE_WORKER_CONTEXT_KEYS.match,
+                encode: nonempty,
+                decode: nonempty,
+                validate: (value, readContext)=>{
+                    const selected = readContext(tanstack_router_namespaceObject.routerContext);
+                    const router = selected.present ? selected.value : void 0;
+                    const current = router?.state.matches.find((match)=>match.routeId === value);
+                    if (!router || !current || 'string' != typeof value || router.stores.getMatchStore(value).get() !== current) throw new TypeError('Worker match context requires its selected native router and a current match');
+                },
+                isProvided: (value)=>void 0 !== value
+            });
+            releaseContexts = ()=>{
+                releaseMatch();
+                releaseRouter();
+            };
+        } catch (error) {
+            releaseRouter();
+            throw error;
+        }
+    }
+    registrations++;
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        if (0 === --registrations) {
+            releaseContexts?.();
+            releaseContexts = void 0;
+        }
+    };
+}
+exports.OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE = __webpack_exports__.OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE;
+exports.associateOctaneFileRouteSnapshot = __webpack_exports__.associateOctaneFileRouteSnapshot;
+exports.captureOctaneRouterSnapshot = __webpack_exports__.captureOctaneRouterSnapshot;
+exports.registerOctaneRouterWorkerContexts = __webpack_exports__.registerOctaneRouterWorkerContexts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE",
+    "associateOctaneFileRouteSnapshot",
+    "captureOctaneRouterSnapshot",
+    "registerOctaneRouterWorkerContexts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server.js

@@ -37,6 +37,7 @@ const server_namespaceObject = require("@octanejs/tanstack-router/ssr/server");
 const external_octane_server_namespaceObject = require("octane/server");
 const external_bootstrap_js_namespaceObject = require("./bootstrap.js");
 const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const external_worker_federation_context_js_namespaceObject = require("./worker-federation-context.js");
 function prepareOctaneDocument(session, document, hydrating) {
     (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(session.identity);
     if ('node' !== session.platform.kind && 'worker' !== session.platform.kind) throw new Error('An Octane document requires a Node or worker request platform.');
@@ -107,12 +108,21 @@ async function renderOctaneApplication(input) {
         if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
         session.startRendering();
         let head = '';
-        const federation = input.federation ? (0, external_federation_context_js_namespaceObject.createFederationScope)(input.federation, true, document.nonce) : void 0;
+        const federation = input.federation || input.workerFederation ? (0, external_federation_context_js_namespaceObject.createFederationScope)(input.federation, true, document.nonce) : void 0;
         const App = federation ? ()=>(0, external_octane_server_namespaceObject.createElement)(external_federation_context_js_namespaceObject.FederationRoot, {
                 scope: federation,
                 children: 'function' == typeof input.App ? (0, external_octane_server_namespaceObject.createElement)(input.App, input.props) : input.App
             }) : input.App;
-        const nativeStream = await (0, external_octane_server_namespaceObject.renderToReadableStream)(App, input.props, {
+        const workerFederation = input.workerFederation ? {
+            transport: input.workerFederation,
+            locale: input.workerFederationLocale ?? 'default',
+            signal: session.signal
+        } : void 0;
+        const NativeApp = workerFederation ? ()=>(0, external_octane_server_namespaceObject.createElement)(external_worker_federation_context_js_namespaceObject.WorkerFederationRoot, {
+                scope: workerFederation,
+                children: 'function' == typeof App ? (0, external_octane_server_namespaceObject.createElement)(App, input.props) : App
+            }) : App;
+        const nativeStream = await (0, external_octane_server_namespaceObject.renderToReadableStream)(NativeApp, input.props, {
             signal: session.signal,
             ...void 0 === document.nonce ? {} : {
                 nonce: document.nonce
@@ -125,6 +135,9 @@ async function renderOctaneApplication(input) {
                 buildId: document.nativeHydrationBuildId,
                 documentId: document.documentId
             },
+            externalSnapshots: {
+                documentId: document.documentId
+            },
             headChannel: 'separate',
             onHeadReady (value) {
                 head = value;

package/dist/cjs/worker-federation-context.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__, {
+    WorkerFederationApplication: ()=>WorkerFederationApplication,
+    WorkerFederationContext: ()=>WorkerFederationContext,
+    WorkerFederationRoot: ()=>WorkerFederationRoot
+});
+const external_octane_namespaceObject = require("octane");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const WorkerFederationContext = (0, external_octane_namespaceObject.createContext)(null);
+function WorkerFederationRoot(props) {
+    return (0, external_octane_namespaceObject.createElement)(WorkerFederationContext, {
+        value: props.scope,
+        children: props.children
+    });
+}
+function WorkerFederationApplication(props) {
+    return (0, external_octane_namespaceObject.createElement)(WorkerFederationRoot, {
+        scope: props.scope,
+        children: props.federation ? (0, external_octane_namespaceObject.createElement)(external_federation_context_js_namespaceObject.FederationApplication, {
+            scope: props.federation,
+            application: props.application
+        }) : (0, external_octane_namespaceObject.createElement)(props.application.default, props.application.props)
+    });
+}
+exports.WorkerFederationApplication = __webpack_exports__.WorkerFederationApplication;
+exports.WorkerFederationContext = __webpack_exports__.WorkerFederationContext;
+exports.WorkerFederationRoot = __webpack_exports__.WorkerFederationRoot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WorkerFederationApplication",
+    "WorkerFederationContext",
+    "WorkerFederationRoot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,97 @@
+"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__, {
+    OCTANE_WORKER_CONTEXT_KEYS: ()=>OCTANE_WORKER_CONTEXT_KEYS,
+    getOctaneWorkerRouterRewrite: ()=>getOctaneWorkerRouterRewrite,
+    registerOctaneWorkerContext: ()=>registerOctaneWorkerContext,
+    registerOctaneWorkerRouterRewrite: ()=>registerOctaneWorkerRouterRewrite,
+    useOctaneWorkerContextKeys: ()=>useOctaneWorkerContextKeys
+});
+const external_octane_namespaceObject = require("octane");
+const OCTANE_WORKER_CONTEXT_KEYS = Object.freeze({
+    router: 'ultramodern.octane.router-context.v1',
+    match: 'ultramodern.octane.match-context.v1',
+    i18n: 'ultramodern.octane.i18n-context.v1'
+});
+const builtinKeys = Object.values(OCTANE_WORKER_CONTEXT_KEYS);
+const contexts = new Map();
+function registerOctaneWorkerContext(context, codec) {
+    const { key, isProvided } = codec;
+    if (!builtinKeys.includes(key) || 'function' != typeof isProvided) throw new TypeError('Invalid Octane Worker builtin context codec');
+    const unregister = (0, external_octane_namespaceObject.registerExternalSnapshotContext)(context, codec);
+    const hasProvider = ()=>isProvided((0, external_octane_namespaceObject.useContext)(context));
+    contexts.set(key, hasProvider);
+    return ()=>{
+        if (contexts.get(key) !== hasProvider) return;
+        unregister();
+        contexts.delete(key);
+    };
+}
+function useOctaneWorkerContextKeys(explicit = []) {
+    const selected = [];
+    for (const key of builtinKeys){
+        const hasProvider = contexts.get(key);
+        if (hasProvider?.() && !explicit.includes(key)) selected.push(key);
+    }
+    return [
+        ...selected,
+        ...explicit
+    ];
+}
+let routerRewrite;
+function registerOctaneWorkerRouterRewrite(codec) {
+    if (routerRewrite || 'function' != typeof codec.capture || 'function' != typeof codec.restore) throw new TypeError('Invalid or duplicate Octane Worker router rewrite codec');
+    const captured = Object.freeze({
+        capture: codec.capture,
+        restore: codec.restore
+    });
+    routerRewrite = captured;
+    return ()=>{
+        if (routerRewrite === captured) routerRewrite = void 0;
+    };
+}
+function getOctaneWorkerRouterRewrite() {
+    return routerRewrite;
+}
+exports.OCTANE_WORKER_CONTEXT_KEYS = __webpack_exports__.OCTANE_WORKER_CONTEXT_KEYS;
+exports.getOctaneWorkerRouterRewrite = __webpack_exports__.getOctaneWorkerRouterRewrite;
+exports.registerOctaneWorkerContext = __webpack_exports__.registerOctaneWorkerContext;
+exports.registerOctaneWorkerRouterRewrite = __webpack_exports__.registerOctaneWorkerRouterRewrite;
+exports.useOctaneWorkerContextKeys = __webpack_exports__.useOctaneWorkerContextKeys;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_WORKER_CONTEXT_KEYS",
+    "getOctaneWorkerRouterRewrite",
+    "registerOctaneWorkerContext",
+    "registerOctaneWorkerRouterRewrite",
+    "useOctaneWorkerContextKeys"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/worker-federation.js

@@ -0,0 +1,97 @@
+"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__, {
+    createNativeWorkerFederationRuntime: ()=>createNativeWorkerFederationRuntime
+});
+const worker_federation_namespaceObject = require("@modern-js/renderer-core/worker-federation");
+const server_namespaceObject = require("octane/server");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const external_worker_federation_context_js_namespaceObject = require("./worker-federation-context.js");
+function isNativeWorkerComponent(value) {
+    return 'function' == typeof value;
+}
+function createNativeWorkerFederationRuntime(options, compiler) {
+    const { resources } = options;
+    const bindings = options.bindings;
+    const transport = resources.workerFederationServices?.length ? (0, worker_federation_namespaceObject.createWorkerFederationTransport)({
+        admitRendererContract: compiler.admitRendererContract,
+        services: resources.workerFederationServices.map((service)=>{
+            const binding = bindings && Reflect.get(bindings, service.binding);
+            if (!binding || 'object' != typeof binding && 'function' != typeof binding || !('fetch' in binding) || 'function' != typeof binding.fetch) throw new Error(`Native Worker federation requires service binding ${service.binding}.`);
+            return {
+                ...service,
+                fetch: binding.fetch.bind(binding)
+            };
+        })
+    }) : void 0;
+    let handle;
+    if (resources.workerFederation) {
+        if (!compiler.registry || !resources.workerFederationManifestUrl) throw new Error('Native Worker federation requires its compiled expose registry and pinned manifest URL.');
+        handle = compiler.registry.initialize({
+            publication: resources.workerFederation.worker,
+            manifestUrl: resources.workerFederationManifestUrl,
+            admitRendererContract: compiler.admitRendererContract,
+            admitNativeRequest (payload, { admitted, signal }) {
+                const initializeContexts = transport ? (provide, request)=>{
+                    provide(external_federation_context_js_namespaceObject.FederationContext, (0, external_federation_context_js_namespaceObject.createFederationScope)(void 0, true, request.nonce));
+                    provide(external_worker_federation_context_js_namespaceObject.WorkerFederationContext, {
+                        transport,
+                        locale: admitted.locale,
+                        signal
+                    });
+                } : void 0;
+                return (0, server_namespaceObject.prepareExternalSnapshotRequest)(payload, {
+                    authority: admitted.coordinate.native,
+                    signal,
+                    ...initializeContexts ? {
+                        initializeContexts
+                    } : {}
+                });
+            },
+            releaseNativeRequest: server_namespaceObject.releasePreparedExternalSnapshotRequest,
+            async renderNativeSnapshot (module, request, { admitted }) {
+                const component = module && 'object' == typeof module && 'default' in module ? module.default : void 0;
+                if (!isNativeWorkerComponent(component)) throw new TypeError(`Native Worker expose ${admitted.expose} requires a default Octane component.`);
+                return (0, server_namespaceObject.serializeExternalSnapshot)(await (0, server_namespaceObject.renderExternalSnapshot)(component, request));
+            }
+        });
+    }
+    return {
+        transport,
+        handleRequest: handle ?? (()=>Promise.resolve(void 0))
+    };
+}
+exports.createNativeWorkerFederationRuntime = __webpack_exports__.createNativeWorkerFederationRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeWorkerFederationRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});