@bleedingdev/modern-js-runtime-renderer-extensions 3.9.0-ultramodern.6 → 3.9.0-ultramodern.8

package/package.json

@@ -11,7 +11,7 @@
     "directory": "packages/runtime/renderer-extensions"
   },
   "license": "MIT",
-  "version": "3.9.0-ultramodern.6",
+  "version": "3.9.0-ultramodern.8",
   "engines": {
     "node": ">=26.7.0"
   },
@@ -36,13 +36,13 @@
     }
   },
   "dependencies": {
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.6",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.6"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.8",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.8"
   },
   "devDependencies": {
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.0-ultramodern.6",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.6",
-    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.6",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.9.0-ultramodern.8",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.8",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.8",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@testing-library/dom": "^10.4.1",

package/tests/federatedCss.test.ts

@@ -45,36 +45,5 @@ describe('createFederatedCssLinks', () => {
     expect(html).toBe(
       '<link nonce="nonce&quot;&amp;&lt;value&gt;" href="/remote/theme.css" rel="stylesheet" />',
     );
-    expect(html.match(/\bhref=/g)).toHaveLength(1);
-    expect(html.match(/\brel=/g)).toHaveLength(1);
-  });
-});
-
-describe('SSR federated CSS helper matrix', () => {
-  it('escapes federated CSS hrefs and dedupes existing, repeated, and template-present assets', () => {
-    expect(
-      createFederatedCssLinks(
-        [
-          '/remote/base.css',
-          '/remote/base.css',
-          '/remote/theme" onload="alert(1)&x=<tag>.css',
-          '/remote/template".css',
-          '/remote/existing.css',
-          '',
-        ],
-        {
-          template:
-            '<link href="/remote/template&quot;.css" rel="stylesheet" />',
-          attributes: {
-            'data-mf': 'checkout',
-            nonce: 'nonce-2',
-            skipped: undefined,
-          },
-          existingAssets: ['/remote/existing.css'],
-        },
-      ),
-    ).toBe(
-      '<link data-mf="checkout" nonce="nonce-2" href="/remote/base.css" rel="stylesheet" /><link data-mf="checkout" nonce="nonce-2" href="/remote/theme&quot; onload=&quot;alert(1)&amp;x=&lt;tag&gt;.css" rel="stylesheet" />',
-    );
   });
 });

package/tests/headRuntime.test.tsx

@@ -1,9 +1,4 @@
 import { getHelmetContext } from '@modern-js/runtime-extensions/helmet-context';
-import {
-  applyRouterRuntimeState,
-  getRouterRuntimeState,
-  getRouterServerSnapshot,
-} from '@modern-js/runtime-extensions/router-state';
 import React, { useContext } from 'react';
 import { renderToReadableStream, renderToString } from 'react-dom/server';
 import {
@@ -11,7 +6,6 @@ import {
   getGlobalInternalRuntimeContext,
   getInitialContext,
   InternalRuntimeContext,
-  RuntimeContext,
   setGlobalContext,
   setGlobalInternalRuntimeContext,
 } from '../../plugin-runtime/src/core/context';
@@ -127,103 +121,6 @@ describe('registered native runtime/head compatibility', () => {
     }
   });
 
