@bleedingdev/modern-js-renderer-core 3.9.3-ultramodern.8 → 3.9.3-ultramodern.9

package/dist/types/worker-federation/contract.d.ts

@@ -0,0 +1,70 @@
+import { type RendererIdentity } from '../identity.js';
+export declare const WORKER_FEDERATION_METADATA_KEY = "ultramodernWorkerFederation";
+export declare const WORKER_FEDERATION_SCHEMA = "ultramodern.worker-federation";
+export declare const WORKER_FEDERATION_VERSION = 1;
+export interface WorkerFederationExpose {
+    readonly entryName: string;
+    readonly boundaryId: string;
+    readonly paths: Readonly<Record<string, string>>;
+    readonly native: {
+        readonly publisherBuildId: string;
+        readonly runtimeABI: 1;
+    };
+}
+export interface WorkerFederationPublication {
+    readonly schema: typeof WORKER_FEDERATION_SCHEMA;
+    readonly schemaVersion: typeof WORKER_FEDERATION_VERSION;
+    readonly remote: string;
+    readonly exposes: Readonly<Record<string, WorkerFederationExpose>>;
+}
+/** The canonical renderer-contract reader and compatibility check are required. */
+export type AdmitWorkerRendererContract = (value: unknown) => {
+    readonly identities: Readonly<Record<string, RendererIdentity>>;
+};
+export interface WorkerFederationAuthority {
+    readonly origin: string;
+    readonly renderer: ReturnType<AdmitWorkerRendererContract>;
+    readonly worker: WorkerFederationPublication;
+}
+export interface AdmittedWorkerFederationExpose {
+    readonly authority: WorkerFederationAuthority;
+    readonly expose: string;
+    readonly locale: string;
+    readonly coordinate: WorkerFederationExpose;
+    readonly path: string;
+    readonly identity: Readonly<RendererIdentity>;
+    readonly endpoint: string;
+    /** Browser styles captured from this exact admitted manifest/expose. */
+    readonly styles: readonly string[];
+}
+export interface WorkerFederationEnvelope {
+    readonly schema: 'ultramodern.worker-federation-request' | 'ultramodern.worker-federation-response';
+    readonly schemaVersion: 1;
+    readonly authority: WorkerFederationAuthority;
+    readonly expose: string;
+    readonly locale: string;
+    /** Encoded and decoded by the native renderer; the framework never reads it. */
+    readonly payload: unknown;
+}
+export declare function workerFederationRecord(value: unknown, label: string): Record<string, unknown>;
+export declare function readWorkerFederationPath(value: unknown): string;
+export declare function readWorkerFederationManifestUrl(value: string): URL;
+export declare function readWorkerFederationPublication(value: unknown, identities: Readonly<Record<string, RendererIdentity>>): WorkerFederationPublication;
+/** Stable JSON also prevents non-wire values from silently changing on POST. */
+export declare function workerFederationWireJson(value: unknown): string;
+/** Preserve the completed MF browser publicPath/asset URL semantics. */
+export declare function readWorkerFederationStyles(options: {
+    manifest: unknown;
+    manifestUrl: string;
+    expose: string;
+}): readonly string[];
+export declare function admitWorkerFederationExpose(options: {
+    manifest: unknown;
+    manifestUrl: string;
+    remote: string;
+    expose: string;
+    locale: string;
+    admitRendererContract: AdmitWorkerRendererContract;
+}): AdmittedWorkerFederationExpose;
+export declare function workerFederationEnvelope(kind: 'request' | 'response', admitted: AdmittedWorkerFederationExpose, payload: unknown): WorkerFederationEnvelope;
+export declare function readWorkerFederationEnvelope(value: unknown, kind: 'request' | 'response', admitted: AdmittedWorkerFederationExpose): unknown;

package/dist/types/worker-federation/handler.d.ts

