@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.5 → 3.9.0-ultramodern.7

package/tests/request-policy/traceparent.test.ts

@@ -7,6 +7,8 @@ describe('parseTraceparent', () => {
   test.each([
     ['01', true],
     ['00', false],
+    ['03', true],
+    ['02', false],
   ])('parses a valid traceparent with flags %s', (flags, sampled) => {
     expect(parseTraceparent(`00-${traceId}-${spanId}-${flags}`)).toEqual({
       traceId,
@@ -27,11 +29,6 @@ describe('parseTraceparent', () => {
     });
   });
 
-  test('reads the sampled bit from arbitrary flag values', () => {
-    expect(parseTraceparent(`00-${traceId}-${spanId}-03`)?.sampled).toBe(true);
-    expect(parseTraceparent(`00-${traceId}-${spanId}-02`)?.sampled).toBe(false);
-  });
-
   test('rejects missing, empty, and malformed headers', () => {
     expect(parseTraceparent(undefined)).toBeUndefined();
     expect(parseTraceparent(null)).toBeUndefined();

package/tests/request-policy/transport-retry.test.ts

@@ -50,7 +50,6 @@ const executeRetryRequest = ({
 describe('transport retry behavior', () => {
   test.each([
     'FetchError',
-    'TimeoutError',
   ])('retries %s up to the configured max then rejects', async errorName => {
     rs.useFakeTimers();
     const errors = [
@@ -144,36 +143,35 @@ describe('transport retry behavior', () => {
     rs.useFakeTimers();
 
     try {
-      for (const statusCode of retryableStatusCodes) {
-        const retryableError = createStatusError(statusCode);
-        const response = { ok: true, status: 200 };
-        let callCount = 0;
-        const fetcher = rs.fn(async () => {
-          callCount += 1;
-          if (callCount === 1) {
-            throw retryableError;
-          }
-          return response;
-        });
+      const statusCode = retryableStatusCodes[0];
+      const retryableError = createStatusError(statusCode);
+      const response = { ok: true, status: 200 };
+      let callCount = 0;
+      const fetcher = rs.fn(async () => {
+        callCount += 1;
+        if (callCount === 1) {
+          throw retryableError;
+        }
+        return response;
+      });
 
-        const pending = executeRetryRequest({
-          fetcher,
-          retry: {
-            retries: 1,
-            baseDelayMs: 5,
-            maxDelayMs: 5,
-            jitterRatio: 0,
-          },
-        });
+      const pending = executeRetryRequest({
+        fetcher,
+        retry: {
+          retries: 1,
+          baseDelayMs: 5,
+          maxDelayMs: 5,
+          jitterRatio: 0,
+        },
+      });
 
-        await flushMicrotasks();
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        await rs.advanceTimersByTimeAsync(4);
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        await rs.advanceTimersByTimeAsync(1);
-        await expect(pending).resolves.toBe(response);
-        expect(fetcher).toHaveBeenCalledTimes(2);
-      }
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      await rs.advanceTimersByTimeAsync(4);
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      await rs.advanceTimersByTimeAsync(1);
+      await expect(pending).resolves.toBe(response);
+      expect(fetcher).toHaveBeenCalledTimes(2);
     } finally {
       await rs.advanceTimersByTimeAsync(1000);
       rs.useRealTimers();
@@ -181,25 +179,24 @@ describe('transport retry behavior', () => {
   });
 
   test('does not retry non-retryable status codes', async () => {
-    for (const statusCode of nonRetryableStatusCodes) {
-      const error = createStatusError(statusCode);
-      const fetcher = rs.fn(async () => {
-        throw error;
-      });
+    const statusCode = nonRetryableStatusCodes[0];
+    const error = createStatusError(statusCode);
+    const fetcher = rs.fn(async () => {
+      throw error;
+    });
 
-      await expect(
-        executeRetryRequest({
-          fetcher,
-          retry: {
-            retries: 2,
-            baseDelayMs: 1,
-            maxDelayMs: 1,
-            jitterRatio: 0,
-          },
-        }),
-      ).rejects.toBe(error);
-      expect(fetcher).toHaveBeenCalledTimes(1);
-    }
+    await expect(
+      executeRetryRequest({
+        fetcher,
+        retry: {
+          retries: 2,
+          baseDelayMs: 1,
+          maxDelayMs: 1,
+          jitterRatio: 0,
+        },
+      }),
+    ).rejects.toBe(error);
+    expect(fetcher).toHaveBeenCalledTimes(1);
   });
 
   test('uses a custom shouldRetry predicate instead of default rules', async () => {

package/tests/routerProvider.test.ts

@@ -1,10 +1,4 @@
-import {
-  createRouterPlugin,
-  registerRouterProvider,
-  unsafe_resetRouterProvidersForTesting,
-} from '../src/routerProvider';
-
-afterEach(() => unsafe_resetRouterProvidersForTesting());
+import { createRouterPlugin } from '../src/routerProvider';
 
 test('selects the injected app-local factory from runtime config and preserves native hook objects', () => {
   const registryHooks = { afterCreate: { call() {} } };
@@ -24,9 +18,7 @@ test('selects the injected app-local factory from runtime config and preserves n
   expect(defaultFactory).not.toHaveBeenCalled();
 });
 
-test('does not resolve missing local providers through the global compatibility registry', () => {
-  const foreign = rstest.fn(() => ({}));
-  registerRouterProvider('foreign', foreign);
+test('rejects missing local providers', () => {
   const factory = createRouterPlugin({
     defaultProvider: { name: 'native', factory: () => ({}) },
     registryHooks: {},
@@ -34,5 +26,4 @@ test('does not resolve missing local providers through the global compatibility
   expect(() =>
     factory({ framework: 'foreign' }).setup({ getRuntimeConfig: () => ({}) }),
   ).toThrow(/app-owned router provider realm/);
-  expect(foreign).not.toHaveBeenCalled();
 });

package/tests/routerState.test.ts

@@ -1,49 +1,14 @@
-import { createRuntimeContextExtension } from '../src/contextExtensions';
 import {
   applyRouterRuntimeState,
   applyRouterServerPrepareResult,
   cleanupRouterRuntimeState,
-  createRouterRuntimeState,
-  createRouterServerSnapshot,
   getRouterHydrationScripts,
   getRouterMatchedRouteIds,
   getRouterRuntimeState,
   getRouterServerSnapshot,
-  type InternalRouterRuntimeState,
 } from '../src/routerState';
 
 describe('router state primitives', () => {
-  it('normalizes snapshots without changing explicit values or input objects', () => {
-    const matches = [
-      { routeId: 'route-a', assetRouteId: 'asset-a' },
-      { routeId: 'route-b' },
-    ];
-    const snapshot = {
-      framework: 'custom',
-      hydrationScript: '<script>first()</script>',
-      matches,
-    };
-
-    expect(createRouterServerSnapshot(snapshot)).toEqual({
-      ...snapshot,
-      hydrationScripts: ['<script>first()</script>'],
-      matchedRouteIds: ['asset-a', 'route-b'],
-    });
-    expect(snapshot).not.toHaveProperty('hydrationScripts');
-    expect(snapshot).not.toHaveProperty('matchedRouteIds');
-    expect(
-      createRouterServerSnapshot({
-        ...snapshot,
-        hydrationScripts: ['<script>explicit()</script>'],
-        matchedRouteIds: [],
-      }),
-    ).toMatchObject({
-      hydrationScript: '<script>first()</script>',
-      hydrationScripts: ['<script>explicit()</script>'],
-      matchedRouteIds: [],
-    });
-  });
-
   it('preserves snapshot precedence and a captured snapshot across client state updates', () => {
     const context = { requestId: 'one' };
     expect(
@@ -79,27 +44,6 @@ describe('router state primitives', () => {
     expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
   });
 
-  it('shares interned slots across accessors and context spreads without serializing state', () => {
-    const context = { requestId: 'one' };
-    const state: InternalRouterRuntimeState = {
-      framework: 'custom',
-      instance: { private: true },
-      hydrationScript: 'legacy',
-      matches: [{ routeId: 'route', assetRouteId: 'asset' }],
-    };
-    const otherAccessor =
-      createRuntimeContextExtension<InternalRouterRuntimeState>(
-        '@modern-js/runtime:router-runtime-state',
-      );
-    otherAccessor.set(context, state);
-    expect(getRouterRuntimeState({ ...context })).toBe(state);
-    expect(getRouterHydrationScripts(context)).toEqual(['legacy']);
-    expect(getRouterMatchedRouteIds(context)).toEqual(['asset']);
-    expect(Object.keys(context)).toEqual(['requestId']);
-    expect(JSON.stringify(context)).toBe('{"requestId":"one"}');
-    expect(getRouterRuntimeState({})).toBeUndefined();
-  });
-
   it('applies server prepare overrides and awaits cleanup without propagating failures', async () => {
     const context = {};
     const stateCleanup = rstest.fn();
@@ -131,27 +75,4 @@ describe('router state primitives', () => {
     await expect(cleanupRouterRuntimeState(context)).resolves.toBeUndefined();
     await expect(cleanupRouterRuntimeState({})).resolves.toBeUndefined();
   });
-
-  it('keeps empty state empty and derives server data only when present', () => {
-    expect(createRouterRuntimeState({ framework: 'custom' })).toEqual({
-      framework: 'custom',
-    });
-    expect(getRouterHydrationScripts({})).toEqual([]);
-    expect(getRouterMatchedRouteIds({})).toBeUndefined();
-    expect(
-      createRouterRuntimeState({
-        framework: 'custom',
-        matches: [{ routeId: 'root' }],
-        hydrationScripts: ['first', 'second'],
-      }),
-    ).toMatchObject({
-      hydrationScript: 'first',
-      matchedRouteIds: ['root'],
-      serverSnapshot: {
-        framework: 'custom',
-        hydrationScripts: ['first', 'second'],
-        matchedRouteIds: ['root'],
-      },
-    });
-  });
 });

package/tests/routerStatePlugin.test.ts

@@ -1,5 +1,4 @@
 import {
-  applyRouterRuntimeState,
   getRouterRuntimeState,
   getRouterServerSnapshot,
 } from '../src/routerState';
@@ -24,8 +23,7 @@ function install() {
 }
 
 test('keeps injected hooks and per-context policies stable without sharing app values', () => {
-  const { plugin, registryHooks, beforeRender } = install();
-  expect(plugin.registryHooks).toBe(registryHooks);
+  const { beforeRender } = install();
   const first: any = {};
   const second: any = {};
   beforeRender(first);
@@ -36,25 +34,6 @@ test('keeps injected hooks and per-context policies stable without sharing app v
   expect(second.linkPrefetchPolicy).not.toBe(policy);
 });
 
-test('stores the exact native client instance and retains an earlier server snapshot', () => {
-  const { afterCreate } = install();
-  const context = {};
-  applyRouterRuntimeState(context, {
-    framework: 'react-router',
-    serverSnapshot: { statusCode: 207, matchedRouteIds: ['server'] },
-  });
-  const router = { navigate() {} };
-  afterCreate({
-    framework: 'react-router',
-    phase: 'client-create',
-    runtimeContext: context,
-    router,
-    basename: '/app',
-  });
-  expect(getRouterRuntimeState(context)?.instance).toBe(router);
-  expect(getRouterServerSnapshot(context)?.statusCode).toBe(207);
-});
-
 test('projects loader data, errors and valid route ids from injected SSR input', () => {
   const { afterCreate } = install();
   const errors = { route: new Error('route error') };
@@ -82,27 +61,3 @@ test('projects loader data, errors and valid route ids from injected SSR input',
     routerData: { loaderData: context.routerContext.loaderData, errors },
   });
 });
-
-test('leaves other providers and incomplete native preparation untouched', () => {
-  const { afterCreate } = install();
-  const context = {};
-  applyRouterRuntimeState(context, {
-    framework: 'tanstack',
-    hydrationScripts: ['<script>hydrate()</script>'],
-    matches: [{ routeId: 'r', assetRouteId: 'asset' }],
-  });
-  const state = getRouterRuntimeState(context);
-  afterCreate({
-    framework: 'tanstack',
-    phase: 'ssr-prepare',
-    runtimeContext: context,
-  });
-  expect(getRouterRuntimeState(context)).toBe(state);
-  const incomplete = {};
-  afterCreate({
-    framework: 'react-router',
-    phase: 'ssr-prepare',
-    runtimeContext: incomplete,
-  });
-  expect(getRouterRuntimeState(incomplete)).toBeUndefined();
-});

package/tests/runtimeContextProjection.test.ts

@@ -59,66 +59,14 @@ describe('fork runtime context projection', () => {
     expect(internal.requestContext).toBe(publicValue.requestContext);
     expect(internal.context).toBe(internal.requestContext);
     expect(publicValue.context).toBe(internal.requestContext);
-    expect(internal.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(internal.requestContext.response).toEqual({
-      locals: response.locals,
-    });
     expect(internal.requestContext.response.locals).toBe(response.locals);
-    expect(Object.keys(internal.requestContext.response)).toEqual(['locals']);
-    expect(typeof internal.requestContext.response.setHeader).toBe('function');
-    expect(typeof internal.requestContext.response.status).toBe('function');
     expect(context.ssrContext.response).toBe(response);
-    expect(Object.keys(response)).toEqual(['setHeader', 'status', 'locals']);
     expect(extension.get(context)).toBe(state);
     // Internal RSC copy behavior is retained pending separate Flight proof.
     expect(extension.get(internal)).toBe(state);
     expect(extension.get(publicValue)).toBeUndefined();
   });
 
-  it('provides the existing empty RSC request fallback when no SSR context exists', () => {
-    const context = { isBrowser: false };
-    const result = projectRuntimeContext(
-      { internalContext: context, publicContext: { ...context } },
-      { context, isRsc: true },
-    );
-    expect(result.internalContext).toMatchObject({
-      context: {
-        request: {
-          params: {},
-          pathname: '',
-          query: {},
-          headers: {},
-          host: '',
-          url: '',
-        },
-        response: { locals: {} },
-      },
-      requestContext: {
-        request: {
-          params: {},
-          pathname: '',
-          query: {},
-          headers: {},
-          host: '',
-          url: '',
-        },
-        response: { locals: {} },
-      },
-    });
-    expect(result.internalContext).not.toHaveProperty('ssrContext');
-    expect(context).toEqual({ isBrowser: false });
-  });
-
   it('does not apply server request projection to an RSC browser context', () => {
     const context = {
       isBrowser: true,

package/tests/safeFailure.test.ts

@@ -10,9 +10,7 @@ const readBody = async (response: Response) =>
 
 describe('safe failure responses', () => {
   it.each([
-    [404, 'REQUEST_FAILED', 'Request failed'],
     [500, 'INTERNAL_SERVER_ERROR', 'Internal Server Error'],
-    [503, 'SERVICE_UNAVAILABLE', 'Service Unavailable'],
   ])('redacts a %i failure through every response surface', async (status, code, message) => {
     const error = Object.assign(new Error('database-password'), {
       status,
@@ -54,23 +52,6 @@ describe('safe failure responses', () => {
 
   it.each([
     ['delay seconds text', ' 120 ', '120'],
-    ['leading-zero delay text', '000120', '120'],
-    ['delay seconds number', 2.1, '3'],
-    [
-      'largest safe delay number',
-      Number.MAX_SAFE_INTEGER,
-      String(Number.MAX_SAFE_INTEGER),
-    ],
-    [
-      'largest safe delay text',
-      String(Number.MAX_SAFE_INTEGER),
-      String(Number.MAX_SAFE_INTEGER),
-    ],
-    [
-      'canonical HTTP-date text',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-    ],
     [
       'valid Date object',
       new Date(Date.UTC(2026, 7, 30, 20, 0, 0)),
@@ -81,6 +62,16 @@ describe('safe failure responses', () => {
     expect(result.headers['Retry-After']).toBe(expected);
   });
 
+  it('derives Retry-After from a retryAfterSeconds error property', () => {
+    const error = Object.assign(new Error('maintenance'), {
+      status: 503,
+      retryAfterSeconds: 120,
+    });
+    expect(createSafeFailureHttpResult(error).headers['Retry-After']).toBe(
+      '120',
+    );
+  });
+
   it('converts Retry-After milliseconds to canonical delay seconds', () => {
     expect(
       createSafeFailureHttpResult({ status: 503, retryAfterMs: 2500 }).headers[
@@ -91,15 +82,6 @@ describe('safe failure responses', () => {
 
   it.each([
     ['a header injection payload', '120\r\nX-Injected: true'],
-    ['arbitrary text', 'after maintenance'],
-    ['an exponent string', '1e3'],
-    ['a decimal string', '2.1'],
-    ['a negative string', '-1'],
-    ['an unsafe integer string', '9007199254740992'],
-    ['an unsafe number', 1e21],
-    ['infinity', Number.POSITIVE_INFINITY],
-    ['a noncanonical date', 'Sunday, 30-Aug-26 20:00:00 GMT'],
-    ['an invalid date string', 'Wed, 99 Jun 2026 25:61:61 GMT'],
     ['an invalid Date object', new Date(Number.NaN)],
   ])('rejects %s as Retry-After', (_, retryAfter) => {
     const result = createSafeFailureHttpResult({ status: 503, retryAfter });