-  it('should keep router runtime state out of public context enumeration', () => {
-    let runtimeValue: Record<string, unknown> | undefined;
-    let internalValue: Record<string, unknown> | undefined;
-
-    const Probe = () => {
-      runtimeValue = useContext(RuntimeContext) as Record<string, unknown>;
-      internalValue = useContext(InternalRuntimeContext) as Record<
-        string,
-        unknown
-      >;
-      return null;
-    };
-
-    const context = getInitialContext(false);
-    applyRouterRuntimeState(context, {
-      framework: 'custom-router',
-      instance: { kind: 'internal-router' },
-      serverSnapshot: {
-        matchedRouteIds: ['route-a'],
-      },
-    });
-
-    renderToString(
-      wrapRuntimeContextProvider(
-        <Probe />,
-        context as Record<string, unknown> as any,
-      ),
-    );
-
-    expect(getRouterServerSnapshot(internalValue as object)).toMatchObject({
-      matchedRouteIds: ['route-a'],
-    });
-    expect(getRouterRuntimeState(internalValue as object)?.framework).toBe(
-      'custom-router',
-    );
-    expect(getRouterRuntimeState(internalValue as object)?.instance).toEqual({
-      kind: 'internal-router',
-    });
-
-    // None of the router state may leak into string-key enumeration of
-    // either context value — each forbidden key is asserted individually so
-    // a partial leak fails too.
-    const forbiddenKeys = [
-      'routerFramework',
-      'routerInstance',
-      'routerRuntime',
-      'routerServerSnapshot',
-      'routerHydrationScript',
-      'routerMatchedRouteIds',
-      '_helmetContext',
-    ];
-    for (const value of [runtimeValue, internalValue]) {
-      const keys = Object.keys(value as object);
-      for (const forbidden of forbiddenKeys) {
-        expect(keys).not.toContain(forbidden);
-      }
-    }
-    expect(runtimeValue?.routerFramework).toBeUndefined();
-    expect(runtimeValue?.routerInstance).toBeUndefined();
-    expect(runtimeValue?.routerServerSnapshot).toBeUndefined();
-
-    // The symbol-keyed extension slot must not be reachable from the PUBLIC
-    // context object either: spreads copy enumerable symbol properties, so
-    // the wrapper has to strip the slot from the public copy.
-    const extensionsSlot = Symbol.for('@modern-js/runtime:context-extensions');
-    expect(Object.getOwnPropertySymbols(runtimeValue as object)).not.toContain(
-      extensionsSlot,
-    );
-    expect(getRouterRuntimeState(runtimeValue as object)).toBeUndefined();
-    expect(getRouterServerSnapshot(runtimeValue as object)).toBeUndefined();
-
-    // ...while the internal context keeps carrying it.
-    expect(Object.getOwnPropertySymbols(internalValue as object)).toContain(
-      extensionsSlot,
-    );
-  });
-
-  it('should collect head tags in an isolated request context', () => {
-    const context = getInitialContext(false);
-
-    renderToString(
-      wrapRuntimeContextProvider(
-        <Helmet htmlAttributes={{ lang: 'cs' }}>
-          <title>Modern SSR</title>
-        </Helmet>,
-        context as Record<string, unknown> as any,
-      ),
-    );
-
-    expect(getHelmetContext(context)?.helmet?.htmlAttributes.toString()).toBe(
-      'lang="cs"',
-    );
-    expect(getHelmetContext(context)?.helmet?.title.toString()).toBe(
-      '<title data-rh="true">Modern SSR</title>',
-    );
-  });
-
   it('keeps response functions outside the RSC internal context', () => {
     let internalValue: ReturnType<typeof getInitialContext> | undefined;
 
@@ -257,78 +154,10 @@ describe('registered native runtime/head compatibility', () => {
       setGlobalContext({ enableRsc: false });
     }
 
-    expect(internalValue?.ssrContext).toBeUndefined();
-    expect(internalValue?.requestContext.request).toEqual({
-      params: { category: 'compact' },
-      pathname: '/tractors',
-      query: { sort: 'price' },
-      headers: { accept: 'text/html' },
-      host: 'example.test',
-      url: 'https://example.test/tractors?sort=price',
-      userAgent: undefined,
-      cookie: undefined,
-      referer: undefined,
-    });
-    expect(internalValue?.requestContext.response).toEqual({
-      locals: response.locals,
-    });
     expect(
       Object.values(internalValue?.requestContext.response ?? {}).some(
         value => typeof value === 'function',
       ),
     ).toBe(false);
   });
-
-  it('renders an RSC context without an SSR context', () => {
-    let internalValue: ReturnType<typeof getInitialContext> | undefined;
-
-    const Probe = () => {
-      internalValue = useContext(InternalRuntimeContext);
-      return <main>RSC request context</main>;
-    };
-
-    setGlobalContext({ enableRsc: true });
-    try {
-      const html = renderToString(
-        wrapRuntimeContextProvider(<Probe />, getInitialContext(false)),
-      );
-
-      expect(html).toContain('RSC request context');
-      expect(internalValue?.requestContext).toEqual({
-        request: {
-          params: {},
-          pathname: '',
-          query: {},
-          headers: {},
-          host: '',
-          url: '',
-        },
-        response: { locals: {} },
-      });
-      expect(internalValue?.ssrContext).toBeUndefined();
-    } finally {
-      setGlobalContext({ enableRsc: false });
-    }
-  });
-
-  it('serializes React head prop names to valid HTML attributes', () => {
-    const context = getInitialContext(false);
-
-    renderToString(
-      wrapRuntimeContextProvider(
-        <Helmet>
-          <link href="/cs" hrefLang="cs" rel="alternate" />
-          <meta charSet="utf-8" />
-        </Helmet>,
-        context as Record<string, unknown> as any,
-      ),
-    );
-
-    expect(getHelmetContext(context)?.helmet?.link.toString()).toContain(
-      '<link data-rh="true" href="/cs" hreflang="cs" rel="alternate">',
-    );
-    expect(getHelmetContext(context)?.helmet?.meta.toString()).toContain(
-      '<meta data-rh="true" charset="utf-8">',
-    );
-  });
 });