@@ -0,0 +1,21 @@
+import { type AdmittedWorkerFederationExpose, type AdmitWorkerRendererContract } from './contract.js';
+export interface WorkerFederationExecution {
+    readonly admitted: AdmittedWorkerFederationExpose;
+    readonly signal: AbortSignal;
+}
+/** Bind once to the compiled registry and this Worker's own publication. */
+export declare function createWorkerFederationHandler<NativeRequest>(options: {
+    publication: {
+        readonly renderer: unknown;
+        readonly worker: unknown;
+    };
+    manifestUrl: string;
+    exposes: Readonly<Record<string, () => Promise<unknown>>>;
+    admitRendererContract: AdmitWorkerRendererContract;
+    /** Native codec admission runs before even loading the exposed module. */
+    admitNativeRequest(payload: unknown, execution: WorkerFederationExecution): NativeRequest | Promise<NativeRequest>;
+    /** Close the admitted native lease, including a preparation resolving after abort. */
+    releaseNativeRequest(request: NativeRequest): void | Promise<void>;
+    renderNativeSnapshot(module: unknown, request: NativeRequest, execution: WorkerFederationExecution): unknown | Promise<unknown>;
+    requestTimeout?: number;
+}): (request: Request) => Promise<Response | undefined>;

package/dist/types/worker-federation/index.d.ts

@@ -0,0 +1,6 @@
+export type { AdmittedWorkerFederationExpose, AdmitWorkerRendererContract, WorkerFederationAuthority, WorkerFederationExpose, WorkerFederationPublication, } from './contract.js';
+export { readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationPublication, WORKER_FEDERATION_METADATA_KEY, WORKER_FEDERATION_SCHEMA, WORKER_FEDERATION_VERSION, } from './contract.js';
+export type { WorkerFederationExecution } from './handler.js';
+export { createWorkerFederationHandler } from './handler.js';
+export type { WorkerFederationService, WorkerFederationSnapshot, WorkerFederationTransport, } from './transport.js';
+export { createWorkerFederationTransport } from './transport.js';

package/dist/types/worker-federation/lease.d.ts

@@ -0,0 +1,11 @@
+export declare function checkWorkerFederationDeadline(deadlineAt: number, signal?: AbortSignal, controller?: AbortController): void;
+export declare function workerFederationErrorMessage(error: unknown, fallback: string, maxLength?: number): string;
+export declare function workerAbortReason(signal: AbortSignal): unknown;
+export declare function workerAbortable<T>(operation: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function readWorkerFederationJsonBody(body: ReadableStream<Uint8Array>, signal: AbortSignal, contentLength?: string | null, checkDeadline?: () => void): Promise<unknown>;
+export declare const WORKER_FEDERATION_MAX_BODY_BYTES: number;
+export declare class WorkerFederationBodyTooLargeError extends Error {
+    constructor();
+}
+/** Count UTF-8 bytes without allocating a second encoded body. */
+export declare function assertWorkerFederationBodySize(value: string): string;

package/dist/types/worker-federation/transport.d.ts

@@ -0,0 +1,47 @@
+import { type AdmittedWorkerFederationExpose, type AdmitWorkerRendererContract } from './contract.js';
+export interface WorkerFederationService {
+    readonly remote: string;
+    /** Existing MF import alias, mapped to the pinned topology publisher. */
+    readonly alias?: string;
+    readonly manifestUrl: string;
+    readonly fragments: readonly {
+        readonly expose: string;
+        readonly boundaryId: string;
+        readonly paths: Readonly<Record<string, string>>;
+    }[];
+    /** A configured Workers service binding, never a caller-selected fetch target. */
+    fetch(request: Request): Promise<Response>;
+}
+export interface WorkerFederationSnapshot {
+    readonly admitted: AdmittedWorkerFederationExpose;
+    readonly payload: unknown;
+}
+export interface WorkerFederationTransport {
+    /** Retire the owning document, its authorities and outstanding requests. */
+    dispose(reason?: unknown): void;
+    /** Admit lazily before constructing the native snapshot boundary. */
+    admit(options: {
+        remote: string;
+        expose: string;
+        locale: string;
+        signal?: AbortSignal;
+    }): Promise<AdmittedWorkerFederationExpose>;
+    /** Deduplicate active requests only; the native boundary owns settled snapshots. */
+    request(options: {
+        remote: string;
+        expose: string;
+        locale: string;
+        /** Already encoded by the renderer's native wire codec. */
+        payload: unknown;
+        signal?: AbortSignal;
+    }): Promise<WorkerFederationSnapshot>;
+}
+export declare function createWorkerFederationTransport(options: {
+    services: readonly WorkerFederationService[];
+    admitRendererContract: AdmitWorkerRendererContract;
+    fetchManifest?: (request: Request) => Promise<Response>;
+    /** One lease covers manifest headers/body and snapshot headers/body. */
+    requestTimeout?: number;
+    /** The document handle owns this transport's complete lifetime. */
+    signal?: AbortSignal;
+}): WorkerFederationTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bleedingdev/modern-js-renderer-core",
-  "version": "3.9.3-ultramodern.8",
+  "version": "3.9.3-ultramodern.9",
   "description": "UltraModern native renderer request, data and document contracts.",
   "license": "MIT",
   "repository": {
@@ -106,6 +106,16 @@
         "default": "./dist/cjs/server/index.js"
       }
     },
