@bleedingdev/modern-js-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/esm-node/router/runtime/plugin.mjs

@@ -1,10 +1,10 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useInRouterContext, useLocation, useMatches, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { normalizePathname } from "@modern-js/runtime-utils/url";
 import * as __rspack_external_react from "react";
-import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { Link } from "./PrefetchLink.mjs";
 import { createClientRouterFromPayload } from "./rsc-router.mjs";
@@ -67,24 +67,20 @@ const routerPlugin = (userConfig = {})=>({
                     const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
                     return match || '/';
                 };
-                let cachedRouter = null;
+                const routerCache = new WeakMap();
                 const RouterWrapper = (props)=>{
                     const routerResult = useRouterCreation(("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) ? {
                         ...props,
                         rscPayload: props?.rscPayload
                     } : props, {
                         api: api,
+                        cache: routerCache,
                         createRoutes,
                         supportHtml5History,
                         selectBasePath,
                         basename
                     });
-                    const router = (0, __rspack_external_react.useMemo)(()=>{
-                        if (cachedRouter) return cachedRouter;
-                        cachedRouter = routerResult.router;
-                        return cachedRouter;
-                    }, []);
-                    const { routes } = routerResult;
+                    const { router, routes } = routerResult;
                     routesContainer.current = routes;
                     beforeCreateRouter = false;
                     const routerContent = /*#__PURE__*/ jsxs(Fragment, {
@@ -121,14 +117,15 @@ function isSegmentPrefix(pathname, base) {
     return p === b || p.startsWith(`${b}/`);
 }
 function useRouterCreation(props, options) {
-    const { api, createRoutes, supportHtml5History, selectBasePath, basename } = options;
+    const { api, cache, createRoutes, supportHtml5History, selectBasePath, basename } = options;
     const runtimeContext = (0, __rspack_external_react.useContext)(InternalRuntimeContext);
     const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
     const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
     const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
     const rscPayload = ("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && props?.rscPayload ? safeUse(props.rscPayload) : null;
     let hydrationData = "u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA : true === getGlobalEnableRsc() ? window._ROUTER_DATA || rscPayload : window._ROUTER_DATA;
-    return (0, __rspack_external_react.useMemo)(()=>{
+    const result = (0, __rspack_external_react.useRef)(cache.get(runtimeContext) ?? null);
+    if (null === result.current) {
         if (hydrationData?.errors) hydrationData = {
             ...hydrationData,
             errors: deserializeErrors(hydrationData.errors)
@@ -144,10 +141,12 @@ function useRouterCreation(props, options) {
         const hooks = api.getHooks();
         if (("u" > typeof __MODERN_ENABLE_RSC__ ? __MODERN_ENABLE_RSC__ : true === getGlobalEnableRsc()) && rscPayload) try {
             const router = createClientRouterFromPayload(rscPayload, routes, _basename);
-            return {
+            result.current = {
                 router,
                 routes: router.routes || []
             };
+            cache.set(runtimeContext, result.current);
+            return result.current;
         } catch (e) {
             console.error('Failed to create router from RSC payload:', e);
         }
@@ -196,16 +195,12 @@ function useRouterCreation(props, options) {
             };
             return originSubscribe(wrappedListener);
         };
-        return {
+        result.current = {
             router,
             routes: modifiedRoutes
         };
-    }, [
-        finalRouteConfig,
-        props,
-        _basename,
-        hydrationData,
-        getBlockNavState
-    ]);
+        cache.set(runtimeContext, result.current);
+    }
+    return result.current;
 }
 export { beforeCreateRouter, finalRouteConfig, modifyRoutes, routerPlugin };

package/dist/esm-node/router/runtime/plugin.node.mjs

@@ -1,12 +1,12 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
 import { merge } from "@modern-js/runtime-utils/merge";
 import { createRequestContext } from "@modern-js/runtime-utils/node";
 import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { useContext } from "react";
-import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context/index.mjs";
 import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
 import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
@@ -16,11 +16,10 @@ import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils.mjs
 function createRemixRequest(request) {
     const method = 'GET';
     const { headers } = request;
-    const controller = new AbortController();
     return new Request(request.url, {
         method,
         headers,
-        signal: controller.signal
+        signal: request.signal
     });
 }
 const routerPlugin = (userConfig = {})=>({
@@ -124,7 +123,7 @@ const routerPlugin = (userConfig = {})=>({
                         }) : /*#__PURE__*/ jsx(RSCStaticRouter, {
                             basename: basename
                         });
-                        {
+                        else {
                             const { nonce, mode, useJsonScript } = context.ssrContext;
                             const remixRouter = createStaticRouter(routes, routerContext);
                             const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {

package/dist/types/common.d.ts

@@ -1,12 +1,6 @@
+import type { RuntimePlugin } from './core/plugin/index.js';
+export type { RuntimePlugin };
 export declare const isBrowser: () => boolean;
-export type RuntimePlugin<Extends = unknown> = {
-    name?: string;
-    registryHooks?: Extends extends {
-        extendHooks: infer Hooks;
-    } ? Hooks : Record<string, unknown>;
-    setup?: (...args: any[]) => unknown;
-    [key: string]: unknown;
-};
 export interface RuntimeConfig {
     plugins?: RuntimePlugin[];
     [key: string]: any;

package/dist/types/core/context/index.d.ts

@@ -23,7 +23,7 @@ export { DefaultNotFound } from '../../router/runtime/DefaultNotFound.js';
 export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, type RouterLifecycleContext, routerProviderRegistryHooks, } from '../../router/runtime/hooks.js';
 export type { LinkPrefetchPolicy } from '../../router/runtime/PrefetchLink.js';
 export type { LoaderFunction, LoaderFunctionArgs, ModernRoute, } from '../../router/runtime/types.js';
-export { getInitialContext, InternalRuntimeContext, RuntimeComponentResolverContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime.js';
+export { getInitialContext, InternalRuntimeContext, ReactRuntimeContext, type RequestContext, RuntimeComponentResolverContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, useRuntimeContext, } from './runtime.js';
 export type { PayloadRoute, ServerPayload } from './serverPayload/index.js';
 interface GlobalContext {
     entryName?: string;

package/dist/types/core/context/public.d.ts

@@ -1 +1 @@
-export { ReactRuntimeContext, type RequestContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './runtime.js';
+export { ReactRuntimeContext, type RequestContext, RuntimeContext, type TRuntimeContext, useRuntimeContext, } from './index.js';

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

@@ -1,5 +1,5 @@
+export { RuntimeContext, useRuntimeContext, } from './context/index.js';
 export { defineRuntimeConfig } from './config.js';
 export type { TRuntimeContext } from './context/runtime.js';
-export { RuntimeContext, useRuntimeContext, } from './context/runtime.js';
 export type { RuntimePlugin } from './plugin/index.js';
 export type { SSRContainer, SSRData } from './types.js';

package/dist/types/core/react/wrapper.d.ts

@@ -1,6 +1,6 @@
 import type { ResolveComponentFn } from '@modern-js/plugin/runtime';
-import type React from 'react';
 import { type TRuntimeContext } from '../context/index.js';
+import type React from 'react';
 export declare function wrapRuntimeComponentResolver(root: React.ReactNode, hooks?: {
     resolveComponent?: {
         call: ResolveComponentFn;

package/dist/types/core/server/requestHandler.d.ts

@@ -1,6 +1,35 @@
+import type { SSRRequestRouterResult, SSRRequestTerminal } from '@modern-js/plugin/runtime';
+import { type TInternalRuntimeContext } from '../context/index.js';
 import type { RequestHandler, RequestHandlerOptions } from '@modern-js/server-core';
+import type { OnError } from '@modern-js/types';
 import React from 'react';
-import { type TInternalRuntimeContext } from '../context/index.js';
+export declare const REQUEST_END_ERROR = "An error occurs during request lifecycle completion";
+export declare const RESPONSE_BODY_CANCEL_ERROR = "An error occurs while cancelling a discarded response body";
+export type RequestLifecycle = {
+    /** True once completion belongs to a response body rather than the handler. */
+    readonly deferred: boolean;
+    /** Notify request completion once; concurrent callers await the same work. */
+    run: (terminal?: SSRRequestTerminal) => Promise<void>;
+    deferUntilBodyDone: (response: Response) => Response;
+    /** Cancel a discarded body before notifying extensions. */
+    discardBody: (response: Response, terminal?: SSRRequestTerminal) => Promise<void>;
+};
+export declare function runWithRequestLifecycleOnError<T>(lifecycle: RequestLifecycle, callback: () => Promise<T> | T): Promise<T>;
+export declare function finishWithRequestLifecycle<T>(lifecycle: RequestLifecycle, callback: () => Promise<T> | T): Promise<T>;
+/** The native owner controls body lifetime; plugins own request resources. */
+export declare function createRequestLifecycle(onEnd: (terminal: SSRRequestTerminal) => void | Promise<void>, onError: OnError): RequestLifecycle;
+export type ResponseProxy = {
+    headers: Record<string, string>;
+    status: number;
+};
+export type RedirectContext = {
+    enableRsc: boolean;
+    isRSCNavigation: boolean;
+    basename: string;
+};
+export declare const applyRouterResult: (context: TInternalRuntimeContext, routerResult: SSRRequestRouterResult | undefined, onError: OnError) => void;
+export declare const createLoaderRedirectResponse: (beforeRenderResult: Response | undefined, redirectCtx: RedirectContext) => Response | undefined;
+export declare const finalizeRenderResponse: (response: Response, responseProxy: ResponseProxy, redirectCtx: RedirectContext, lifecycle: RequestLifecycle) => Promise<Response>;
 export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/server-core';
 export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
     runtimeContext: TInternalRuntimeContext;

package/dist/types/core/server/stream/deferredScript.d.ts

@@ -12,4 +12,4 @@ export declare function toErrorInfo(error: unknown): {
     stack?: string;
 };
 export declare function buildDeferredDataScript(nonce: string | undefined, args: unknown[]): string;
-export declare function enqueueFromEntries(entries: Array<[string, unknown]>, nonce: string | undefined, emit: (script: string) => void): void;
+export declare function enqueueFromEntries(entries: Array<[string, unknown]>, deferredScriptKeys: Map<string, string[]> | undefined, nonce: string | undefined, emit: (script: string) => void): Promise<void>;

package/dist/types/core/server/stream/deferredScriptOutputCoordinator.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Serializes the router's deferred-data resolver scripts with React's Fizz
+ * output without rewriting either producer's bytes.
+ *
+ * Why this exists:
+ * - A resolver script settles the client-side Promise created for a
+ *   `defer()` key. It must be sent when that individual server Promise
+ *   settles; waiting for the whole React stream would unnecessarily delay
+ *   hydration and interactivity behind unrelated Suspense boundaries.
+ * - React and the resolver callbacks are independent stream producers. A
+ *   direct `write()` can therefore land in a partial HTML tag, a hidden Fizz
+ *   segment container, or between that container and its continuation
+ *   instruction.
+ * - React's public streaming callbacks expose shell/all-ready lifecycle
+ *   events, not a safe byte-level insertion point. React chunk sizes and
+ *   `progressiveChunkSize` are buffering heuristics, not HTML or Fizz
+ *   boundaries.
+ *
+ * The coordinator deliberately recognizes the Fizz continuation containers
+ * and instructions used by the supported React stream format. This is a
+ * compatibility boundary: when the supported React/Fizz output protocol is
+ * changed, update this recognizer and its Node, Edge, HTML, SVG, MathML, and
+ * table continuation tests together. It is not intended to be a general HTML
+ * rewriter.
+ *
+ * Shell completion only makes a resolver eligible to send. The resolver is
+ * emitted after a root-level HTML boundary and, for a continuation segment,
+ * after React's matching continuation instruction.
+ */
+export declare class DeferredScriptOutputCoordinator {
+    private readonly emit;
+    private readonly pendingResolvers;
+    private readonly openElements;
+    private shellFinished;
+    private closed;
+    private state;
+    private currentTagName;
+    private currentAttributes;
+    private currentAttributeName;
+    private currentAttributeValue;
+    private currentAttributeHasValue;
+    private declarationPrefix;
+    private commentTail;
+    private rawTextElement;
+    private rawTextSearch;
+    private continuationProtocolScript;
+    private continuationProtocolTail;
+    private hasContinuationProtocolCall;
+    private awaitingContinuationProtocol;
+    constructor(emit: (chunk: string) => void);
+    enqueueResolver(script: string): void;
+    /**
+     * Keep this separate from the ShellChunkStatus assignment. The caller sets
+     * FINISH at the existing marker position, then calls this after the marker
+     * chunk's afterMark bytes have been observed.
+     */
+    markShellFinished(): void;
+    writeReact(chunk: string): void;
+    finish(): void;
+    abort(): void;
+    private isSafeBoundary;
+    private flushResolvers;
+    private consume;
+    private startTag;
+    private startAttribute;
+    private completeAttribute;
+    private completeStartTag;
+    private completeEndTag;
+    private consumeRawText;
+    private completeRawTextEndTag;
+    private closeOpenElement;
+}

package/dist/types/core/server/stream/shared.d.ts

@@ -32,6 +32,20 @@ export declare enum ShellChunkStatus {
     START = 0,
     FINISH = 1
 }
+/**
+ * The document head is sealed when the shell end mark is written, so only head
+ * tags emitted before it reach `<head>`. React writes a completed Suspense
+ * boundary after the shell once the flushed bytes exceed `progressiveChunkSize`,
+ * which drops the head of every large route and keeps its content hidden until
+ * the inline `$RC` script runs. Completed boundaries therefore stay inline in
+ * the shell; pending boundaries still stream when they resolve. Buffering
+ * paths (`onAllReady`) thereby seal the head after all content.
+ *
+ * Measured on a ~1 MB route completed at shell time (React 19.3, Node): the
+ * default chunk size reaches the shell end mark in 0.7 ms, this one in 1.2 ms,
+ * so the head fix costs no measurable time to first byte.
+ */
+export declare const SHELL_PROGRESSIVE_CHUNK_SIZE: number;
 export declare function resolveStreamingMode(request: Request, forceStreamToString: boolean): {
     onReady: 'onAllReady' | 'onShellReady';
     waitForAllReady: boolean;

package/dist/types/document/cli/index.d.ts

@@ -2,5 +2,6 @@ import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import type { Entrypoint } from '@modern-js/types/cli';
 export declare const processScriptPlaceholders: (html: string, nonce?: string) => string;
 export declare const getDocumentByEntryName: (entrypoints: Entrypoint[], entryName: string, fallbackDir?: string) => string | undefined;
+export declare const getDocumentTempEntry: (internalDirectory: string, compilerName: string | undefined, entryName: string) => string;
 export declare const documentPlugin: () => CliPlugin<AppTools>;
 export default documentPlugin;

package/dist/types/internal.d.ts

@@ -1 +1 @@
-export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/runtime.js';
+export { InternalRuntimeContext, type TInternalRuntimeContext, } from './core/context/index.js';

package/dist/types/router/cli/code/utils.d.ts

@@ -4,7 +4,7 @@ export declare const replaceWithAlias: (base: string, filePath: string, alias: s
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;
-}) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean]>;
+}) => Promise<readonly [imports: readonly import("es-module-lexer").Import[], exports: readonly import("es-module-lexer").Export[], facade: boolean, hasModuleSyntax: boolean]>;
 export declare const hasLoader: (filename: string, source?: string) => Promise<boolean>;
 export declare const hasAction: (filename: string, source?: string) => Promise<boolean>;
 export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;

package/dist/types/router/runtime/hooks.d.ts

@@ -10,24 +10,20 @@ export type RouterLifecycleContext = {
     router?: unknown;
     [key: string]: unknown;
 };
-export type RouterSyncHook<Handler extends (...args: any[]) => any> = {
-    call: (...args: Parameters<Handler>) => ReturnType<Handler>;
-    [key: string]: unknown;
-};
-declare const modifyRoutes: RouterSyncHook<(routes: RouteObject[]) => RouteObject[]>;
-declare const onBeforeCreateRoutes: RouterSyncHook<(context: TRuntimeContext) => void>;
-declare const onBeforeCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-declare const onBeforeHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-declare const onAfterHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
+declare const modifyRoutes: import("@modern-js/plugin").SyncHook<(routes: RouteObject[]) => RouteObject[]>;
+declare const onBeforeCreateRoutes: import("@modern-js/plugin").SyncHook<(context: TRuntimeContext) => void>;
+declare const onBeforeCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onBeforeHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+declare const onAfterHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
 export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, };
 export declare const routerProviderRegistryHooks: {
-    modifyRoutes: RouterSyncHook<(routes: RouteObject[]) => RouteObject[]>;
-    onBeforeCreateRoutes: RouterSyncHook<(context: TRuntimeContext) => void>;
-    onBeforeCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-    onAfterCreateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-    onBeforeHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
-    onAfterHydrateRouter: RouterSyncHook<(context: RouterLifecycleContext) => void>;
+    modifyRoutes: import("@modern-js/plugin").SyncHook<(routes: RouteObject[]) => RouteObject[]>;
+    onBeforeCreateRoutes: import("@modern-js/plugin").SyncHook<(context: TRuntimeContext) => void>;
+    onBeforeCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+    onAfterCreateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+    onBeforeHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
+    onAfterHydrateRouter: import("@modern-js/plugin").SyncHook<(context: RouterLifecycleContext) => void>;
 };
 export type RouterExtendsHooks = {
     modifyRoutes: typeof modifyRoutes;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bleedingdev/modern-js-runtime",
   "description": "A Progressive React Framework for modern web development.",
-  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
   "bugs": {
-    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
     "directory": "packages/runtime/plugin-runtime"
   },
   "license": "MIT",
@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.9",
+  "version": "3.9.3-ultramodern.2",
   "engines": {
     "node": ">=20"
   },
@@ -217,50 +217,53 @@
   "dependencies": {
     "@loadable/component": "5.16.7",
     "@loadable/server": "5.16.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.9",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.0-ultramodern.9",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.0-ultramodern.9",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.9",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.9",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.9",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.9",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.9",
-    "@swc/core": "1.16.2",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.3-ultramodern.2",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.3-ultramodern.2",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.3-ultramodern.2",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.3-ultramodern.2",
+    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.3-ultramodern.2",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.3-ultramodern.2",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.2",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.2",
+    "@rsbuild/plugin-react": "2.1.1",
+    "@rsbuild/plugin-svgr": "2.0.5",
+    "@swc/core": "1.16.13",
     "@swc/helpers": "^0.5.23",
-    "@swc/plugin-loadable-components": "^13.0.0",
+    "@swc/plugin-loadable-components": "^14.0.0",
     "@types/loadable__component": "^5.13.10",
     "@types/react-helmet": "^6.1.11",
     "cookie": "2.0.1",
-    "entities": "^8.0.0",
-    "es-module-lexer": "^2.3.2",
+    "entities": "^8.1.0",
+    "es-module-lexer": "^3.0.2",
     "esbuild": "^0.28.2",
     "invariant": "^2.2.4",
     "isbot": "5.2.2",
     "react-helmet": "^6.1.0",
     "react-helmet-async": "3.0.0",
-    "react-is": "^19.2.8"
+    "react-is": "^19.3.0",
+    "react-router": "7.18.4"
   },
   "peerDependencies": {
     "react": "^19.2.8",
     "react-dom": "^19.2.8"
   },
   "devDependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.9",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.3-ultramodern.2",
     "@remix-run/web-fetch": "^4.4.2",
-    "@rsbuild/core": "2.2.3",
-    "@rslib/core": "1.0.0",
+    "@rsbuild/core": "2.2.11",
+    "@rslib/core": "1.0.3",
     "@scripts/rstest-config": "2.66.0",
-    "@testing-library/dom": "^10.4.1",
+    "@testing-library/dom": "^10.4.2",
     "@testing-library/react": "^16.3.3",
     "@types/cookie": "0.6.0",
     "@types/invariant": "^2.2.37",
     "@types/loadable__server": "5.12.11",
-    "@types/node": "^26.4.1",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "@types/node": "^26.6.3",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "ts-node": "^10.9.2",
-    "typescript": "^7.0.2"
+    "typescript": "7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -271,5 +274,8 @@
     "build": "rslib build && pnpm run gen-static",
     "gen-static": "node --disable-warning=ExperimentalWarning --experimental-strip-types ./scripts/gen-static.mts",
     "test": "rstest"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/runtime"
   }
 }

package/rslib.config.mts

@@ -10,6 +10,9 @@ export default defineConfig({
   },
   output: {
     externals: [
+      // Keep the package self-reference in the output: Module Federation
+      // shares the runtime contexts by that request.
+      '@modern-js/runtime/context',
       {
         '@modern-js/runtime-utils/node$':
           'commonjs @modern-js/runtime-utils/node',

package/rstest.config.mts

@@ -72,10 +72,6 @@ export default {
             __dirname,
             'tests/fixtures/rsc-server.ts',
           ),
-          '@modern-js/render/rsc-worker': path.join(
-            __dirname,
-            'tests/fixtures/rsc-server.ts',
-          ),
         },
       },
     }),

package/dist/cjs/core/server/requestResponse.js

@@ -1,107 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    applyRouterSnapshotResult: ()=>applyRouterSnapshotResult,
-    createLoaderRedirectResponse: ()=>createLoaderRedirectResponse,
-    finalizeRenderResponse: ()=>finalizeRenderResponse
-});
-const router_state_namespaceObject = require("@modern-js/runtime-extensions/router-state");
-const redirect_js_namespaceObject = require("../../router/runtime/redirect.js");
-const external_tracer_js_namespaceObject = require("./tracer.js");
-const isRedirectStatus = (status)=>301 === status || 302 === status || 303 === status || 307 === status || 308 === status;
-const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
-const getRedirectLocation = (headers)=>{
-    const location = headers.get('Location');
-    return null !== location && '' !== location && URL.canParse(location, 'http://localhost') ? location : void 0;
-};
-const processRedirect = (headers, status, ctx)=>{
-    headers.delete('content-length');
-    headers.delete('transfer-encoding');
-    if (ctx.enableRsc && ctx.isRSCNavigation) return (0, redirect_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
-    return new Response(null, {
-        status,
-        headers
-    });
-};
-const applyRouterSnapshotResult = (context, onError)=>{
-    const routerServerSnapshot = (0, router_state_namespaceObject.getRouterServerSnapshot)(context);
-    const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
-    if (void 0 !== routerStatusCode && 0 !== routerStatusCode && !Number.isNaN(routerStatusCode) && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
-    const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
-    if (errors.length > 0) onError(errors[0], external_tracer_js_namespaceObject.SSRErrors.LOADER_ERROR);
-};
-const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
-    if (void 0 === beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
-    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
-    const redirectUrl = getRedirectLocation(beforeRenderResult.headers);
-    if (void 0 === redirectUrl) return;
-    return processRedirect(new Headers(beforeRenderResult.headers), beforeRenderResult.status, redirectCtx);
-};
-const finalizeRenderResponse = async (response, responseProxy, redirectCtx, routerCleanup)=>{
-    const proxyHeaders = new Headers(responseProxy.headers);
-    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && void 0 !== getRedirectLocation(proxyHeaders)) {
-        await routerCleanup.discardBody(response);
-        return processRedirect(proxyHeaders, responseProxy.status, redirectCtx);
-    }
-    const headers = new Headers(response.headers);
-    Object.entries(responseProxy.headers).forEach(([key, value])=>{
-        headers.set(key, value);
-    });
-    if (-1 !== responseProxy.status) {
-        if (isNullBodyStatus(responseProxy.status)) {
-            await routerCleanup.discardBody(response);
-            headers.delete('content-length');
-            headers.delete('transfer-encoding');
-            return new Response(null, {
-                status: responseProxy.status,
-                headers
-            });
-        }
-        return routerCleanup.deferUntilBodyDone(new Response(response.body, {
-            status: responseProxy.status,
-            headers
-        }));
-    }
-    Object.entries(responseProxy.headers).forEach(([key, value])=>{
-        response.headers.set(key, value);
-    });
-    return routerCleanup.deferUntilBodyDone(response);
-};
-exports.applyRouterSnapshotResult = __webpack_exports__.applyRouterSnapshotResult;
-exports.createLoaderRedirectResponse = __webpack_exports__.createLoaderRedirectResponse;
-exports.finalizeRenderResponse = __webpack_exports__.finalizeRenderResponse;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "applyRouterSnapshotResult",
-    "createLoaderRedirectResponse",
-    "finalizeRenderResponse"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});