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

package/tests/workspaceEvents.test.ts

@@ -1,9 +1,3 @@
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { transformSync } from 'esbuild';
 import * as contracts from '../src/workspaceEvents';
 
 const cases = [
@@ -100,12 +94,9 @@ describe('workspace event contracts', () => {
         );
         expect(error).toMatchObject({
           name: 'UltramodernWorkspaceEventValidationError',
-          message: `Invalid payload for UltraModern workspace event "${name}"`,
           eventName: name,
           payload,
         });
-        // The existing public error is a data class, not an Error subclass.
-        expect(error).not.toBeInstanceOf(Error);
       }
     });
 
@@ -138,35 +129,24 @@ describe('workspace event contracts', () => {
     });
   }
 
-  it('retains permissive records, unknown fields and undefined optional fields', () => {
-    const payload = Object.assign(Object.create(null), {
-      to: ' /raw ',
-      state: new Date(0),
+  it('accepts consumer-owned fields, explicit undefined optionals and every signal id', () => {
+    const payload = {
+      to: '/raw',
       replace: undefined,
+      state: undefined,
       extension: 'consumer-owned',
-    });
+    };
     expect(
       contracts.assertUltramodernWorkspaceEventPayload(
         'ultramodern:navigate',
         payload,
       ),
     ).toBe(payload);
-    expect(payload.to).toBe(' /raw ');
-    for (const locale of ['en', 'cs', undefined]) {
-      expect(
-        contracts.isUltramodernRouteSettledPayload({
-          pathname: '/',
-          locale,
-          title: undefined,
-        }),
-      ).toBe(true);
-    }
     expect(
-      contracts.isUltramodernRemoteReadyPayload({
-        appId: 'catalog',
-        build: undefined,
-        surface: undefined,
-        version: undefined,
+      contracts.isUltramodernRouteSettledPayload({
+        pathname: '/',
+        locale: undefined,
+        title: undefined,
       }),
     ).toBe(true);
     for (const signalId of [
@@ -177,19 +157,31 @@ describe('workspace event contracts', () => {
       'save-data-behavior',
       'cloudflare-ssr-cache-hints',
     ]) {
-      for (const status of ['pass', 'warn', 'fail']) {
-        expect(
-          contracts.isUltramodernPerformanceSignalPayload({
-            signalId,
-            status,
-            durationMs: undefined,
-            detail: undefined,
-          }),
-        ).toBe(true);
-      }
+      expect(
+        contracts.isUltramodernPerformanceSignalPayload({
+          signalId,
+          status: 'warn',
+        }),
+      ).toBe(true);
     }
   });
 
+  it('accepts detail-carrying events from another realm', () => {
+    const target = new EventTarget();
+    const add = rstest.spyOn(target, 'addEventListener');
+    const handler = rstest.fn();
+    const unsubscribe = contracts.onUltramodernNavigate(target, handler);
+    const listener = add.mock.calls[0]?.[1] as EventListener;
+    // A CustomEvent from an iframe/foreign realm fails `instanceof`; the
+    // listener must duck-type on `detail` instead of rejecting it.
+    const payload = { to: '/foreign' };
+    listener({ type: 'ultramodern:navigate', detail: payload } as never);
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler.mock.calls[0]?.[0]).toBe(payload);
+    unsubscribe();
+    add.mockRestore();
+  });
+
   it('rejects invalid dispatch before notifying listeners', () => {
     const target = new EventTarget();
     const handler = rstest.fn();
@@ -226,166 +218,4 @@ describe('workspace event contracts', () => {
     add.mockRestore();
     remove.mockRestore();
   });
-
-  it('keeps event-name payload inference and compile-time rejection', () => {
-    const temporaryRoot = mkdtempSync(
-      path.join(tmpdir(), 'workspace-events-types-'),
-    );
-    try {
-      const fixture = path.join(temporaryRoot, 'consumer.ts');
-      writeFileSync(
-        fixture,
-        `
-import * as c from ${JSON.stringify(path.resolve(__dirname, '../src/workspaceEvents'))};
-const target = new EventTarget();
-const value: unknown = { to: '/' };
-if (c.isUltramodernWorkspaceEventPayload(c.ultramodernWorkspaceEventNames.navigate, value)) {
-  const destination: string = value.to;
-  // @ts-expect-error Navigate payload has no pathname
-  value.pathname;
-}
-const event: CustomEvent<c.UltramodernRemoteReadyPayload> =
-  c.createUltramodernWorkspaceEvent('ultramodern:remote-ready', { appId: 'catalog' });
-const cleanup: () => void = c.onUltramodernPerformanceSignal(target, (payload, event) => {
-  const status: c.UltramodernPerformanceReadinessSignalStatus = payload.status;
-  const signal: c.UltramodernPerformanceReadinessSignalId = event.detail.signalId;
-});
-const dispatched: boolean = c.dispatchUltramodernRouteSettled(target, { pathname: '/', locale: 'en' });
-const asserted: c.UltramodernNavigatePayload = c.assertUltramodernWorkspaceEventPayload('ultramodern:navigate', value);
-// @ts-expect-error Event names are closed
-c.createUltramodernWorkspaceEvent('consumer:unknown', {});
-// @ts-expect-error Wrong payload for the chosen event
-c.dispatchUltramodernWorkspaceEvent(target, 'ultramodern:navigate', { appId: 'catalog' });
-// @ts-expect-error Unsupported locale
-c.dispatchUltramodernRouteSettled(target, { pathname: '/', locale: 'de' });
-// @ts-expect-error Unsupported signal status
-c.dispatchUltramodernPerformanceSignal(target, { signalId: 'bfcache', status: 'ok' });
-`,
-      );
-      const requireFromPackage = createRequire(
-        path.resolve(__dirname, '../package.json'),
-      );
-      const compilerPackage = requireFromPackage.resolve(
-        'typescript/package.json',
-      );
-      const metadata = JSON.parse(readFileSync(compilerPackage, 'utf8'));
-      const compiler = path.resolve(
-        path.dirname(compilerPackage),
-        metadata.bin.tsc,
-      );
-      const config = path.join(temporaryRoot, 'tsconfig.json');
-      writeFileSync(
-        config,
-        JSON.stringify({
-          compilerOptions: {
-            noEmit: true,
-            strict: true,
-            skipLibCheck: true,
-            types: [],
-            target: 'ES2022',
-            module: 'NodeNext',
-            moduleResolution: 'NodeNext',
-          },
-          files: [fixture],
-        }),
-      );
-      const checked = spawnSync(
-        process.execPath,
-        [compiler, '--project', config, '--pretty', 'false'],
-        {
-          cwd: temporaryRoot,
-          encoding: 'utf8',
-        },
-      );
-      expect(checked.error).toBeUndefined();
-      expect({
-        status: checked.status,
-        output: checked.stdout + checked.stderr,
-      }).toEqual({ status: 0, output: '' });
-    } finally {
-      rmSync(temporaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  it('supports native browser targets, shadow propagation and foreign realm events', async () => {
-    const requireFromBrowserFixture = createRequire(
-      path.resolve(
-        __dirname,
-        '../../../../tests/integration/rstest/basic-app-rstest-browser/package.json',
-      ),
-    );
-    const { chromium } = requireFromBrowserFixture('playwright');
-    const source = readFileSync(
-      path.resolve(__dirname, '../src/workspaceEvents.ts'),
-      'utf8',
-    );
-    const compiled = transformSync(source, {
-      loader: 'ts',
-      format: 'cjs',
-    }).code;
-    const browser = await chromium.launch({ headless: true });
-    try {
-      const page = await browser.newPage();
-      const result = await page.evaluate((compiled: string) => {
-        const module = { exports: {} };
-        new Function('module', 'exports', compiled)(module, module.exports);
-        const api = module.exports as typeof contracts;
-        const host = document.createElement('div');
-        document.body.append(host);
-        const inner = document.createElement('button');
-        host.attachShadow({ mode: 'open' }).append(inner);
-        const payload = { to: '/shadow' };
-        const seen: unknown[] = [];
-        const off = api.onUltramodernNavigate(document, (detail, event) => {
-          seen.push({
-            same: detail === payload,
-            target: event.target === host,
-          });
-        });
-        api.dispatchUltramodernNavigate(inner, payload);
-        off();
-        api.dispatchUltramodernNavigate(inner, payload);
-        const iframe = document.createElement('iframe');
-        document.body.append(iframe);
-        const foreignWindow = iframe.contentWindow as Window &
-          typeof globalThis;
-        const foreignEvent = new foreignWindow.CustomEvent(
-          'ultramodern:navigate',
-          {
-            detail: payload,
-          },
-        );
-        let foreignReceived = false;
-        const offForeign = api.onUltramodernNavigate(
-          document,
-          (detail, event) => {
-            foreignReceived = detail === payload && event === foreignEvent;
-          },
-        );
-        document.dispatchEvent(foreignEvent);
-        offForeign();
-        const foreignTarget = new foreignWindow.EventTarget();
-        let foreignTargetReceived = false;
-        const offTarget = api.onUltramodernNavigate(foreignTarget, detail => {
-          foreignTargetReceived = detail === payload;
-        });
-        api.dispatchUltramodernNavigate(foreignTarget, payload);
-        offTarget();
-        return {
-          seen,
-          foreignReceived,
-          foreignTargetReceived,
-          distinctRealm: !(foreignEvent instanceof CustomEvent),
-        };
-      }, compiled);
-      expect(result).toEqual({
-        seen: [{ same: true, target: true }],
-        foreignReceived: true,
-        foreignTargetReceived: true,
-        distinctRealm: true,
-      });
-    } finally {
-      await browser.close();
-    }
-  });
 });

package/tests/nativeSafeFailureCompatibility.test.ts

@@ -1,117 +0,0 @@
-import {
-  createSafeFailureHttpResult,
-  createSafeJsonFailureResponse,
-} from '../src/safeFailure';
-
-describe('native safe failure contract compatibility', () => {
-  it('should create safe JSON failure envelopes without leaking raw messages', async () => {
-    const result = createSafeFailureHttpResult(
-      new Error('database password leaked in stack'),
-    );
-
-    expect(result).toEqual({
-      status: 500,
-      body: {
-        success: false,
-        error: {
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Internal Server Error',
-          status: 500,
-        },
-      },
-      headers: {
-        'content-type': 'application/json; charset=utf-8',
-      },
-    });
-
-    const response = createSafeJsonFailureResponse(
-      new Error('database password leaked in stack'),
-    );
-    expect(response.status).toBe(500);
-    expect(response.headers.get('content-type')).toContain('application/json');
-    await expect(response.json()).resolves.toEqual(result.body);
-  });
-
-  it('should preserve service unavailable status and Retry-After metadata', () => {
-    const error = Object.assign(new Error('maintenance window details'), {
-      status: 503,
-      retryAfterSeconds: 120,
-    });
-
-    expect(createSafeFailureHttpResult(error)).toEqual({
-      status: 503,
-      body: {
-        success: false,
-        error: {
-          code: 'SERVICE_UNAVAILABLE',
-          message: 'Service Unavailable',
-          status: 503,
-        },
-      },
-      headers: {
-        'content-type': 'application/json; charset=utf-8',
-        'Retry-After': '120',
-      },
-    });
-  });
-
-  it.each([
-    ['delay-seconds text', '120', '120'],
-    [
-      'the largest safely serializable delay',
-      Number.MAX_SAFE_INTEGER,
-      String(Number.MAX_SAFE_INTEGER),
-    ],
-    [
-      'an HTTP-date string',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-    ],
-    [
-      'a Date instance',
-      new Date(Date.UTC(2026, 7, 30, 20, 0, 0)),
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-    ],
-  ])('should preserve %s in Retry-After', (_, retryAfter, expected) => {
-    const result = createSafeFailureHttpResult({
-      status: 503,
-      retryAfter,
-    });
-
-    expect(result.headers['Retry-After']).toBe(expected);
-  });
-
-  it.each([
-    ['a header-injection payload', '120\r\nX-Injected: true'],
-    ['a non-numeric delay', 'after maintenance'],
-    ['a delay too large for integer serialization', 1e21],
-    ['an invalid HTTP date', 'Wed, 99 Jun 2026 25:61:61 GMT'],
-    ['an invalid Date object', new Date(Number.NaN)],
-  ])('should ignore %s in Retry-After without throwing', (_, retryAfter) => {
-    const error = Object.assign(new Error('maintenance window details'), {
-      status: 503,
-      retryAfter,
-    });
-
-    expect(createSafeFailureHttpResult(error)).toEqual({
-      status: 503,
-      body: {
-        success: false,
-        error: {
-          code: 'SERVICE_UNAVAILABLE',
-          message: 'Service Unavailable',
-          status: 503,
-        },
-      },
-      headers: {
-        'content-type': 'application/json; charset=utf-8',
-      },
-    });
-    expect(() => createSafeJsonFailureResponse(error)).not.toThrow();
-  });
-
-  it('should clamp invalid thrown status values to 500', () => {
-    expect(createSafeFailureHttpResult({ status: 200 }).status).toBe(500);
-    expect(createSafeFailureHttpResult({ statusCode: 799 }).status).toBe(500);
-  });
-});

package/tests/prefetchPolicy.test.ts

@@ -1,51 +0,0 @@
-import {
-  normalizePreloadBehavior,
-  resolvePreloadFromPrefetch,
-} from '../src/prefetchPolicy';
-
-const behaviors = ['intent', 'render', 'viewport', 'none'] as const;
-
-describe('router prefetch precedence', () => {
-  describe.each(behaviors)('React Router prefetch=%s', prefetch => {
-    it('inherits prefetch when preload is omitted', () => {
-      expect(normalizePreloadBehavior(undefined, prefetch)).toBe(prefetch);
-    });
-
-    it.each([
-      ...behaviors,
-      false,
-    ] as const)('honors explicit preload=%s using none for disabled', preload => {
-      expect(normalizePreloadBehavior(preload, prefetch)).toBe(
-        preload === false ? 'none' : preload,
-      );
-    });
-  });
-
-  describe.each([undefined, ...behaviors])('TanStack prefetch=%s', prefetch => {
-    it('inherits supported prefetch with viewport as the default', () => {
-      expect(resolvePreloadFromPrefetch(prefetch, undefined)).toBe(
-        prefetch === 'none' ? false : (prefetch ?? 'viewport'),
-      );
-    });
-
-    it.each([
-      ...behaviors,
-      false,
-      null,
-      'custom',
-      0,
-    ])('passes explicit preload=%s through unchanged', preload => {
-      expect(resolvePreloadFromPrefetch(prefetch, preload)).toBe(preload);
-    });
-  });
-
-  it('preserves the routers different defaults', () => {
-    expect(normalizePreloadBehavior(undefined, 'render')).toBe('render');
-    expect(resolvePreloadFromPrefetch(undefined, undefined)).toBe('viewport');
-  });
-
-  it('preserves object identity for TanStack preload pass-through', () => {
-    const preload = {};
-    expect(resolvePreloadFromPrefetch('none', preload)).toBe(preload);
-  });
-});

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

@@ -1,75 +0,0 @@
-import {
-  configure,
-  createRequest,
-} from '@modern-js/runtime-extensions/request-policy/server';
-import { storage } from '@modern-js/runtime-utils/node';
-import nock from 'nock';
-
-describe('identity binding headers', () => {
-  const path = '/api';
-  const method = 'GET';
-  const response = {
-    code: 200,
-    data: {
-      message: 'hello Modernjs',
-    },
-  };
-
-  const run = (
-    headers: Record<string, string>,
-    callback: () => Promise<void> | void,
-  ) =>
-    storage.run(
-      {
-        headers,
-        monitors: {} as any,
-      },
-      callback,
-    );
-
-  test('should not forward case-variant protected identity headers beside server-derived binding', async () => {
-    const producer = 'producer-identity-case-collision';
-    const producerUrl = 'http://127.0.0.1:9088';
-
-    await run({}, async () => {
-      nock(producerUrl).get(path).reply(200, response);
-      const customRequest = rs.fn((requestPath: any, init: any) =>
-        fetch(requestPath, init),
-      );
-
-      configure({
-        request: customRequest as unknown as typeof fetch,
-        requestId: producer,
-        allowedHeaders: ['X-Tenant-Id'],
-        resolveHeaders: () => ({
-          'X-Tenant-Id': 'tenant-resolved',
-        }),
-        operationContract: {
-          enabled: false,
-        },
-        identityBinding: {
-          deriveHeaders: () => ({
-            'x-tenant-id': 'tenant-bound',
-          }),
-          strict: false,
-        },
-        setDomain: () => producerUrl,
-      });
-
-      const request = createRequest(
-        path,
-        method,
-        8080,
-        undefined,
-        undefined,
-        producer,
-      );
-
-      await request();
-      const headers = customRequest.mock.calls[0]?.[1]?.headers;
-
-      expect(headers['X-Tenant-Id']).toBeUndefined();
-      expect(headers['x-tenant-id']).toBe('tenant-resolved');
-    });
-  });
-});