+    "./worker-federation": {
+      "import": {
+        "types": "./dist/types/worker-federation/index.d.ts",
+        "default": "./dist/esm/worker-federation/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/worker-federation/index.d.ts",
+        "default": "./dist/cjs/worker-federation/index.js"
+      }
+    },
     "./entry-client": {
       "import": {
         "types": "./dist/types/entry-client.d.ts",
@@ -142,7 +152,7 @@
     }
   },
   "devDependencies": {
-    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.3-ultramodern.8",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.3-ultramodern.9",
     "@rsbuild/core": "2.2.13",
     "@rslib/core": "1.0.3",
     "@scripts/rstest-config": "2.66.0",

package/src/adapter.ts

@@ -250,6 +250,8 @@ export function nativeRendererDependencies(
         ([name]) => !name.startsWith('@modern-js/'),
       ),
     ),
-    [profile.router.coreName]: profile.router.coreVersion,
+    [profile.router.coreName]:
+      profile.dependencies[profile.router.coreName] ??
+      profile.router.coreVersion,
   };
 }

package/src/entry-client.ts

@@ -78,6 +78,8 @@ export interface NativeClientAdapter<
     application: NativeRoutedApplication,
     options: NativeRouterOptions,
   ): Router;
+  /** Release the router and browser history created for this entry. */
+  disposeRouter(router: Router): void;
   /** Load a fresh router, or adopt the server's matches when hydrating. */
   prepareRouter(
     router: Router,
@@ -197,6 +199,9 @@ export function startNativeClientEntry<
         ? { rewrite: i18n.rewrite(() => current.language) }
         : {}),
     });
+    const releaseRouter = () => adapter.disposeRouter(router);
+    if (signal.aborted) releaseRouter();
+    else signal.addEventListener('abort', releaseRouter, { once: true });
     // HMR disposal aborts the signal; a failed start stops the sync too.
     const stopSync =
       i18n && current ? i18n.syncWithRouter(router, current) : undefined;

package/src/federation.ts

@@ -1,8 +1,17 @@
+/** The Node dev runtime captures assets before releasing a container load. */
+const LOAD_WITH_CAPTURE = Symbol.for(
+  'ultramodern.federation.load-with-capture',
+);
+
 /** The application compiler's native Module Federation runtime. */
 export interface FederationInstance {
   /** The application's federation name, unique among this realm's instances. */
   readonly name?: string;
   loadRemote<T>(id: string): Promise<T | null>;
+  [LOAD_WITH_CAPTURE]?: <T, Captured>(
+    id: string,
+    capture: (module: T | null, resolution?: LoadResolution) => Captured,
+  ) => Promise<{ module: T | null; captured: Captured | undefined }>;
   readonly remoteHandler?: {
     readonly idToRemoteMap?: Record<string, { name: string; expose: string }>;
   };
@@ -27,6 +36,11 @@ interface RemoteSnapshot {
   }[];
 }
 
