@bleedingdev/modern-js-runtime 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

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,7 +1,36 @@
-import type { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
-import React from 'react';
+import type { SSRRequestRouterResult, SSRRequestTerminal } from '@modern-js/plugin/runtime';
 import { type TInternalRuntimeContext } from '../context/index.js';
-export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+import type { RequestHandler, RequestHandlerOptions } from '@modern-js/server-core';
+import type { OnError } from '@modern-js/types';
+import React from 'react';
+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/shared.d.ts

@@ -1,5 +1,5 @@
-import type { ServerUserConfig } from '@modern-js/app-tools';
 import type { SSRAssetGroup, SSRAssetTransformInfo, SSRRenderAsset, SSRRenderLifecycle, SSRRenderTerminal, SSRRouterData, SSRTemplateChunk, StreamSSRExtender } from '@modern-js/plugin/runtime';
+import type { ServerUserConfig } from '@modern-js/server-core';
 import type { HandleRequestOptions } from './requestHandler.js';
 export type RenderOptions = HandleRequestOptions;
 export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;

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

@@ -1,4 +1,4 @@
-import type { OnError } from '@modern-js/app-tools';
+import type { OnError } from '@modern-js/types';
 import type { ClientManifest as RscClientManifest, ServerManifest as RscServerManifest, SSRManifest as RscSSRManifest } from '@modern-js/types/server';
 import type React from 'react';
 import type { TInternalRuntimeContext } from '../../context/index.js';
@@ -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/core/server/tracer.d.ts

@@ -1,4 +1,4 @@
-import type { OnError, OnTiming } from '@modern-js/app-tools';
+import type { OnError, OnTiming } from '@modern-js/types';
 export declare enum SSRTimings {
     PRERENDER = "ssr-prerender",
     RENDER_HTML = "ssr-render-html",

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

@@ -1,5 +1,5 @@
-import type { ServerUserConfig } from '@modern-js/app-tools';
 import type { StaticHandlerContext } from '@modern-js/runtime-utils/router';
+import type { ServerUserConfig } from '@modern-js/server-core';
 import type { SSRConfig } from './shared.js';
 export declare function attributesToString(attributes: Record<string, any>): string;
 /**

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

@@ -1,5 +1,4 @@
-import type { OnError, OnTiming } from '@modern-js/app-tools';
-import type { BaseSSRServerContext } from '@modern-js/types';
+import type { BaseSSRServerContext, OnError, OnTiming } from '@modern-js/types';
 import type { RenderLevel } from './constants.js';
 declare global {
     interface Window {

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.8",
+  "version": "3.9.3-ultramodern.1",
   "engines": {
     "node": ">=20"
   },
@@ -217,49 +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.8",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.0-ultramodern.8",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.0-ultramodern.8",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.8",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.8",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.8",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.8",
-    "@swc/core": "1.16.2",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.3-ultramodern.1",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.9.3-ultramodern.1",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.3-ultramodern.1",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.3-ultramodern.1",
+    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.3-ultramodern.1",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.1",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.3-ultramodern.1",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.1",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.1",
+    "@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.8",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.3-ultramodern.1",
     "@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": {
@@ -270,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',
-          ),
         },
       },
     }),