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

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

@@ -0,0 +1,216 @@
+import { assertDefaultRouterRenderHost, associateRouterRenderProfile, captureRouterRenderSnapshot, createRouterRenderRouteTree, defaultParseSearch, defaultStringifySearch, disposeRouterRenderSnapshot, getRouterRenderProfile, matchContext, registerRouterRenderProfile, restoreRouterRenderSnapshot, routerContext } from "@octanejs/tanstack-router";
+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 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');
+            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 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/server.mjs

@@ -4,6 +4,7 @@ import { transformReadableStreamWithRouter } from "@octanejs/tanstack-router/ssr
 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.');
@@ -74,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
@@ -92,6 +102,9 @@ async function renderOctaneApplication(input) {
                 buildId: document.nativeHydrationBuildId,
                 documentId: document.documentId
             },
+            externalSnapshots: {
+                documentId: document.documentId
+            },
             headChannel: 'separate',
             onHeadReady (value) {
                 head = value;

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/plugin/index.mjs

@@ -77,7 +77,7 @@ const rendererAdapter = defineRendererAdapter({
     create: {
         templates: {
             federation: true,
-            workers: false
+            workers: true
         },
         dependencies: (profile, { typescriptVersion })=>({
                 frameworkDependencies: [

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

@@ -22,7 +22,7 @@ const octaneProfile = {
         name: '@octanejs/tanstack-router',
         version: '0.2.10',
         coreName: '@tanstack/router-core',
-        coreVersion: '1.171.34'
+        coreVersion: '1.171.38'
     },
     sourceExtensions: [
         '.tsx',
@@ -33,9 +33,10 @@ const octaneProfile = {
     jsxImportSource: 'octane',
     dependencies: {
         '@tsrx/oxc': '0.20.0',
-        octane: 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octane-0.13.8.tgz',
-        '@octanejs/tanstack-router': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octanejs-tanstack-router-0.2.10.tgz',
-        '@octanejs/rspack-plugin': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-d5988dd93614/octanejs-rspack-plugin-0.2.4.tgz',
+        octane: 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octane-0.13.8.tgz',
+        '@octanejs/tanstack-router': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octanejs-tanstack-router-0.2.10.tgz',
+        '@octanejs/rspack-plugin': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-0bf2313bbdfb/octanejs-rspack-plugin-0.2.4.tgz',
+        '@tanstack/router-core': 'https://github.com/BleedingDev/router/releases/download/ultramodern-router-core-585d3233f7f5/tanstack-router-core-1.171.38.tgz',
         '@modern-js/renderer-octane': '3.8.3',
         seroval: '1.6.9',
         'seroval-plugins': '1.6.9'

package/dist/types/client.d.ts

@@ -1,6 +1,7 @@
 import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
 import { type RendererIdentity } from '@modern-js/renderer-core/identity';
 import { type ComponentBody, type Root, type RootContainer, type RootOptions } from 'octane';
+import { type OctaneWorkerFederationFactory, type OctaneWorkerFederationScope } from './worker-federation-context';
 export type { OctaneDocumentBootstrap } from './bootstrap';
 export { readOctaneDocumentBootstrap } from './bootstrap';
 export interface OctaneApplicationModule {
@@ -23,9 +24,12 @@ export interface OctaneApplicationOptions {
     readonly signal?: AbortSignal;
     /** Hydration installs the native signal bridge before invoking this importer. */
     readonly load: () => Promise<OctaneApplicationModule>;
-    readonly options?: Omit<RootOptions, 'signalOwner'>;
+    readonly options?: Omit<RootOptions, 'signalOwner' | 'externalSnapshots'>;
     /** This browser compilation's native Module Federation runtime. */
     readonly federation?: NativeFederationBinding;
+    readonly workerFederation?: OctaneWorkerFederationScope | OctaneWorkerFederationFactory;
+    /** Trusted document bootstrap identity, also present for a CSR document. */
+    readonly documentId?: string;
 }
 export interface OctaneHydrationOptions extends OctaneApplicationOptions {
     readonly documentIdentity: RendererIdentity;

package/dist/types/entry-client.d.ts

@@ -1,8 +1,10 @@
 import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
 import { type NativeClientEntryOptions, type NativeI18nInstance } from '@modern-js/renderer-core/entry-client';
+import type { OctaneWorkerFederationFactory, OctaneWorkerFederationScope } from './worker-federation-context';
 export interface OctaneClientEntryOptions extends NativeClientEntryOptions<NativeI18nInstance, LocalisedUrlsOption> {
     /** The native client compilation hash, `__webpack_hash__`. */
     readonly nativeHydrationBuildId: string;
+    readonly workerFederation?: OctaneWorkerFederationScope | OctaneWorkerFederationFactory;
 }
 /** Start a generated Octane browser entry: mount, or hydrate the server document. */
 export declare function startNativeClient(options: OctaneClientEntryOptions): void;

package/dist/types/entry-server.d.ts

@@ -6,6 +6,9 @@ import type { ResponsePolicy } from '@modern-js/renderer-core/session';
  * declares for the document itself are kept, as Solid document headers are.
  */
 export declare function withOctaneDocumentFields(policy: ResponsePolicy, responseHeaders: Headers): ResponsePolicy;
-export type OctaneServerEntryOptions = NativeServerEntryOptions<NativeI18nInstance, LocalisedUrlsOption>;
+export { createNativeWorkerFederationRuntime } from './worker-federation';
+export interface OctaneServerEntryOptions extends NativeServerEntryOptions<NativeI18nInstance, LocalisedUrlsOption> {
+    readonly workerFederationLocale?: string;
+}
 /** The native transport handlers of a generated Octane server entry. */
 export declare function createNativeServerEntry(options: OctaneServerEntryOptions): NativeServerEntry;

package/dist/types/federation.d.ts

@@ -8,6 +8,8 @@ export interface FederatedComponentOptions {
     readonly fallback?: () => OctaneNode;
     /** A positive load limit; the server defaults to 3000ms. */
     readonly timeout?: number;
+    /** Explicit registered server projections required by an application remote. */
+    readonly contextKeys?: readonly string[];
 }
 /**
  * Render a native Octane remote by its `remote/Expose` id or a browser loader.

package/dist/types/i18n/LocalizedLink.d.ts

@@ -1,41 +1,14 @@
 import { type OctaneNode } from 'octane';
-import { type LinkComponentProps } from '../router';
-export interface LocalizedLinkProps {
+import { type AnyRouter, type LinkComponentProps } from '../router';
+export interface LocalizedLinkProps extends Omit<LinkComponentProps<'a', AnyRouter, string, string>, 'to' | 'mask' | 'href' | 'publicHref' | '_fromLocation'> {
     /** A canonical, language-agnostic target, e.g. `/products/red-shoe`. */
     to: string;
     /** Localize for a specific language instead of the current one. */
     language?: string;
-    children?: unknown;
-    class?: string;
-    activeProps?: LinkComponentProps<'a'>['activeProps'];
-    inactiveProps?: LinkComponentProps<'a'>['inactiveProps'];
-    activeOptions?: LinkComponentProps<'a'>['activeOptions'];
-    replace?: boolean;
-    preload?: LinkComponentProps<'a'>['preload'];
 }
 /**
- * A thin wrapper over the native Octane router `Link`
- * (`@octanejs/tanstack-router`'s precompiled `Link.tsrx`) that localizes a
- * canonical `to` for the current (or an explicit) language before handing it
- * to the real link — the same contract as `@modern-js/plugin-i18n`'s React
- * `Link`. It resolves the href itself via the shared pathname helpers, so it
- * works with or without the router's i18n `rewrite`. Every link, including
- * one to another language, is the native `Link`: navigation, preloading and
- * active state stay with the router.
- *
- * Under the i18n `rewrite` the router matches canonical paths and localizes
- * outgoing locations to the current language, so a link to another language
- * routes to the canonical `to` and publishes the target language's URL as a
- * route mask (the rewrite keeps a mask's explicit language). The entry's
- * router language synchronization (`syncWithRouter`) switches the i18next
- * instance from the navigated URL, as it does for history navigation.
- *
- * No JSX: built with `createElement`, matching this package's existing
- * style (see `src/routes.ts`).
+ * The native router owns client navigation, preloading and active state. Its mask
+ * keeps the canonical route while publishing the selected language URL;
+ * the entry's i18n router subscription synchronizes the instance on navigation.
  */
 export declare function LocalizedLink(props: LocalizedLinkProps): OctaneNode;
-/**
- * Language-invariant active check: `to="/products"` is active whether the
- * current location is `/en/products` or `/produkty` under a mapped locale.
- */
-export declare function useIsLocalizedActive(canonicalTarget: string): boolean;

package/dist/types/i18n/context.d.ts

@@ -3,7 +3,7 @@ export type { I18nContextValue, I18nInstanceLike } from './types';
 /**
  * Octane's `createContext<T>(defaultValue: T)` requires a default (unlike
  * Solid 2's default-less form), so a missing provider is detected by
- * checking for `null` in `useI18n`/`useIsLocalizedActive` instead — the same
+ * checking for `null` in `useI18n`/`LocalizedLink` instead — the same
  * guard shape `@modern-js/plugin-i18n`'s React `ModernI18nContext` uses.
  */
 export declare const I18nContext: import("octane").Context<I18nContextValue | null>;

package/dist/types/i18n/index.d.ts

@@ -3,7 +3,7 @@ export { createI18nSsrHandoffInlineData, I18N_SSR_HANDOFF_ELEMENT_ID, type I18nS
 export { type CreateI18nUrlRewriteOptions, createI18nUrlRewrite, type I18nLocationRewrite, } from '@modern-js/i18n-runtime-extensions/urlRewrite';
 export { I18nContext } from './context';
 export { I18nProvider, type I18nProviderProps } from './I18nProvider';
-export { LocalizedLink, type LocalizedLinkProps, useIsLocalizedActive, } from './LocalizedLink';
+export { LocalizedLink, type LocalizedLinkProps } from './LocalizedLink';
 export { type OctaneLatestLanguageSyncOptions, useLatestLanguageSync, } from './languageSync';
 export type { I18nContextValue, I18nInstanceLike } from './types';
 export { type UseI18nReturn, useI18n } from './useI18n';

package/dist/types/i18n-external-snapshot.d.ts

@@ -0,0 +1,43 @@
+import { type NativeI18nRewriteSnapshot } from '@modern-js/i18n-runtime-extensions/native';
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import type { NativeLocationRewrite } from '@modern-js/renderer-core/router';
+import { type i18n as I18nInstance, type Resource } from 'i18next';
+import type { I18nContextValue, I18nInstanceLike } from './i18n/types';
+export type I18nSnapshotJson = null | boolean | number | string | I18nSnapshotJson[] | I18nSnapshotOptions;
+export interface I18nSnapshotOptions {
+    [key: string]: I18nSnapshotJson;
+}
+export interface OctaneI18nProfileId {
+    key: string;
+    version: string;
+}
+export interface OctaneI18nSnapshot {
+    version: 1;
+    profile: OctaneI18nProfileId;
+    language: string;
+    languages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+    options: I18nSnapshotOptions;
+    resources: Resource;
+}
+/** Named profiles install their custom translation functions locally. */
+export interface OctaneI18nSnapshotProfile extends OctaneI18nProfileId {
+    captureOptions(instance: I18nInstanceLike): Readonly<I18nSnapshotOptions>;
+    validateOptions(options: Readonly<I18nSnapshotOptions>): void;
+    create(input: {
+        language: string;
+        options: Readonly<I18nSnapshotOptions>;
+        resources: Resource;
+        signal?: AbortSignal;
+    }): I18nInstance | Promise<I18nInstance>;
+    dispose?(instance: I18nInstance): void;
+}
+export declare function captureOctaneI18nRewriteSnapshot(rewrite: NativeLocationRewrite): NativeI18nRewriteSnapshot;
+export declare function restoreOctaneI18nRewriteSnapshot(value: unknown): NativeLocationRewrite;
+export declare function registerOctaneI18nSnapshotProfile(profile: OctaneI18nSnapshotProfile): () => void;
+export declare function associateOctaneI18nSnapshotProfile(instance: I18nInstanceLike, id: OctaneI18nProfileId): void;
+/** Built-in translation behavior only. Custom per-call processors need a profile. */
+export declare function captureOctaneI18nSnapshot(value: I18nContextValue): OctaneI18nSnapshot;
+export declare function restoreOctaneI18nSnapshot(value: unknown, signal?: AbortSignal): Promise<I18nContextValue>;
+export declare function disposeOctaneI18nSnapshot(value: I18nContextValue): void;
+export declare function registerOctaneI18nWorkerContexts(): () => void;

package/dist/types/router-external-snapshot.d.ts

@@ -0,0 +1,10 @@
+import { type AnyRouter, type RouterRenderSnapshot } from '@octanejs/tanstack-router';
+export declare const OCTANE_FILE_ROUTE_SNAPSHOT_PROFILE: Readonly<{
+    key: "ultramodern.file-routes";
+    version: "1";
+}>;
+/** Associate the genuine router produced by the generated file-route factory. */
+export declare function associateOctaneFileRouteSnapshot(router: AnyRouter): void;
+export declare function captureOctaneRouterSnapshot(router: AnyRouter): RouterRenderSnapshot;
+/** Startup registration uses the actual physical native router/match Contexts. */
+export declare function registerOctaneRouterWorkerContexts(): () => void;

package/dist/types/server.d.ts

@@ -1,6 +1,7 @@
 import { type DocumentAsset, type DocumentInlineData } from '@modern-js/renderer-core/document';
 import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
 import { type RequestSession, type ResponsePolicy } from '@modern-js/renderer-core/session';
+import type { WorkerFederationTransport } from '@modern-js/renderer-core/worker-federation';
 import type { AnyRouter } from '@octanejs/tanstack-router';
 import { type ServerRenderNode, type StreamOptions } from 'octane/server';
 export interface OctaneDocumentOptions {
@@ -32,6 +33,8 @@ export interface RenderOctaneApplicationOptions<Bindings extends object = object
     readonly routerSerializationTimeoutMs?: number;
     /** This server compilation's native Module Federation runtime. */
     readonly federation?: NativeFederationBinding;
+    readonly workerFederation?: WorkerFederationTransport;
+    readonly workerFederationLocale?: string;
 }
 /** Deliver the CSR document; native browser mounting owns the empty root. */
 export declare function renderOctaneCSRDocument<Bindings extends object>(input: OctaneDocumentResponseOptions<Bindings>): Promise<Response>;

package/dist/types/worker-federation-context.d.ts

@@ -0,0 +1,34 @@
+import type { WorkerFederationTransport } from '@modern-js/renderer-core/worker-federation';
+import { FederationApplication, type OctaneFederationScope } from './federation-context';
+export interface OctaneWorkerFederationScope {
+    readonly transport: WorkerFederationTransport;
+    /** Compiled entry fallback; localized providers supply their live language. */
+    readonly locale: string;
+    /** Own document disposal; each lazy admission also owns its waiter deadline. */
+    readonly signal?: AbortSignal;
+}
+export type OctaneWorkerFederationFactory = (signal: AbortSignal) => OctaneWorkerFederationScope;
+/** Each native document owns its transport and captured publisher authorities. */
+export declare const WorkerFederationContext: import("octane").Context<OctaneWorkerFederationScope | null>;
+export declare function WorkerFederationRoot(props: {
+    readonly scope: OctaneWorkerFederationScope;
+    readonly children?: unknown;
+}): import("octane").ElementDescriptor<{
+    value: OctaneWorkerFederationScope;
+    children: unknown;
+}>;
+/** Stable native root used for startup and application updates alike. */
+export declare function WorkerFederationApplication(props: {
+    readonly scope: OctaneWorkerFederationScope;
+    readonly federation?: OctaneFederationScope;
+    readonly application: Parameters<typeof FederationApplication>[0]['application'];
+}): import("octane").ElementDescriptor<{
+    scope: OctaneWorkerFederationScope;
+    children: import("octane").ElementDescriptor<unknown> | import("octane").ElementDescriptor<{
+        scope: OctaneFederationScope;
+        application: {
+            readonly default: import("octane").ComponentBody;
+            readonly props?: unknown;
+        };
+    }>;
+}>;