@bleedingdev/modern-js-renderer-octane 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

package/dist/esm/router-external-snapshot.mjs

@@ -0,0 +1,244 @@
+import { associateRouterRenderProfile, captureRouterRenderSnapshot, createRouterRenderRouteTree, defaultParseSearch, defaultStringifySearch, disposeRouterRenderSnapshot, getRouterRenderProfile, matchContext, registerRouterRenderProfile, restoreRouterRenderSnapshot, routerContext } from "@octanejs/tanstack-router";
+import { hasUnchangedOctaneFileRouteHead } from "./routes.mjs";
+import { OCTANE_WORKER_CONTEXT_KEYS, getOctaneWorkerRouterRewrite, registerOctaneWorkerContext } from "./worker-federation-contexts.mjs";
+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 = 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 assertFileRouteRenderHost(router, allowRewrite) {
+    if (router.options.parseSearch !== defaultParseSearch || router.options.stringifySearch !== defaultStringifySearch || !allowRewrite && router.options.rewrite || router.options.routeMasks?.length) throw new TypeError('Router render snapshot: authored router behavior requires an exact local profile');
+    const authoredRouting = [
+        'caseSensitive',
+        'validateSearch',
+        'loaderDeps',
+        'beforeLoad',
+        'context',
+        'onEnter',
+        'onStay',
+        'onLeave',
+        'lazyFn',
+        "scripts",
+        'headers',
+        'onError',
+        'parseParams',
+        'stringifyParams'
+    ];
+    const seen = new Set();
+    const visit = (route, depth)=>{
+        if (seen.has(route) || seen.size >= 4096 || depth > 64) throw new TypeError('Router render snapshot: route geometry must be bounded and acyclic');
+        seen.add(route);
+        if (authoredRouting.some((key)=>void 0 !== Reflect.get(route.options, key)) || route.options.params?.parse || route.options.params?.stringify || route.options.search?.middlewares?.length || route.lazyFn || 'path' in route.options && 'id' in route.options || !hasUnchangedOctaneFileRouteHead(route)) throw new TypeError('Router render snapshot: authored route behavior requires an exact local profile');
+        for (const child of route.children ?? [])visit(child, depth + 1);
+    };
+    visit(router.options.routeTree, 0);
+}
+function ensureDefaultProfile() {
+    if (profileRegistered) return;
+    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');
+            assertFileRouteRenderHost(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 createRouterRenderRouteTree(snapshot.routes);
+        },
+        routingOptions: (snapshot)=>{
+            const defaults = {
+                parseSearch: defaultParseSearch,
+                stringifySearch: defaultStringifySearch
+            };
+            const i18n = rewriteDescriptor(snapshot.i18n);
+            if (!i18n) return defaults;
+            const codec = 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
+    });
+    associateRouterRenderProfile(router, {
+        id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+        publicContext: context
+    });
+}
+function captureOctaneRouterSnapshot(router) {
+    const origin = origins.get(router);
+    const declared = getRouterRenderProfile(router);
+    if (origin && declared?.key === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.key && declared.version === OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE.version) {
+        const i18n = nativeRewriteDescriptor(router);
+        associateRouterRenderProfile(router, {
+            id: OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE,
+            publicContext: origin.publicContext,
+            ...void 0 === i18n ? {} : {
+                i18n
+            }
+        });
+    }
+    return captureRouterRenderSnapshot(router);
+}
+let registrations = 0;
+let releaseContexts;
+function registerOctaneRouterWorkerContexts() {
+    ensureDefaultProfile();
+    if (!releaseContexts) {
+        const releaseRouter = registerOctaneWorkerContext(routerContext, {
+            key: OCTANE_WORKER_CONTEXT_KEYS.router,
+            encode: (value)=>{
+                if (!value) throw new TypeError('Missing native router provider');
+                return captureOctaneRouterSnapshot(value);
+            },
+            decode: (value, signal)=>restoreRouterRenderSnapshot(value, {
+                    signal
+                }),
+            dispose: (value)=>{
+                if (value) disposeRouterRenderSnapshot(value);
+            },
+            isProvided: (value)=>void 0 !== value
+        });
+        try {
+            const releaseMatch = registerOctaneWorkerContext(matchContext, {
+                key: OCTANE_WORKER_CONTEXT_KEYS.match,
+                encode: nonempty,
+                decode: nonempty,
+                validate: (value, readContext)=>{
+                    const selected = readContext(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;
+        }
+    };
+}
+export { OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE, associateOctaneFileRouteSnapshot, captureOctaneRouterSnapshot, registerOctaneRouterWorkerContexts };

package/dist/esm/router-handler.mjs

@@ -52,8 +52,8 @@ function requestHeaders(router) {
         if (field?.get || field?.set) throw new TypeError('Native Octane response headers must be owned values');
         appendHeaders(headers, field?.value);
     }
-    const redirect = router.stores.redirect.get();
-    if (redirect) appendHeaders(headers, redirect.headers);
+    const result = router._serverResult;
+    if (result?.type === 'redirect') appendHeaders(headers, result.redirect.headers);
     return headers;
 }
 function createOctaneRequestHandler({ createRouter, request, session, getRouterManifest, serialization }) {
@@ -74,7 +74,6 @@ function createOctaneRequestHandler({ createRouter, request, session, getRouterM
                     ...serialization?.forbiddenValues ?? []
                 ]
             });
-            session.registerCleanup(()=>router.cancelMatches());
             const { url } = getNormalizedURL(request.url, 'http://localhost');
             const href = url.href.replace(url.origin, '');
             router.update({
@@ -86,11 +85,13 @@ function createOctaneRequestHandler({ createRouter, request, session, getRouterM
                 }),
                 origin: router.options.origin ?? getOrigin(request)
             });
-            await withAbort(router.load(), session.signal);
+            await withAbort(router.load({
+                _signal: session.signal
+            }), session.signal);
             guard.assertActive();
-            const redirect = router.stores.redirect.get();
-            if (redirect) {
-                const resolved = router.resolveRedirect(redirect);
+            const loadResult = router._serverResult;
+            if (loadResult?.type === 'redirect') {
+                const resolved = loadResult.redirect;
                 const headers = requestHeaders(router);
                 return new Response(null, {
                     status: resolved.status,
@@ -101,7 +102,9 @@ function createOctaneRequestHandler({ createRouter, request, session, getRouterM
             guard.assertMatches();
             const serverSsr = router.serverSsr;
             if (!serverSsr) throw new Error('Native Octane router SSR state is required');
-            await withAbort(serverSsr.dehydrate(), session.signal);
+            await withAbort(serverSsr.dehydrate({
+                signal: session.signal
+            }), session.signal);
             guard.assertActive();
             const responseHeaders = requestHeaders(router);
             const rendered = Promise.resolve(callback({

package/dist/esm/router-server.mjs

@@ -7,6 +7,5 @@ function OctaneRouterServer({ router }) {
     });
 }
 export { createOctaneRequestHandler } from "./router-handler.mjs";
-export { createOctaneRouterInjection } from "./router-injection.mjs";
 export { prepareOctaneRouterSerialization } from "./router-server-snapshot.mjs";
 export { OctaneRouterServer };

package/dist/esm/router.mjs

@@ -1,6 +1,6 @@
 import { createDataClient } from "@modern-js/renderer-core/data";
 import { RouterProvider, createRouter, redirect, useMatch, useRouter } from "@octanejs/tanstack-router";
-import { createSubSlot, useCallback, useEffect, useRef } from "octane";
+import { createSubSlot, useCallback, useLayoutEffect, useRef } from "octane";
 import { assertOctaneIdentity } from "./bootstrap.mjs";
 import { RouteDataError, createFileSystemRouteTree, matchApplicationRouteIds, matchApplicationRoutes, resolveRouteData, selectApplicationDataRoute } from "./routes.mjs";
 export * from "@octanejs/tanstack-router";
@@ -69,7 +69,7 @@ function useOctaneRouteAction(...args) {
     const identity = useApplicationIdentity();
     const routeId = useApplicationRouteId();
     const owner = useRef(null, actionSlot(slot, 'owner'));
-    useEffect(()=>{
+    useLayoutEffect(()=>{
         const controller = new AbortController();
         owner.current = controller;
         return ()=>controller.abort(new DOMException('The route action owner unmounted', 'AbortError'));

package/dist/esm/routes.mjs

@@ -1,6 +1,10 @@
 import { RouteDataError, loadFileSystemRoute, matchApplicationRouteIds, matchApplicationRoutes, nativeRoutePath, resolveRouteData, selectApplicationDataRoute, splitFileSystemRoutes } from "@modern-js/renderer-core/router";
 import { ErrorComponent, HeadContent, Outlet, Scripts, createRootRoute, createRoute, notFound, redirect } from "@octanejs/tanstack-router";
 import { Fragment, createElement } from "octane";
+const fileRouteHeads = new WeakMap();
+function hasUnchangedOctaneFileRouteHead(route) {
+    return fileRouteHeads.get(route) === route.options.head;
+}
 function routes_resolveRouteData(routeId, outcome) {
     return resolveRouteData({
         redirect: redirect,
@@ -10,21 +14,12 @@ function routes_resolveRouteData(routeId, outcome) {
 function isReactiveNativeMatch(value) {
     return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
 }
-function observeRouteCompletion(router, controller, signal, completion) {
+function observeRouteCompletion(router, routeId, controller, signal, completion) {
     completion.catch((error)=>{
         if (signal.aborted) return;
-        const match = [
-            ...router.stores.pendingMatches.get(),
-            ...router.stores.matches.get(),
-            ...router.stores.cachedMatches.get()
-        ].find((candidate)=>candidate.abortController === controller);
-        if (!match) return;
-        const store = [
-            router.stores.pendingMatchStores.get(match.id),
-            router.stores.matchStores.get(match.id),
-            router.stores.cachedMatchStores.get(match.id)
-        ].find((candidate)=>candidate?.get().abortController === controller);
-        if (!store) return;
+        const route = Object.values(router.routesById).find((candidate)=>candidate.options.staticData?.ultramodernRouteId === routeId);
+        if (!route) return;
+        const store = router.stores.getMatchStore(route.id);
         let subscription;
         let settled = false;
         const cleanup = ()=>{
@@ -35,9 +30,10 @@ function observeRouteCompletion(router, controller, signal, completion) {
             settled = true;
             cleanup();
         };
-        const publish = ()=>{
+        const publish = async ()=>{
             if (settled) return;
             const current = store.get();
+            if (!current) return;
             if (current.abortController !== controller || signal.aborted || 'pending' !== current.status && 'success' !== current.status) return void onAbort();
             if ('success' !== current.status || current.isFetching) return;
             settled = true;
@@ -45,17 +41,19 @@ function observeRouteCompletion(router, controller, signal, completion) {
             const route = router.routesById[current.routeId];
             let failure = error;
             try {
+                await route?.options.errorComponent?.preload?.();
+                if (signal.aborted || store.get()?.abortController !== controller) return;
                 route?.options.onError?.(failure);
             } catch (onErrorFailure) {
                 failure = onErrorFailure;
             }
             if (signal.aborted) return;
-            router.updateMatch(match.id, (previous)=>previous.abortController !== controller || 'success' !== previous.status || previous.isFetching ? previous : {
+            router.stores.setMatches(router.stores.matches.get().map((previous)=>previous.routeId !== route.id || previous.abortController !== controller || 'success' !== previous.status || previous.isFetching ? previous : {
                     ...previous,
                     error: failure,
                     status: 'error',
                     isFetching: false
-                });
+                }));
         };
         signal.addEventListener('abort', onAbort, {
             once: true
@@ -99,7 +97,7 @@ function createFileSystemRouteTree(routes, modules, options = {}) {
                         await Promise.resolve();
                         signal.throwIfAborted();
                         if (failed) throw failure;
-                        observeRouteCompletion(router, match.abortController, signal, outcome.completion);
+                        observeRouteCompletion(router, route.id, match.abortController, signal, outcome.completion);
                     }
                     options.onOutcome?.(route.id, outcome);
                     return routes_resolveRouteData(route.id, outcome);
@@ -120,6 +118,7 @@ function createFileSystemRouteTree(routes, modules, options = {}) {
         ...rootBindings,
         component: OctaneDocumentRoot
     });
+    fileRouteHeads.set(root, root.options.head);
     function bind(route, parent, inheritedErrorComponent) {
         const errorComponent = modules[route.id]?.errorComponent ?? inheritedErrorComponent;
         const native = createRoute({
@@ -127,8 +126,9 @@ function createFileSystemRouteTree(routes, modules, options = {}) {
             ...nativeRoutePath(route),
             ...bindings(route, errorComponent)
         });
+        fileRouteHeads.set(native, native.options.head);
         return native.addChildren(route.children.map((child)=>bind(child, native, errorComponent)));
     }
     return root.addChildren(children.map((route)=>bind(route, root, rootErrorComponent)));
 }
-export { RouteDataError, createFileSystemRouteTree, matchApplicationRouteIds, matchApplicationRoutes, routes_resolveRouteData as resolveRouteData, selectApplicationDataRoute };
+export { RouteDataError, createFileSystemRouteTree, hasUnchangedOctaneFileRouteHead, matchApplicationRouteIds, matchApplicationRoutes, routes_resolveRouteData as resolveRouteData, selectApplicationDataRoute };

package/dist/esm/server.mjs

@@ -1,8 +1,10 @@
 import { prepareDocument } from "@modern-js/renderer-core/document";
 import { untilAborted } from "@modern-js/renderer-core/session";
+import { transformReadableStreamWithRouter } from "@octanejs/tanstack-router/ssr/server";
 import { createElement, earlySignalBootstrapScript, renderToReadableStream } from "octane/server";
 import { assertNativeHydrationBuildId, assertOctaneIdentity } from "./bootstrap.mjs";
 import { FederationRoot, createFederationScope } from "./federation-context.mjs";
+import { WorkerFederationRoot } from "./worker-federation-context.mjs";
 function prepareOctaneDocument(session, document, hydrating) {
     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.');
@@ -73,12 +75,21 @@ async function renderOctaneApplication(input) {
         if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
         session.startRendering();
         let head = '';
-        const federation = input.federation ? createFederationScope(input.federation, true, document.nonce) : void 0;
+        const federation = input.federation || input.workerFederation ? createFederationScope(input.federation, true, document.nonce) : void 0;
         const App = federation ? ()=>createElement(FederationRoot, {
                 scope: federation,
                 children: 'function' == typeof input.App ? createElement(input.App, input.props) : input.App
             }) : input.App;
-        const nativeStream = await renderToReadableStream(App, input.props, {
+        const workerFederation = input.workerFederation ? {
+            transport: input.workerFederation,
+            locale: input.workerFederationLocale ?? 'default',
+            signal: session.signal
+        } : void 0;
+        const NativeApp = workerFederation ? ()=>createElement(WorkerFederationRoot, {
+                scope: workerFederation,
+                children: 'function' == typeof App ? createElement(App, input.props) : App
+            }) : App;
+        const nativeStream = await renderToReadableStream(NativeApp, input.props, {
             signal: session.signal,
             ...void 0 === document.nonce ? {} : {
                 nonce: document.nonce
@@ -91,6 +102,9 @@ async function renderOctaneApplication(input) {
                 buildId: document.nativeHydrationBuildId,
                 documentId: document.documentId
             },
+            externalSnapshots: {
+                documentId: document.documentId
+            },
             headChannel: 'separate',
             onHeadReady (value) {
                 head = value;
@@ -174,7 +188,14 @@ async function renderOctaneApplication(input) {
         }, {
             highWaterMark: 0
         });
-        return session.respond(body);
+        return session.respond(input.router ? transformReadableStreamWithRouter(input.router, body, {
+            signal: session.signal,
+            rendererSafePoint: "script-close",
+            timeoutMs: input.routerSerializationTimeoutMs,
+            onAbort: (reason)=>{
+                session.fail(reason);
+            }
+        }) : body);
     } catch (error) {
         await session.fail(error);
         throw error;

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

@@ -0,0 +1,19 @@
+import { createContext, createElement } from "octane";
+import { FederationApplication } from "./federation-context.mjs";
+const WorkerFederationContext = createContext(null);
+function WorkerFederationRoot(props) {
+    return createElement(WorkerFederationContext, {
+        value: props.scope,
+        children: props.children
+    });
+}
+function WorkerFederationApplication(props) {
+    return createElement(WorkerFederationRoot, {
+        scope: props.scope,
+        children: props.federation ? createElement(FederationApplication, {
+            scope: props.federation,
+            application: props.application
+        }) : createElement(props.application.default, props.application.props)
+    });
+}
+export { WorkerFederationApplication, WorkerFederationContext, WorkerFederationRoot };

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

@@ -0,0 +1,47 @@
+import { registerExternalSnapshotContext, useContext } from "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 = registerExternalSnapshotContext(context, codec);
+    const hasProvider = ()=>isProvided(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;
+}
+export { OCTANE_WORKER_CONTEXT_KEYS, getOctaneWorkerRouterRewrite, registerOctaneWorkerContext, registerOctaneWorkerRouterRewrite, useOctaneWorkerContextKeys };

package/dist/esm/worker-federation.mjs

@@ -0,0 +1,59 @@
+import { createWorkerFederationTransport } from "@modern-js/renderer-core/worker-federation";
+import { prepareExternalSnapshotRequest, releasePreparedExternalSnapshotRequest, renderExternalSnapshot, serializeExternalSnapshot } from "octane/server";
+import { FederationContext, createFederationScope } from "./federation-context.mjs";
+import { WorkerFederationContext } from "./worker-federation-context.mjs";
+function isNativeWorkerComponent(value) {
+    return 'function' == typeof value;
+}
+function createNativeWorkerFederationRuntime(options, compiler) {
+    const { resources } = options;
+    const bindings = options.bindings;
+    const transport = resources.workerFederationServices?.length ? 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(FederationContext, createFederationScope(void 0, true, request.nonce));
+                    provide(WorkerFederationContext, {
+                        transport,
+                        locale: admitted.locale,
+                        signal
+                    });
+                } : void 0;
+                return prepareExternalSnapshotRequest(payload, {
+                    authority: admitted.coordinate.native,
+                    signal,
+                    ...initializeContexts ? {
+                        initializeContexts
+                    } : {}
+                });
+            },
+            releaseNativeRequest: 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 serializeExternalSnapshot(await renderExternalSnapshot(component, request));
+            }
+        });
+    }
+    return {
+        transport,
+        handleRequest: handle ?? (()=>Promise.resolve(void 0))
+    };
+}
+export { createNativeWorkerFederationRuntime };

package/dist/esm-node/manifest.mjs

@@ -1,7 +1,7 @@
 import { nativeModuleManifestFilename, readRendererIdentity } from "@modern-js/renderer-core/identity";
 import { assertNativeHydrationBuildId, assertOctaneIdentity } from "./bootstrap.mjs";
-const OCTANE_RUNTIME_VERSION = '0.7.1+ultramodern.1331985ea3b0';
-const OCTANE_COMPILER_VERSION = '0.1.55';
+const OCTANE_RUNTIME_VERSION = '0.13.8';
+const OCTANE_COMPILER_VERSION = '0.2.4';
 function octaneModuleManifestFileName(entryName) {
     return nativeModuleManifestFilename('octane', entryName);
 }

package/dist/esm-node/plugin/compiler.mjs

@@ -20,7 +20,8 @@ function createOctaneCompilerPlugin(options) {
             const directory = pluginSourceDirectory();
             const require = createRequire(node_path.join(directory, 'index.cjs'));
             const { OctaneCompilerManifestPlugin } = require('./compiler-manifest.cjs');
-            const { inferRspackEnvironment, OctaneRspackPlugin } = require('@octanejs/rspack-plugin');
+            const appRequire = createRequire(node_path.join(api.context.rootPath, 'package.json'));
+            const { inferRspackEnvironment, OctaneRspackPlugin } = appRequire('@octanejs/rspack-plugin');
             api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
                     source: {
                         include: [
@@ -30,10 +31,6 @@ function createOctaneCompilerPlugin(options) {
                 }));
             api.modifyRspackConfig((config, { environment: rsbuildEnvironment })=>{
                 const environment = rsbuildEnvironment.name === options.workerEnvironmentName ? 'server' : inferRspackEnvironment(config.target);
-                config.resolve ??= {};
-                const extensions = (config.resolve.extensions ?? []).filter((extension)=>'.tsrx' !== extension);
-                extensions.splice(Math.max(extensions.indexOf('.ts'), extensions.indexOf('.tsx')) + 1, 0, '.tsrx');
-                config.resolve.extensions = extensions;
                 config.plugins ??= [];
                 config.plugins.push(new OctaneRspackPlugin({
                     root: api.context.rootPath,