package/tests/nativeAssetPolicy.test.tsx

@@ -130,71 +130,6 @@ describe('buildShellBeforeTemplate', () => {
     );
 
     expect(html).toBe(expectedHtml);
-    expect(orderedFragments.map(fragment => html.indexOf(fragment))).toEqual(
-      orderedFragments.map(fragment => expectedHtml.indexOf(fragment)),
-    );
-    expect(html.split(orderedFragments[1])).toHaveLength(2);
-  });
-
-  it('should use shared matched route ids from the router snapshot for css injection', async () => {
-    for (const buildTemplate of [
-      buildShellBeforeTemplate,
-      buildWorkerShellBeforeTemplate,
-    ]) {
-      const html = await buildTemplate(
-        `<html><head>${CHUNK_CSS_PLACEHOLDER}</head><body></body></html>`,
-        {
-          entryName: 'main',
-          runtimeContext: withRouterSnapshot(
-            {
-              routeManifest: {
-                routeAssets: {
-                  'route-a': {
-                    referenceCssAssets: ['/assets/route-a.css'],
-                  },
-                },
-              },
-            },
-            {
-              matchedRouteIds: ['route-a'],
-            },
-          ) as any,
-          config: {} as any,
-        },
-      );
-
-      expect(html).toContain('/assets/route-a.css');
-    }
-  });
-
-  it('should derive css route ids from generic match snapshots', async () => {
-    const html = await buildShellBeforeTemplate(
-      `<html><head>${CHUNK_CSS_PLACEHOLDER}</head><body></body></html>`,
-      {
-        entryName: 'main',
-        runtimeContext: withRouterSnapshot(
-          {
-            routeManifest: {
-              routeAssets: {
-                'asset-route': {
-                  referenceCssAssets: ['/assets/asset-route.css'],
-                },
-                legacy: {
-                  referenceCssAssets: ['/assets/legacy.css'],
-                },
-              },
-            },
-          },
-          {
-            matches: [{ routeId: 'router-route', assetRouteId: 'asset-route' }],
-          },
-        ) as any,
-        config: {} as any,
-      },
-    );
-
-    expect(html).toContain('/assets/asset-route.css');
-    expect(html).not.toContain('/assets/legacy.css');
   });
 });
 
@@ -258,9 +193,6 @@ const chunk = (url: string, filename = url) => ({
   path: url,
 });
 