+interface LoadResolution {
+  readonly remoteSnapshot: unknown;
+  readonly expose: string;
+}
+
 /** Generated entries retain their own compiler's host, including on the server. */
 export interface NativeFederationBinding {
   readonly instance: () => FederationInstance;
@@ -59,27 +73,41 @@ export function getFederationHost(
 export async function loadFederatedModule<T>(
   instance: FederationInstance | undefined,
   id: string,
-): Promise<T> {
+): Promise<{ module: T; assets: FederatedAssets | undefined }> {
   if (!instance)
     throw new Error(
       `Cannot load ${id}: this application has no Module Federation runtime. Add module-federation.config.ts with its remotes.`,
     );
-  const module = await instance.loadRemote<T>(id);
+  const coupledLoad = instance[LOAD_WITH_CAPTURE];
+  const result = coupledLoad
+    ? await coupledLoad<T, FederatedAssets | undefined>(
+        id,
+        (_module, resolution) => remoteBrowserAssets(instance, id, resolution),
+      )
+    : {
+        module: await instance.loadRemote<T>(id),
+        captured: remoteBrowserAssets(instance, id),
+      };
+  const module = result.module;
   if (!module) throw new Error(`Remote module ${id} is unavailable`);
-  return module;
+  return { module, assets: result.captured };
 }
 
 /** Browser assets from the native snapshot that admitted and loaded this remote. */
 export function remoteBrowserAssets(
   instance: FederationInstance,
   id: string,
+  resolution?: LoadResolution,
 ): FederatedAssets | undefined {
   const target = instance.remoteHandler?.idToRemoteMap?.[id];
   const loaded = target && instance.moduleCache?.get(target.name);
-  const snapshot =
-    loaded &&
-    instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo)
-      .remoteSnapshot;
+  const snapshot = (
+    resolution
+      ? resolution.remoteSnapshot
+      : loaded &&
+        instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo)
+          .remoteSnapshot
+  ) as RemoteSnapshot | undefined;
   if (
     !snapshot ||
     typeof snapshot.publicPath !== 'string' ||
@@ -89,7 +117,7 @@ export function remoteBrowserAssets(
   )
     return undefined;
   const expose = snapshot.modules?.find(
-    module => module.modulePath === target.expose,
+    module => module.modulePath === (resolution?.expose ?? target?.expose),
   );
   if (!expose?.assets) return undefined;
   const publicPath = snapshot.publicPath;

package/src/server/types.ts

@@ -1,6 +1,7 @@
 import type { DocumentAsset } from '../document';
 import type { RendererIdentity } from '../identity';
 import type { RequestPlatform, RequestSession } from '../session';
+import type { WorkerFederationTransport } from '../worker-federation';
 
 /** Native route matching remains with the selected router adapter. */
 export interface NativeServerConfig {
@@ -17,6 +18,8 @@ export interface NativeRequestContext<Bindings extends object = object> {
   readonly nativeManifest?: unknown;
   readonly serverConfig?: NativeServerConfig;
   readonly entry: Readonly<RendererIdentity>;
+  /** Request-owned service transport for native Worker snapshot boundaries. */
+  readonly workerFederation?: WorkerFederationTransport;
 }
 
 export type NativeRequestHandler<Bindings extends object = object> = (

package/src/server/worker.ts

@@ -1,5 +1,9 @@
 import { collectDocumentAssets, type DocumentAsset } from '../document';
 import { assertRendererIdentity, type RendererIdentity } from '../identity';
+import type {
+  WorkerFederationPublication,
+  WorkerFederationTransport,
+} from '../worker-federation';
 import { dispatchNativeRequest, rejectNativeRscRequest } from './dispatch';
 import type {
   NativeExecutionContext,
@@ -17,6 +21,22 @@ export interface NativeWorkerEntryResources {
   /** Present only when the entry admits a CSR fallback request. */
   readonly csrFallbackHeader?: string;
   readonly nonce?: string;
+  readonly workerFederation?: {
+    readonly renderer: unknown;
+    readonly worker: WorkerFederationPublication;
+  };
+  readonly workerFederationManifestUrl?: string;
+  readonly workerFederationServices?: readonly {
+    readonly remote: string;
+    readonly alias?: string;
+    readonly manifestUrl: string;
+    readonly binding: string;
+    readonly fragments: readonly {
+      readonly expose: string;
+      readonly boundaryId: string;
+      readonly paths: Readonly<Record<string, string>>;
+    }[];
+  }[];
 }
 
 export interface NativeWorkerDispatchOptions<Bindings extends object> {
@@ -27,6 +47,8 @@ export interface NativeWorkerDispatchOptions<Bindings extends object> {
   /** The module worker `env`, forwarded unchanged as the platform binding. */
   readonly bindings: Bindings | undefined;
   readonly executionContext?: NativeExecutionContext;
+  /** Constructed by this compiled renderer entry for this document only. */
+  readonly workerFederation?: WorkerFederationTransport;
 }
 
 function workerManifest<Bindings extends object>(
@@ -89,6 +111,7 @@ export function dispatchNativeWorkerRequest<Bindings extends object>(
       bindings,
       serverConfig: { ...resources.serverConfig, forceCSR },
       nonce: resources.nonce,
+      workerFederation: options.workerFederation,
     },
   });
 }