@bleedingdev/modern-js-ultramodern-app-tools 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

package/README.md

@@ -142,7 +142,9 @@ export default defineConfig(
 The workspace preset reads `topology/reference-topology.json` and
 `topology/local-overlays/development.json` relative to that config. Those records
 provide app identity, renderer, development ports, composed remote references
-and delivery unit identity. An authored `renderer` must match the topology.
+and delivery unit identity. An authored `renderer` must match the topology. A
+headless (API-only) unit declares renderer `none` and no Module Federation
+name; its config selects no `renderer`.
 Adding a shell or vertical changes the records; existing application configs
 keep their authored contents.
 

package/bin/ultramodern.mjs

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises';
 const [major, minor] = process.versions.node.split('.').map(Number);
 if (major < 26 || (major === 26 && minor < 10)) {
   console.error(
-    `UltraModern.js requires Node.js >=26.10.0; detected v${process.versions.node}.`,
+    `UltraModern.js requires Node.js >=26.12.0; detected v${process.versions.node}.`,
   );
   process.exit(1);
 }

package/dist/cjs/native-composition/config-metadata.js

@@ -47,8 +47,12 @@ const external_node_module_namespaceObject = require("node:module");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_url_namespaceObject = require("node:url");
+const cli_namespaceObject = require("@modern-js/plugin/cli");
 const core_namespaceObject = require("@rsbuild/core");
 const external_config_js_namespaceObject = require("./config.js");
+const external_config_read_context_js_namespaceObject = require("./config-read-context.js");
+const external_native_i18n_js_namespaceObject = require("./native-i18n.js");
+const external_renderer_router_resolution_js_namespaceObject = require("./renderer-router-resolution.js");
 function inside(directory, file) {
     const relative = external_node_path_default().relative(directory, file);
     return '' !== relative && !relative.startsWith(`..${external_node_path_default().sep}`) && '..' !== relative && !external_node_path_default().isAbsolute(relative);
@@ -115,11 +119,76 @@ async function readUltramodernConfigMetadata(options) {
             appDirectory,
             configFile: options.configFile,
             env: options.env,
-            command: options.command
+            command: options.analyzeServerRoutes ? 'metadata' : options.command
         });
+        const installedAppDirectory = options.stagedWorkspace && (appDirectory === external_node_path_default().resolve(options.stagedWorkspace.root) || inside(external_node_path_default().resolve(options.stagedWorkspace.root), appDirectory)) ? external_node_path_default().resolve(options.stagedWorkspace.originalRoot, external_node_path_default().relative(options.stagedWorkspace.root, appDirectory)) : appDirectory;
+        if (options.analyzeServerRoutes) {
+            const previousArgv = process.env.MODERN_ARGV;
+            process.env.MODERN_ARGV = 'node modern metadata';
+            const cli = (0, cli_namespaceObject.createCli)();
+            let cleanup;
+            try {
+                return await (0, external_config_read_context_js_namespaceObject.withEntryMetadataRead)(async ()=>{
+                    const { appContext } = await cli.init({
+                        cwd: appDirectory,
+                        configFile: false,
+                        config: loaded.config,
+                        command: 'metadata',
+                        internalPlugins: [
+                            {
+                                name: '@modern-js/ultramodern-route-metadata-context',
+                                setup (api) {
+                                    api.updateAppContext({
+                                        configFile: loaded.configFile
+                                    });
+                                    cleanup = ()=>api.getHooks().onBeforeExit.call();
+                                }
+                            }
+                        ]
+                    });
+                    const context = appContext.pluginAPI.getAppContext();
+                    const entrypoints = context.entrypoints ?? [];
+                    if (!entrypoints.length) throw new Error('UltraModern analyzed configuration has no application entries');
+                    const entryBasePaths = {};
+                    for (const entry of entrypoints){
+                        const prefixes = [
+                            ...new Set((context.serverRoutes ?? []).filter((route)=>route.entryName === entry.entryName && !route.isApi).map((route)=>route.urlPath))
+                        ];
+                        if (1 !== prefixes.length || 'string' != typeof prefixes[0]) throw new Error(`Native Worker federation entry ${entry.entryName} requires exactly one analyzed public route prefix.`);
+                        entryBasePaths[entry.entryName] = prefixes[0];
+                    }
+                    const entries = entrypoints.map(({ entryName, isMainEntry })=>({
+                            entryName,
+                            isMainEntry
+                        }));
+                    const primary = entries.find((entry)=>entry.isMainEntry) ?? entries[0];
+                    const renderer = loaded.config.renderer;
+                    const routerBindings = await (0, external_renderer_router_resolution_js_namespaceObject.resolveEntrypointRouterBindings)(renderer, entrypoints, context.plugins.map((plugin)=>plugin.name), void 0, installedAppDirectory);
+                    const i18n = (0, external_native_i18n_js_namespaceObject.findNativeI18nConfig)(loaded.config.plugins ?? []);
+                    return {
+                        renderer,
+                        entries,
+                        primaryEntryName: primary.entryName,
+                        routerBindings,
+                        entryBasePaths,
+                        ...i18n ? {
+                            i18n
+                        } : {}
+                    };
+                });
+            } finally{
+                try {
+                    await cleanup?.();
+                } finally{
+                    cli.dispose();
+                    if (void 0 === previousArgv) delete process.env.MODERN_ARGV;
+                    else process.env.MODERN_ARGV = previousArgv;
+                }
+            }
+        }
         const resolution = await (0, external_config_js_namespaceObject.resolveUltramodernEntryIdentities)({
             appDirectory,
-            installedAppDirectory: options.stagedWorkspace && (appDirectory === external_node_path_default().resolve(options.stagedWorkspace.root) || inside(external_node_path_default().resolve(options.stagedWorkspace.root), appDirectory)) ? external_node_path_default().resolve(options.stagedWorkspace.originalRoot, external_node_path_default().relative(options.stagedWorkspace.root, appDirectory)) : appDirectory,
+            installedAppDirectory,
             config: loaded.config,
             command: options.command,
             configFile: loaded.configFile
@@ -140,7 +209,7 @@ function workerFile() {
         if (parent === directory) throw new Error('Cannot find the UltraModern app tools package root');
         directory = parent;
     }
-    return external_node_path_default().join(directory, 'dist/cjs/native-composition/config-metadata-worker.js');
+    return external_node_path_default().join(directory, 'dist/esm-node/native-composition/config-metadata-worker.mjs');
 }
 function loadUltramodernConfigMetadata(options) {
     const appDirectory = external_node_path_default().resolve(options.appDirectory);
@@ -150,7 +219,10 @@ function loadUltramodernConfigMetadata(options) {
             execArgv: [],
             env: {
                 ...process.env,
-                NODE_ENV: options.env
+                NODE_ENV: options.env,
+                ...options.analyzeServerRoutes ? {
+                    MODERN_ARGV: 'node modern metadata'
+                } : {}
             },
             stdio: [
                 'ignore',

package/dist/cjs/native-composition/module-federation-renderer-plugin.js

@@ -83,7 +83,7 @@ function resolveRendererFederationCompatibility(renderer) {
         specifier: owners.package,
         filename: (0, external_node_module_namespaceObject.createRequire)(`${bootstrap.directory}/package.json`).resolve(owners.package)
     });
-    const { protocolVersion, compiler, hydration, router } = metadata.profile;
+    const { protocolVersion, compiler, hydration, router } = (0, external_renderer_installed_profile_js_namespaceObject.projectInstalledFederationProfile)(metadata.profile, bootstrap);
     return (0, renderer_contract_namespaceObject.readRendererFederationCompatibility)({
         profile: {
             renderer,

package/dist/cjs/native-composition/native-development.js

@@ -56,6 +56,7 @@ const server_namespaceObject = require("@modern-js/renderer-core/server");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_native_build_manifest_js_namespaceObject = require("./native-build-manifest.js");
 const external_native_federation_dev_assets_js_namespaceObject = require("./native-federation-dev-assets.js");
+const external_native_federation_dev_public_path_js_namespaceObject = require("./native-federation-dev-public-path.js");
 const external_renderer_registration_js_namespaceObject = require("./renderer-registration.js");
 const allowsOrigin = (allowed, origin)=>Array.isArray(allowed) ? allowed.some((entry)=>allowsOrigin(entry, origin)) : allowed instanceof RegExp ? allowed.test(origin) : 'string' == typeof allowed ? allowed === origin : Boolean(allowed);
 async function applyDevServerHeaders(request, response, server) {
@@ -124,6 +125,15 @@ class NativeDevelopment {
                 (0, identity_namespaceObject.assertRendererIdentity)(snapshot.manifest.rendererIdentity, identity);
                 return snapshot;
             }
+            await this.waitForPublication(signal);
+        }
+    }
+    async waitForPublication(signal) {
+        for(;;){
+            signal.throwIfAborted();
+            if (this.closed) throw new Error('Native development compiler is closed');
+            if (this.failure) throw this.failure.error;
+            if (this.ready) return;
             await new Promise((resolve, reject)=>{
                 const resumed = ()=>{
                     signal.removeEventListener('abort', aborted);
@@ -150,11 +160,26 @@ class NativeDevelopment {
         if (!client?.compilation.hash || !server?.compilation.hash || !serverRoot) throw new Error('Native development requires completed client and server compilations');
         const session = this.options.getSessionIdentities();
         const entryNames = Object.keys(session.identities);
-        const federationAssets = await (0, external_native_federation_dev_assets_js_namespaceObject.collectNativeFederationDevAssets)(server, entryNames, (name)=>emittedBytes(server, name));
+        const federationAssets = new Map([
+            ...await (0, external_native_federation_dev_assets_js_namespaceObject.collectNativeFederationDevAssets)(server, entryNames, (name)=>emittedBytes(server, name)),
+            ...await (0, external_native_federation_dev_assets_js_namespaceObject.collectNativeFederationDevAssets)(client, entryNames, (name)=>emittedBytes(client, name))
+        ]);
+        const federationGraph = (0, external_native_federation_dev_assets_js_namespaceObject.nativeFederationDevGraph)(client);
+        const federationRevision = federationAssets.size ? (0, external_native_federation_dev_assets_js_namespaceObject.nativeFederationDevRevision)(federationAssets) : void 0;
+        const retainedFederationAssets = (0, external_native_federation_dev_assets_js_namespaceObject.retainNativeFederationDevAssets)(this.retainedFederationAssets, new Map([
+            ...federationAssets
+        ].map(([url, asset])=>[
+                url,
+                {
+                    ...asset,
+                    revision: federationRevision,
+                    graphManifest: federationGraph?.immutableManifest
+                }
+            ])));
         const publicPath = client.compilation.outputOptions.publicPath;
         const prefix = 'string' == typeof publicPath && 'auto' !== publicPath ? publicPath.endsWith('/') ? publicPath : `${publicPath}/` : '/';
         for (const asset of client.compilation.getAssets()){
-            if (asset.info.hotModuleReplacement || this.mutableClientAssets.has(asset.name) || this.compilerArtifacts.isMutableDevelopmentAsset(asset.name, entryNames)) continue;
+            if (true !== asset.info.immutable || asset.info.hotModuleReplacement || this.mutableClientAssets.has(asset.name) || this.compilerArtifacts.isMutableDevelopmentAsset(asset.name, entryNames)) continue;
             const pathname = new URL(`${prefix}${asset.name}`, 'http://native-dev.invalid').pathname;
             if (!this.retained.has(pathname)) this.retained.set(pathname, {
                 bytes: await emittedBytes(client, asset.name),
@@ -218,7 +243,10 @@ class NativeDevelopment {
         await promises_default().rename(temporary, manifestFile);
         return {
             entries,
-            federationAssets
+            federationAssets,
+            federationGraph,
+            federationRevision,
+            retainedFederationAssets
         };
     }
     async close() {
@@ -226,8 +254,13 @@ class NativeDevelopment {
         this.closed = true;
         this.ready = void 0;
         this.notify();
+        await this.publication.catch(()=>{});
         this.retained.clear();
         this.federationAssets = new Map();
+        this.federationRevision = void 0;
+        this.federationGraph = void 0;
+        this.federationCompilers.clear();
+        this.retainedFederationAssets = new Map();
         if (this.manifestFile) await promises_default().rm(this.manifestFile, {
             force: true
         });
@@ -238,9 +271,12 @@ class NativeDevelopment {
         this.compilerVersions = new WeakMap();
         this.compilationVersions = new WeakMap();
         this.generation = 0;
+        this.publication = Promise.resolve();
         this.closed = false;
         this.retained = new Map();
         this.federationAssets = new Map();
+        this.federationCompilers = new Set();
+        this.retainedFederationAssets = new Map();
         this.mutableClientAssets = new Set([
             'renderer-assets.json'
         ]);
@@ -279,16 +315,73 @@ class NativeDevelopment {
                     config.mode = 'development';
                     const previous = config.dev?.setupMiddlewares;
                     const retain = (middlewares)=>{
-                        middlewares.unshift((request, response, next)=>{
+                        const owner = this;
+                        middlewares.unshift(function serve(request, response, next) {
+                            if (owner.closed) return next();
                             if ('GET' !== request.method && 'HEAD' !== request.method) return next();
                             const pathname = URL.parse(request.url ?? '/', 'http://native-dev.invalid')?.pathname;
                             const protocol = request.socket instanceof external_node_tls_namespaceObject.TLSSocket ? 'https:' : 'http:';
-                            const asset = (0, external_native_federation_dev_assets_js_namespaceObject.resolveNativeFederationDevAsset)(this.federationAssets, request.url ?? '/', `${protocol}//${request.headers.host}`) || pathname && this.retained.get(pathname);
-                            if (!asset) return next();
+                            const origin = `${protocol}//${request.headers.host}`;
+                            const afterPublication = (resume)=>{
+                                const pending = new AbortController();
+                                const aborted = ()=>pending.abort(new Error('Native graph request closed'));
+                                request.once('aborted', aborted);
+                                response.once('close', aborted);
+                                if (request.aborted || response.destroyed) aborted();
+                                const cleanup = ()=>{
+                                    request.removeListener('aborted', aborted);
+                                    response.removeListener('close', aborted);
+                                };
+                                owner.waitForPublication(pending.signal).then(()=>{
+                                    cleanup();
+                                    if (!pending.signal.aborted) resume();
+                                }, (error)=>{
+                                    cleanup();
+                                    if (!pending.signal.aborted) next(error);
+                                });
+                            };
+                            if (!owner.federationGraph && [
+                                ...owner.federationCompilers
+                            ].some((compiler)=>{
+                                const manifest = (0, external_native_federation_dev_assets_js_namespaceObject.nativeFederationDevManifest)(compiler);
+                                return manifest && URL.parse(manifest)?.pathname === pathname;
+                            })) return void afterPublication(()=>{
+                                if (!owner.federationGraph) return next(new Error('Native browser manifest was not published'));
+                                serve(request, response, next);
+                            });
+                            const hotUpdate = owner.federationGraph && (0, external_native_federation_dev_public_path_js_namespaceObject.nativeFederationDevHotUpdateTarget)(owner.federationGraph.publicPath, request.url ?? '/', origin);
+                            if (hotUpdate) {
+                                request.url = hotUpdate;
+                                return next();
+                            }
+                            const federationAsset = (0, external_native_federation_dev_assets_js_namespaceObject.resolveNativeFederationDevAsset)(owner.federationAssets, request.url ?? '/', origin) ?? (owner.federationGraph && (0, external_native_federation_dev_assets_js_namespaceObject.resolveNativeFederationDevManifest)(owner.federationAssets, request.url ?? '/', owner.federationGraph.manifest));
+                            const revision = owner.federationRevision;
+                            const asset = federationAsset || pathname && owner.retained.get(pathname);
+                            if (!asset) {
+                                if (owner.federationGraph && !owner.ready && !owner.failure && (0, external_native_federation_dev_public_path_js_namespaceObject.isNativeFederationDevGraphAsset)(owner.federationGraph.publicPath, request.url ?? '/', origin)) return void afterPublication(()=>serve(request, response, next));
+                                return next();
+                            }
                             applyDevServerHeaders(request, response, api.getNormalizedConfig().server).then(()=>{
                                 response.setHeader('Content-Type', asset.contentType);
                                 response.setHeader('Content-Length', asset.bytes.length);
-                                response.setHeader('Cache-Control', 'no-store');
+                                response.setHeader('Cache-Control', asset.immutable ? 'public, max-age=31536000, immutable' : 'no-store');
+                                if (federationAsset) {
+                                    const graphManifest = asset.graphManifest ?? owner.federationGraph?.immutableManifest;
+                                    if (graphManifest) response.setHeader('Link', `<${graphManifest}>; rel="ultramodern-completed-graph"`);
+                                    const graphRevision = asset.revision ?? revision;
+                                    if (graphRevision) response.setHeader(external_native_federation_dev_assets_js_namespaceObject.NATIVE_FEDERATION_DEV_REVISION_HEADER, graphRevision);
+                                    if (api.getNormalizedConfig().server.cors) {
+                                        const previous = response.getHeader('Access-Control-Expose-Headers');
+                                        const exposed = new Set([
+                                            ...Array.isArray(previous) ? previous : String(previous ?? '').split(','),
+                                            'Link',
+                                            external_native_federation_dev_assets_js_namespaceObject.NATIVE_FEDERATION_DEV_REVISION_HEADER
+                                        ].map((value)=>value.trim()).filter(Boolean));
+                                        response.setHeader('Access-Control-Expose-Headers', [
+                                            ...exposed
+                                        ].join(','));
+                                    }
+                                }
                                 response.end('HEAD' === request.method ? void 0 : asset.bytes);
                             }, next);
                         });
@@ -309,6 +402,7 @@ class NativeDevelopment {
                         compiler
                     ];
                     for (const candidate of compilers){
+                        this.federationCompilers.add(candidate);
                         this.compilerVersions.set(candidate, 0);
                         let runVersion = 0;
                         const captureRun = ()=>{
@@ -330,28 +424,39 @@ class NativeDevelopment {
                         candidate.hooks.failed.tap('UltraModernNativeDevelopment', (error)=>this.fail(error));
                     }
                 });
-                api.onDevCompileDone(async ({ stats })=>{
+                api.onDevCompileDone(({ stats })=>{
                     const epoch = this.epoch;
-                    const results = 'stats' in stats ? stats.stats : [
-                        stats
-                    ];
-                    if (this.closed || results.some((result)=>{
-                        const version = this.compilationVersions.get(result.compilation);
-                        return void 0 === version || version !== this.compilerVersions.get(result.compilation.compiler);
-                    })) return;
-                    if (stats.hasErrors()) return this.fail(new Error('Native development compilation failed'));
-                    try {
-                        const publication = await this.publish(stats);
-                        if (this.closed || epoch !== this.epoch) return;
-                        this.federationAssets = publication.federationAssets;
-                        this.ready = publication.entries;
-                        this.failure = void 0;
-                        this.notify();
-                    } catch (error) {
+                    const publishNext = async ()=>{
                         if (this.closed || epoch !== this.epoch) return;
-                        this.fail(error);
-                        api.logger.error('Native development could not load the compiled application.', error);
-                    }
+                        const results = 'stats' in stats ? stats.stats : [
+                            stats
+                        ];
+                        if (results.some((result)=>{
+                            const version = this.compilationVersions.get(result.compilation);
+                            return void 0 === version || version !== this.compilerVersions.get(result.compilation.compiler);
+                        })) return;
+                        if (stats.hasErrors()) return this.fail(new Error('Native development compilation failed'));
+                        try {
+                            const publication = await this.publish(stats);
+                            if (this.closed || epoch !== this.epoch) return;
+                            this.retainedFederationAssets = publication.retainedFederationAssets;
+                            this.federationAssets = new Map([
+                                ...publication.federationAssets,
+                                ...this.retainedFederationAssets
+                            ]);
+                            this.federationRevision = publication.federationRevision;
+                            this.federationGraph = publication.federationGraph;
+                            this.ready = publication.entries;
+                            this.failure = void 0;
+                            this.notify();
+                        } catch (error) {
+                            if (this.closed || epoch !== this.epoch) return;
+                            this.fail(error);
+                            api.logger.error('Native development could not load the compiled application.', error);
+                        }
+                    };
+                    this.publication = this.publication.then(publishNext, publishNext);
+                    return this.publication;
                 });
                 api.onCloseDevServer(()=>this.close());
             }

package/dist/cjs/native-composition/native-entry.js

@@ -51,6 +51,8 @@ const external_native_federation_files_js_namespaceObject = require("./native-fe
 const external_native_i18n_js_namespaceObject = require("./native-i18n.js");
 const external_native_module_federation_js_namespaceObject = require("./native-module-federation.js");
 const external_native_routes_js_namespaceObject = require("./native-routes.js");
+const external_native_worker_js_namespaceObject = require("./native-worker.js");
+const external_native_worker_federation_js_namespaceObject = require("./native-worker-federation.js");
 const external_renderer_registration_js_namespaceObject = require("./renderer-registration.js");
 const entryRoutes = new WeakMap();
 function resolveNativeEntryIdentity(context, renderer) {
@@ -88,13 +90,18 @@ async function emitNativeEntryApplication(context, mode) {
             entryRoutes.set(context, discovery);
         }
         const routes = await discovery;
+        const sourceRequests = await (0, external_native_routes_js_namespaceObject.resolveNativeApplicationSourceRequests)(routes, context.profile.sourceExtensions, 'server' === mode ? 'node' : mode);
         if (context.i18n) (0, external_native_i18n_js_namespaceObject.validateNativeLocalisedUrls)(context.i18n, routes);
         sources[`app.${mode}.ts`] = (0, external_native_routes_js_namespaceObject.emitNativeApplicationModule)({
             routes,
-            mode,
-            basePath: context.basePath
+            mode: 'client' === mode ? 'client' : 'server',
+            basePath: context.basePath,
+            sourceRequests
         });
-    } else sources[`app.${mode}.ts`] = `export { default } from ${JSON.stringify(source)};\n`;
+    } else {
+        const sourceRequest = await (0, external_native_routes_js_namespaceObject.resolveNativeApplicationSourceRequest)(source, context.profile.sourceExtensions, 'server' === mode ? 'node' : mode);
+        sources[`app.${mode}.ts`] = `export { default } from ${JSON.stringify(sourceRequest)};\n`;
+    }
     await writeNativeEntryModules(directory, sources);
     return {
         routed,
@@ -105,11 +112,36 @@ const NATIVE_APPLICATION_CLIENT_REQUEST = './app.client';
 function createNativeEntryStubGenerator(adapter) {
     const renderer = adapter.name;
     const extra = adapter.entryClient;
+    const serverSource = async (context, worker = false)=>{
+        const identity = resolveNativeEntryIdentity(context, renderer);
+        const { directory, routed } = await emitNativeEntryApplication(context, worker ? 'worker' : 'server');
+        const federated = Boolean(!worker && (0, external_native_federation_files_js_namespaceObject.findNativeFederationConfig)(context.appDirectory));
+        const server = `import { createNativeServerEntry } from ${JSON.stringify(adapter.runtime.entryServer)};
+${worker && !context.workerFederation?.plan ? workerContextStartup(context, routed) : ''}${context.i18n ? 'import { i18n } from "./i18n";\n' : ''}${federated ? nativeFederationDeclaration : ''}
+export const { ${nativeServerHandlers.join(', ')} } = createNativeServerEntry({
+  identity: ${JSON.stringify(identity)},
+  app: () => import("./app.${worker ? 'worker' : 'server'}"),${worker && context.workerFederation ? `\n  workerFederationLocale: ${JSON.stringify(context.i18n?.fallbackLanguage ?? 'default')},` : ''}${federated ? `\n  federation: ${nativeServerFederationBinding},` : ''}${context.i18n ? '\n  i18n,' : ''}
+});
+`;
+        if (!federated) return {
+            source: server,
+            directory,
+            routed
+        };
+        await writeNativeEntryModules(directory, {
+            'handlers.server.ts': server
+        });
+        return {
+            source: federatedServerSource(identity),
+            directory,
+            routed
+        };
+    };
     return {
         async client (context) {
             const identity = resolveNativeEntryIdentity(context, renderer);
             const federated = Boolean((0, external_native_federation_files_js_namespaceObject.findNativeFederationConfig)(context.appDirectory));
-            await emitNativeEntryApplication(context, 'client');
+            const { routed } = await emitNativeEntryApplication(context, 'client');
             const fields = {
                 identity: JSON.stringify(identity),
                 load: `() => import(${JSON.stringify(NATIVE_APPLICATION_CLIENT_REQUEST)})`,
@@ -120,34 +152,47 @@ function createNativeEntryStubGenerator(adapter) {
                 ...federated ? {
                     federation: nativeFederationBinding
                 } : {},
+                ...context.workerFederation ? {
+                    workerFederation: 'workerFederation'
+                } : {},
                 ...extra?.fields
             };
             return `import { startNativeClient } from ${JSON.stringify(adapter.runtime.entryClient)};
-${context.i18n ? 'import { i18n } from "./i18n";\n' : ''}${extra?.declarations ?? ''}${federated ? nativeFederationDeclaration : ''}
+${workerContextStartup(context, routed)}${context.workerFederation ? nativeWorkerClientTransportSource(context) : ''}${context.i18n ? 'import { i18n } from "./i18n";\n' : ''}${extra?.declarations ?? ''}${federated ? nativeFederationDeclaration : ''}
 startNativeClient({
 ${Object.entries(fields).map(([name, value])=>`  ${name === value ? name : `${name}: ${value}`},`).join('\n')}
 });
 `;
         },
-        async server (context) {
-            const identity = resolveNativeEntryIdentity(context, renderer);
-            const { directory } = await emitNativeEntryApplication(context, 'server');
-            const federated = Boolean((0, external_native_federation_files_js_namespaceObject.findNativeFederationConfig)(context.appDirectory));
-            const server = `import { createNativeServerEntry } from ${JSON.stringify(adapter.runtime.entryServer)};
-${context.i18n ? 'import { i18n } from "./i18n";\n' : ''}${federated ? nativeFederationDeclaration : ''}
-export const { ${nativeServerHandlers.join(', ')} } = createNativeServerEntry({
-  identity: ${JSON.stringify(identity)},
-  app: () => import("./app.server"),${federated ? `\n  federation: ${nativeServerFederationBinding},` : ''}${context.i18n ? '\n  i18n,' : ''}
-});
-`;
-            if (!federated) return server;
+        server: async (context)=>(await serverSource(context)).source,
+        async worker (context) {
+            const { source, directory, routed } = await serverSource(context, true);
+            const federation = context.workerFederation;
             await writeNativeEntryModules(directory, {
-                'handlers.server.ts': server
+                'handlers.worker.ts': source,
+                ...federation?.plan ? {
+                    'federation.worker.ts': (0, external_native_worker_federation_js_namespaceObject.nativeWorkerFederationRegistrySource)(federation.plan, workerContextOptions(context, routed))
+                } : {}
             });
-            return federatedServerSource(identity);
+            return (0, external_native_worker_js_namespaceObject.nativeWorkerEntrySource)('./handlers.worker', federation ? {
+                runtime: adapter.runtime.entryServer,
+                compatibility: federation.compatibility,
+                registry: federation.plan ? './federation.worker' : void 0
+            } : void 0);
         }
     };
 }
+function workerContextOptions(context, routed) {
+    return 'octane' === context.renderer && context.workerFederation ? {
+        router: routed,
+        i18n: Boolean(context.i18n),
+        contextProfiles: context.workerFederation.contextProfiles
+    } : {};
+}
+function workerContextStartup(context, routed) {
+    const source = (0, external_native_worker_federation_js_namespaceObject.nativeWorkerContextStartupSource)(workerContextOptions(context, routed));
+    return source ? `${source}\n` : '';
+}
 const nativeFederationBinding = '{ instance: () => __webpack_require__.federation.instance }';
 const nativeServerFederationBinding = `{ instance: () => __webpack_require__.federation.instance, hydrationModule: ${JSON.stringify(external_native_module_federation_js_namespaceObject.NATIVE_FEDERATION_HYDRATION_MODULE)} }`;
 const nativeFederationDeclaration = 'declare const __webpack_require__: { federation: { instance: import("@modern-js/renderer-core/federation").FederationInstance } };\n';
@@ -169,6 +214,26 @@ ${nativeServerHandlers.slice(1).map((name)=>`export async function ${name}(reque
 function createNativeEntryGenerator(renderer) {
     return createNativeEntryStubGenerator((0, external_renderer_registration_js_namespaceObject.resolveNativeRendererAdapter)(renderer));
 }
+function nativeWorkerClientTransportSource(context) {
+    const federation = context.workerFederation;
+    return `import { createWorkerFederationTransport } from '@modern-js/renderer-core/worker-federation';
+import { assertRendererFederationCompatibility, readRendererFederationContract } from '@modern-js/federation-runtime/renderer-contract';
+const expectedWorkerRenderer = ${JSON.stringify(federation.compatibility)};
+const workerFederation = signal => ({
+  locale: ${JSON.stringify(context.i18n?.fallbackLanguage ?? 'default')},
+  signal,
+  transport: createWorkerFederationTransport({
+    signal,
+    services: ${JSON.stringify(federation.services)}.map(service => ({...service, fetch: request => globalThis.fetch(request)})),
+    admitRendererContract(value) {
+      const contract = readRendererFederationContract(value);
+      assertRendererFederationCompatibility(expectedWorkerRenderer, contract);
+      return contract;
+    },
+  }),
+});
+`;
+}
 exports.NATIVE_APPLICATION_CLIENT_REQUEST = __webpack_exports__.NATIVE_APPLICATION_CLIENT_REQUEST;
 exports.createNativeEntryGenerator = __webpack_exports__.createNativeEntryGenerator;
 exports.createNativeEntryStubGenerator = __webpack_exports__.createNativeEntryStubGenerator;