-const scriptUrls = (chunks: Array<{ url?: string }>) =>
-  chunks.map(item => item.url).filter(Boolean);
-
 describe('createRouteHydrationScriptTags', () => {
   it('does not treat substring matches in the template as existing scripts', () => {
     const runtimeContext = createRuntimeContextWithMatchedRoutes(['route-a']);
@@ -327,30 +259,6 @@ describe('LoadableCollector federated css', () => {
     );
   });
 
-  it('orders matched route scripts before the async entry script', () => {
-    const ordered = orderHydrationScriptChunks({
-      entryName: 'index',
-      asyncEntryChunks: [
-        chunk('/static/js/async/vendor.js'),
-        chunk('/static/js/async/async-index-123.js'),
-      ],
-      collectedChunks: [chunk('/static/js/async/loadable-child.js')],
-      matchedRouteChunks: [
-        chunk('/static/js/async/(lang)/page.js'),
-        chunk('/static/js/async/(lang)/checkout/page.js'),
-        chunk('/static/js/async/(lang)/page.js'),
-      ],
-    });
-
-    expect(scriptUrls(ordered)).toEqual([
-      '/static/js/async/vendor.js',
-      '/static/js/async/loadable-child.js',
-      '/static/js/async/(lang)/page.js',
-      '/static/js/async/(lang)/checkout/page.js',
-      '/static/js/async/async-index-123.js',
-    ]);
-  });
-
   it('does not fall back to runtime route manifest when options omit routeManifest', async () => {
     const chunkSet = {
       renderLevel: RenderLevel.CLIENT_RENDER,
@@ -412,24 +320,6 @@ test('registered asset policy orders native loadable output before the async ent
 });
 
 describe('SSR hydration helper matrix', () => {
-  const createRuntimeContext = (
-    matchedRouteIds: string[],
-    routeAssets: Record<string, { assets?: string[] }>,
-  ) => {
-    const runtimeContext = {
-      routeManifest: {
-        routeAssets,
-      },
-    } as any;
-
-    applyRouterRuntimeState(runtimeContext, {
-      framework: 'custom-router',
-      matchedRouteIds,
-    } as any);
-
-    return runtimeContext;
-  };
-
   it('dedupes hydration script chunks and generated tags by the exact script src', () => {
     expect(
       orderHydrationScriptChunks({
@@ -483,33 +373,5 @@ describe('SSR hydration helper matrix', () => {
         url: '/assets/async-main.123.js',
       },
     ]);
-
-    const runtimeContext = createRuntimeContext(['routes/dashboard'], {
-      'routes/dashboard': {
-        assets: [
-          '/assets/dashboard.js',
-          '/assets/shared.js',
-          '/assets/dashboard.css',
-          '/assets/dashboard.js',
-        ],
-      },
-      'async-main': {
-        assets: [
-          '/assets/async-main.js',
-          '/assets/shared.js',
-          '/assets/async-main.css',
-        ],
-      },
-    });
-
-    expect(
-      createRouteHydrationScriptTags(runtimeContext, 'main', {
-        nonce: 'nonce-1',
-        template:
-          '<script defer src="/assets/dashboard.js"></script><script src="/assets/shared.js?cache=1"></script>',
-      }),
-    ).toBe(
-      '<script src="/assets/shared.js" nonce="nonce-1"></script> <script src="/assets/async-main.js" nonce="nonce-1"></script>',
-    );
   });
 });

package/tests/nativeTemplatePolicy.test.tsx

@@ -38,11 +38,6 @@ const buildShellAfterTemplate = (template: string, options: any) =>
     ...options,
     lifecycle: lifecycleFor(options),
   });
-const getTemplates = (template: string, options: any) =>
-  nativeGetTemplates(template, {
-    ...options,
-    lifecycle: lifecycleFor(options),
-  });
 const createDataCollector = (options: any) => {
   const lifecycle = lifecycleFor(options, 'string');
   const collector = new SSRDataCollector({ ...options, lifecycle });
@@ -66,7 +61,6 @@ import { applyRouterRuntimeState } from '@modern-js/runtime-extensions/router-st
 import { RenderLevel } from '../../plugin-runtime/src/core/constants';
 import { SSR_DATA_PLACEHOLDER } from '../../plugin-runtime/src/core/server/constants';
 import { buildShellAfterTemplate as nativeBuildShellAfterTemplate } from '../../plugin-runtime/src/core/server/stream/afterTemplate';
-import { getTemplates as nativeGetTemplates } from '../../plugin-runtime/src/core/server/stream/template';
 import { SSRDataCollector } from '../../plugin-runtime/src/core/server/string/ssrData';
 
 const withRouterSnapshot = (
@@ -86,130 +80,6 @@ const scriptSrcs = (html: string) =>
   ).map(match => match[1] ?? match[2] ?? match[3]);
 
 describe('SSRDataCollector (stream parity)', () => {
-  it('should append router hydration script from the shared router snapshot', () => {
-    const chunkSet = {
-      renderLevel: RenderLevel.SERVER_RENDER,
-      ssrScripts: '',
-      jsChunk: '',
-      cssChunk: '',
-    };
-
-    const collector = createDataCollector({
-      runtimeContext: withRouterSnapshot(
-        {
-          initialData: {},
-          __i18nData__: {},
-        },
-        {
-          hydrationScript: '<script>window.__HYDRATE__ = "router";</script>',
-        },
-      ) as any,
-      request: new Request('http://localhost/'),
-      chunkSet,
-      ssrContext: {
-        request: {
-          params: {},
-          query: {},
-          pathname: '/',
-          host: 'localhost',
-          url: 'http://localhost/',
-          headers: {},
-        },
-        reporter: { sessionId: 'session-1' },
-      } as any,
-      ssrConfig: {} as any,
-    });
-
-    collector.effect();
-
-    expect(chunkSet.ssrScripts).toContain('window.__HYDRATE__ = "router";');
-  });
-
-  it('should inject generic router hydration scripts into stream templates', async () => {
-    const html = await buildShellAfterTemplate(SSR_DATA_PLACEHOLDER, {
-      entryName: 'main',
-      renderLevel: RenderLevel.SERVER_RENDER,
-      request: new Request('http://localhost/'),
-      runtimeContext: withRouterSnapshot(
-        {
-          initialData: {},
-          __i18nData__: {},
-          routeManifest: {},
-          ssrContext: {
-            request: {
-              params: {},
-              query: {},
-              pathname: '/',
-              host: 'localhost',
-              url: 'http://localhost/',
-              headers: {},
-            },
-            reporter: { sessionId: 'session-1' },
-          },
-        },
-        {
-          hydrationScripts: [
-            '<script>window.__STREAM_ROUTER_A__ = true;</script>',
-            '<script>window.__STREAM_ROUTER_B__ = true;</script>',
-          ],
-        },
-      ) as any,
-      ssrConfig: {} as any,
-      config: {} as any,
-    });
-
-    expect(html).toContain('window.__STREAM_ROUTER_A__ = true;');
-    expect(html).toContain('window.__STREAM_ROUTER_B__ = true;');
-  });
-
-  it('should inject matched route scripts before hydration', async () => {
-    const html = await buildShellAfterTemplate('<!--<?- chunksMap.js ?>-->', {
-      entryName: 'main',
-      renderLevel: RenderLevel.SERVER_RENDER,
-      request: new Request('http://localhost/products/shoe'),
-      runtimeContext: withRouterSnapshot(
-        {
-          routeManifest: {
-            routeAssets: {
-              layout: {
-                assets: ['/assets/layout.js'],
-              },
-              'products/$slug': {
-                assets: ['/assets/product.js', '/assets/product.css'],
-              },
-              'async-main': {
-                assets: ['/assets/main.js'],
-              },
-            },
-          },
-          initialData: {},
-          __i18nData__: {},
-          ssrContext: {
-            request: {
-              params: {},
-              query: {},
-              pathname: '/products/shoe',
-              host: 'localhost',
-              url: 'http://localhost/products/shoe',
-              headers: {},
-            },
-            reporter: { sessionId: 'session-1' },
-          },
-        },
-        {
-          matchedRouteIds: ['layout', 'products/$slug'],
-        },
-      ) as any,
-      ssrConfig: {} as any,
-      config: {} as any,
-    });
-
-    expect(html).toContain('<script src="/assets/layout.js"></script>');
-    expect(html).toContain('<script src="/assets/product.js"></script>');
-    expect(html).toContain('<script src="/assets/main.js"></script>');
-    expect(html).not.toContain('/assets/product.css');
-  });
-
   it('should move matched route scripts before the hydration entry script', async () => {
     const html = await buildShellAfterTemplate(
       '<script defer src="/static/js/index.js"></script><!--<?- chunksMap.js ?>-->',
@@ -262,203 +132,6 @@ describe('SSRDataCollector (stream parity)', () => {
       '/static/js/index.js',
     ]);
   });
-
-  it('should place stream hydration bootstrap before an async head entry', async () => {
-    const { shellBefore, shellAfter } = await getTemplates(
-      [
-        '<html><head>',
-        '<script async src="/static/js/index.js"></script>',
-        '</head><body><div id="root">',
-        '<!--<?- html ?>-->',
-        '</div>',
-        '<!--<?- chunksMap.js ?>-->',
-        SSR_DATA_PLACEHOLDER,
-        '</body></html>',
-      ].join(''),
-      {
-        entryName: 'index',
-        renderLevel: RenderLevel.SERVER_RENDER,
-        request: new Request('http://localhost/products/shoe'),
-        runtimeContext: withRouterSnapshot(
-          {
-            routeManifest: {
-              routeAssets: {
-                'products/$slug': {
-                  assets: ['/static/js/async/products/$slug.js'],
-                },
-                'async-index': {
-                  assets: ['/static/js/async/async-index.js'],
-                },
-              },
-            },
-            initialData: {},
-            __i18nData__: {},
-            ssrContext: {
-              request: {
-                params: {},
-                query: {},
-                pathname: '/products/shoe',
-                host: 'localhost',
-                url: 'http://localhost/products/shoe',
-                headers: {},
-              },
-              reporter: { sessionId: 'session-1' },
-            },
-          },
-          {
-            hydrationScripts: [
-              '<script>window.$_TSR = { router: "hydrated" };</script>',
-            ],
-            matchedRouteIds: ['products/$slug'],
-          },
-        ) as any,
-        ssrConfig: {} as any,
-        config: {} as any,
-      },
-    );
-
-    const html = `${shellBefore}<main>server markup</main>${shellAfter}`;
-    const entryIndex = html.indexOf(
-      '<script async src="/static/js/index.js"></script>',
-    );
-    const routeIndex = html.indexOf(
-      '<script src="/static/js/async/products/$slug.js"></script>',
-    );
-    const ssrDataIndex = html.indexOf('window._SSR_DATA =');
-    const routerBootstrapIndex = html.indexOf('window.$_TSR =');
-
-    expect(routeIndex).toBeGreaterThan(-1);
-    expect(ssrDataIndex).toBeGreaterThan(routeIndex);
-    expect(routerBootstrapIndex).toBeGreaterThan(ssrDataIndex);
-    expect(entryIndex).toBeGreaterThan(routerBootstrapIndex);
-    expect(html).not.toContain('<!--<?- chunksMap.js ?>-->');
-    expect(html).not.toContain(SSR_DATA_PLACEHOLDER);
-  });
-
-  it('should preserve JSON bootstrap and nonce before an async head entry', async () => {
-    const { shellBefore, shellAfter } = await getTemplates(
-      [
-        '<html><head>',
-        '<script async nonce="nonce-value" src="/static/js/index.js"></script>',
-        '</head><body><div id="root">',
-        '<!--<?- html ?>-->',
-        '</div>',
-        '<!--<?- chunksMap.js ?>-->',
-        SSR_DATA_PLACEHOLDER,
-        '</body></html>',
-      ].join(''),
-      {
-        entryName: 'index',
-        renderLevel: RenderLevel.SERVER_RENDER,
-        request: new Request('http://localhost/products/shoe'),
-        runtimeContext: withRouterSnapshot(
-          {
-            routeManifest: {
-              routeAssets: {
-                'products/$slug': {
-                  assets: ['/static/js/async/products/$slug.js'],
-                },
-              },
-            },
-            initialData: {},
-            __i18nData__: {},
-            ssrContext: {
-              request: {
-                params: {},
-                query: {},
-                pathname: '/products/shoe',
-                host: 'localhost',
-                url: 'http://localhost/products/shoe',
-                headers: {},
-              },
-              reporter: { sessionId: 'session-1' },
-            },
-          },
-          {
-            hydrationScripts: [
-              '<script nonce="nonce-value">window.$_TSR = { router: "hydrated" };</script>',
-            ],
-            matchedRouteIds: ['products/$slug'],
-          },
-        ) as any,
-        ssrConfig: {} as any,
-        config: {
-          nonce: 'nonce-value',
-          useJsonScript: true,
-        } as any,
-      },
-    );
-
-    const html = `${shellBefore}<main>server markup</main>${shellAfter}`;
-    const routeIndex = html.indexOf(
-      '<script src="/static/js/async/products/$slug.js" nonce="nonce-value"></script>',
-    );
-    const ssrDataIndex = html.indexOf(
-      '<script type="application/json" id="__MODERN_SSR_DATA__">',
-    );
-    const routerBootstrapIndex = html.indexOf('window.$_TSR =');
-    const entryIndex = html.indexOf(
-      '<script async nonce="nonce-value" src="/static/js/index.js"></script>',
-    );
-
-    expect(routeIndex).toBeGreaterThan(-1);
-    expect(ssrDataIndex).toBeGreaterThan(routeIndex);
-    expect(routerBootstrapIndex).toBeGreaterThan(ssrDataIndex);
-    expect(entryIndex).toBeGreaterThan(routerBootstrapIndex);
-    expect(html).not.toContain('window._SSR_DATA =');
-    expect(html).not.toContain('<!--<?- chunksMap.js ?>-->');
-    expect(html).not.toContain(SSR_DATA_PLACEHOLDER);
-  });
-
-  it('should preserve a custom stream template that omits script markers', async () => {
-    const template = '<script async src="/static/js/index.js"></script>';
-    const html = await buildShellAfterTemplate(template, {
-      entryName: 'index',
-      renderLevel: RenderLevel.SERVER_RENDER,
-      request: new Request('http://localhost/products/shoe'),
-      runtimeContext: withRouterSnapshot(
-        {
-          initialData: {},
-          __i18nData__: {},
-          routeManifest: {
-            routeAssets: {
-              'products/$slug': {
-                assets: ['/static/js/async/products/$slug.js'],
-              },
-              'async-index': {
-                assets: ['/static/js/async/async-index.js'],
-              },
-            },
-          },
-          ssrContext: {
-            request: {
-              params: {},
-              query: {},
-              pathname: '/products/shoe',
-              host: 'localhost',
-              url: 'http://localhost/products/shoe',
-              headers: {
-                'x-request-id': 'request-1',
-              },
-            },
-            reporter: { sessionId: 'session-1' },
-          },
-        },
-        {
-          hydrationScripts: [
-            '<script>window.__OMITTED_BOOTSTRAP__ = true;</script>',
-          ],
-          matchedRouteIds: ['products/$slug'],
-        },
-      ) as any,
-      ssrConfig: {
-        unsafeHeaders: ['x-request-id'],
-      } as any,
-      config: {} as any,
-    });
-
-    expect(html).toBe(template);
-  });
 });
 
 import React from 'react';
@@ -551,48 +224,6 @@ describe('renderString template assembly (string-mode script ordering)', () => {
     expect(html).not.toContain(SSR_DATA_PLACEHOLDER);
   });
 
-  it('should keep the async entry variant ordered after the bootstrap', async () => {
-    const html = await render(
-      [
-        '<html><head>',
-        '<script async src="/static/js/async-index.js"></script>',
-        '</head><body><div id="root">',
-        '<!--<?- html ?>-->',
-        '</div>',
-        SSR_DATA_PLACEHOLDER,
-        '</body></html>',
-      ].join(''),
-    );
-
-    const entryIndex = html.indexOf(
-      '<script async src="/static/js/async-index.js"></script>',
-    );
-    const routerBootstrapIndex = html.indexOf('window.$_TSR =');
-
-    expect(routerBootstrapIndex).toBeGreaterThan(-1);
-    expect(entryIndex).toBeGreaterThan(routerBootstrapIndex);
-  });
-
-  it('should fall back to in-place replacement when no entry script tag exists', async () => {
-    const html = await render(
-      [
-        '<html><head></head><body><div id="root">',
-        '<!--<?- html ?>-->',
-        '</div>',
-        '<span id="marker"></span>',
-        SSR_DATA_PLACEHOLDER,
-        '</body></html>',
-      ].join(''),
-    );
-
-    const markerIndex = html.indexOf('<span id="marker"></span>');
-    const ssrDataIndex = html.indexOf('window._SSR_DATA =');
-
-    expect(markerIndex).toBeGreaterThan(-1);
-    expect(ssrDataIndex).toBeGreaterThan(markerIndex);
-    expect(html).not.toContain(SSR_DATA_PLACEHOLDER);
-  });
-
   it('should preserve a custom template that omits script markers', async () => {
     const template =
       '<html><head><script async src="/static/js/index.js"></script></head><body>custom shell</body></html>';
@@ -732,87 +363,4 @@ describe('SSR data script generation', () => {
       loaderData: { route: { ok: true } },
     });
   });
-
-  it('should serialize generic router hydration scripts when present', () => {
-    const browser = executeScripts(
-      createScripts({
-        routerServerSnapshot: {
-          hydrationScripts: [
-            '<script>window.__ROUTER_A__ = true;</script>',
-            '<script>window.__ROUTER_B__ = true;</script>',
-          ],
-        },
-      }),
-    );
-
-    expect(browser.__ROUTER_A__).toBe(true);
-    expect(browser.__ROUTER_B__).toBe(true);
-  });
-});
-
-import {
-  injectBeforeHydrationEntryScript,
-  replaceChunkJsPlaceholder,
-} from '@modern-js/runtime-extensions';
-
-const matrixScriptSrcs = (html: string) =>
-  Array.from(html.matchAll(/<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*>/g)).map(
-    match => match[2],
-  );
-
-describe('string SSR script ordering', () => {
-  it('injects hydration route scripts before the entry bootstrap', () => {
-    const html = injectBeforeHydrationEntryScript(
-      '<head><script defer src="/static/js/index.abc.js"></script></head>',
-      '<script defer src="/static/js/async/(lang)/page.js"></script>',
-      'index',
-    );
-
-    expect(matrixScriptSrcs(html)).toEqual([
-      '/static/js/async/(lang)/page.js',
-      '/static/js/index.abc.js',
-    ]);
-  });
-
-  it('falls back to the async entry when the bootstrap script is absent', () => {
-    const html = injectBeforeHydrationEntryScript(
-      '<body><script defer src="/static/js/async/async-index.js"></script></body>',
-      '<script defer src="/static/js/async/(lang)/page.js"></script>',
-      'index',
-    );
-
-    expect(matrixScriptSrcs(html)).toEqual([
-      '/static/js/async/(lang)/page.js',
-      '/static/js/async/async-index.js',
-    ]);
-  });
-
-  it('preserves a template that omits the script marker', () => {
-    const template =
-      '<body><script defer src="/static/js/index.js"></script></body>';
-
-    expect(
-      replaceChunkJsPlaceholder(
-        template,
-        '<script src="/static/js/async/page.js"></script>',
-        undefined,
-        '<!--<?- chunksMap.js ?>-->',
-      ),
-    ).toBe(template);
-  });
-
-  it('orders scripts before the entry when the marker is present', () => {
-    const html = replaceChunkJsPlaceholder(
-      '<body><script defer src="/static/js/index.js"></script><!--<?- chunksMap.js ?>--></body>',
-      '<script src="/static/js/async/page.js"></script>',
-      undefined,
-      '<!--<?- chunksMap.js ?>-->',
-    );
-
-    expect(matrixScriptSrcs(html)).toEqual([
-      '/static/js/async/page.js',
-      '/static/js/index.js',
-    ]);
-    expect(html).not.toContain('<!--<?- chunksMap.js ?>-->');
-  });
 });

package/tests/runtimePlugin.test.tsx

@@ -1,37 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
-
-const packageDirectory = fileURLToPath(new URL('..', import.meta.url));
-
-// Resolve the public package entry, including its platform conditions.
-test.each([
-  'browser',
-  'node',
-] as const)('public %s entry selects the matching renderer adapter', async platform => {
-  const output = await build({
-    absWorkingDir: packageDirectory,
-    stdin: {
-      contents:
-        "export { default } from '@modern-js/runtime-renderer-extensions'",
-      resolveDir: packageDirectory,
-    },
-    bundle: true,
-    write: false,
-    metafile: true,
-    platform,
-    format: 'esm',
-    conditions: ['modern:source'],
-  });
-  const inputs = Object.keys(output.metafile.inputs);
-  expect(inputs.some(input => input.endsWith('/runtimePlugin.ts'))).toBe(true);
-  expect(
-    inputs.some(input => input.endsWith('/runtime-extensions/src/node.ts')),
-  ).toBe(platform === 'node');
-  expect(
-    inputs.some(
-      input =>
-        input === 'src/node.ts' ||
-        input.endsWith('/renderer-extensions/src/node.ts'),
-    ),
-  ).toBe(platform === 'node');
-});