@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/types/server/dispatch.d.ts

@@ -0,0 +1,11 @@
+import type { NativeDispatchOptions } from './types.js';
+/** Runs before bundle loading, cache lookup, or any renderer dispatch. */
+export declare function rejectNativeRscRequest(request: Request): Response | undefined;
+/** Production Fetch dispatch. React rendering and matching are never imported. */
+export declare function dispatchNativeRequest<Bindings extends object>(request: Request, options: NativeDispatchOptions<Bindings>): Promise<Response>;
+/**
+ * Node host dispatch; the request platform binding is always `node`.
+ * The Node adapter hands over a Proxy for requests with a body, which
+ * `new Request(request)` rejects, so the body request is rebuilt first.
+ */
+export declare function dispatchNativeNodeRequest<Bindings extends object>(request: Request, options: NativeDispatchOptions<Bindings>): Promise<Response>;

package/dist/types/server/index.d.ts

@@ -0,0 +1,4 @@
+export { type NativeClientAssetManifest, RENDERER_ASSET_MANIFEST_FILE, validateNativeClientAssetManifest, } from './assets.js';
+export { dispatchNativeNodeRequest, dispatchNativeRequest, rejectNativeRscRequest, } from './dispatch.js';
+export type * from './types.js';
+export { dispatchNativeWorkerRequest, type NativeWorkerDispatchOptions, type NativeWorkerEntryResources, } from './worker.js';

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

@@ -0,0 +1,64 @@
+import type { DocumentAsset } from '../document.js';
+import type { RendererIdentity } from '../identity.js';
+import type { RequestPlatform, RequestSession } from '../session/index.js';
+/** Native route matching remains with the selected router adapter. */
+export interface NativeServerConfig {
+    readonly ssr?: boolean | 'stream';
+    readonly forceCSR?: boolean;
+    readonly ssrByRouteIds?: readonly string[];
+}
+export interface NativeRequestContext<Bindings extends object = object> {
+    readonly session: RequestSession<Bindings>;
+    readonly assets?: readonly DocumentAsset[];
+    readonly nonce?: string;
+    /** Opaque compiler-owned JSON. The native adapter validates its own ABI. */
+    readonly nativeManifest?: unknown;
+    readonly serverConfig?: NativeServerConfig;
+    readonly entry: Readonly<RendererIdentity>;
+}
+export type NativeRequestHandler<Bindings extends object = object> = (request: Request, context: NativeRequestContext<Bindings>) => Response | Promise<Response>;
+/** Identity is generated with the bundle, never inferred from its filename. */
+export interface NativeServerManifest<Bindings extends object = object> {
+    readonly rendererIdentity: RendererIdentity;
+    readonly nativeRequestHandler: NativeRequestHandler<Bindings>;
+    readonly nativeCSRRequestHandler?: NativeRequestHandler<Bindings>;
+    readonly nativeMatchRouteIds?: (request: Request, context: NativeRequestContext<Bindings>) => readonly string[] | Promise<readonly string[]>;
+}
+export interface CachedNativeDocument {
+    readonly identityKey: string;
+    /** Epoch milliseconds when the document was stored; replays derive Age from it. */
+    readonly storedAt: number;
+    readonly expiresAt: number;
+    readonly status: 200;
+    readonly statusText: string;
+    readonly headers: ReadonlyArray<readonly [string, string]>;
+    readonly bytes: Uint8Array;
+}
+/** All calls receive an identity-namespaced key, including custom stores. */
+export interface NativeDocumentCache {
+    get(key: string): CachedNativeDocument | undefined | Promise<CachedNativeDocument | undefined>;
+    set(key: string, value: CachedNativeDocument): void | Promise<void>;
+}
+/** The subset of a worker execution context the native dispatcher uses. */
+export interface NativeExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+}
+export interface NativeDispatchOptions<Bindings extends object = object> {
+    readonly identity: RendererIdentity;
+    readonly loadManifest: () => NativeServerManifest<Bindings> | Promise<NativeServerManifest<Bindings>>;
+    readonly context: Omit<NativeRequestContext<Bindings>, 'session' | 'entry'> & {
+        readonly bindings: Bindings;
+    };
+    /** The request host binding kind. Defaults to `node`. */
+    readonly platform?: RequestPlatform['kind'];
+    /** Worker hosts retain each owned session until its cleanup completes. */
+    readonly executionContext?: NativeExecutionContext;
+    readonly cache?: NativeDocumentCache;
+    readonly maxCacheBytes?: number;
+    /** Native hydration ABI build, distinct from the source/profile identity. */
+    readonly hydrationBuildId?: string;
+    /** Node hosts confirm complete delivery and return the final wire headers. */
+    readonly confirmDelivery?: (response: Response) => Promise<Headers | undefined>;
+    readonly onCacheError?: (error: unknown) => void;
+    readonly onError?: (error: unknown, request: Request, context: NativeRequestContext<Bindings>) => Response | Promise<Response>;
+}

package/dist/types/server/worker.d.ts

@@ -0,0 +1,25 @@
+import { type DocumentAsset } from '../document.js';
+import { type RendererIdentity } from '../identity.js';
+import type { NativeExecutionContext, NativeServerConfig } from './types.js';
+/** Build-validated per-entry inputs a worker bundle cannot read from disk. */
+export interface NativeWorkerEntryResources {
+    readonly assets: readonly DocumentAsset[];
+    /** Opaque compiler-owned JSON, revalidated by the native request handler. */
+    readonly nativeManifest?: unknown;
+    readonly hydrationBuildId?: string;
+    readonly serverConfig: NativeServerConfig;
+    /** Present only when the entry admits a CSR fallback request. */
+    readonly csrFallbackHeader?: string;
+    readonly nonce?: string;
+}
+export interface NativeWorkerDispatchOptions<Bindings extends object> {
+    readonly identity: RendererIdentity;
+    /** The imported worker bundle: its namespace or default-exported manifest. */
+    readonly bundle: unknown;
+    readonly resources: NativeWorkerEntryResources;
+    /** The module worker `env`, forwarded unchanged as the platform binding. */
+    readonly bindings: Bindings | undefined;
+    readonly executionContext?: NativeExecutionContext;
+}
+/** Worker Fetch dispatch over the same native handler the Node host loads. */
+export declare function dispatchNativeWorkerRequest<Bindings extends object>(request: Request, options: NativeWorkerDispatchOptions<Bindings>): Promise<Response>;

package/dist/types/session/cache.d.ts

@@ -0,0 +1,25 @@
+import { type RendererIdentity } from '../identity.js';
+import type { DocumentCachePolicy, ResponseHeaders, ResponsePolicy } from './types.js';
+/** Compute this before looking up any application-provided request key. */
+export declare function documentCacheKey(identity: RendererIdentity, requestKey: string): string;
+/** Header fields with each Set-Cookie kept as its own entry. */
+export declare function responseHeaders(headers: Headers): [string, string][];
+export declare function policyHeaders(headers: ResponseHeaders): Headers;
+/**
+ * Every Cache-Control directive in order, names lowercased, or `undefined`
+ * when any part is malformed (an unterminated quote, trailing syntax). Quoted
+ * values are consumed whole, so their text is never read as a directive.
+ */
+export declare function parseCacheControl(value: string): {
+    name: string;
+    value: string | undefined;
+}[] | undefined;
+/** The `max-age` and `s-maxage` lifetimes these headers declare. */
+export declare function headerMaxAgeSeconds(headers: Headers): number[];
+export declare function permitsDocumentCache(policy: ResponsePolicy): boolean;
+/**
+ * Narrow a policy's cache to what every header source allows, then write the
+ * matching Cache-Control to `outgoing`. Only a 200 HTML document can be public;
+ * its lifetime is the shortest one any source declares.
+ */
+export declare function restrictDocumentCache(policy: ResponsePolicy, sources: readonly Headers[], outgoing: Headers): DocumentCachePolicy;

package/dist/types/session/index.d.ts

@@ -0,0 +1,4 @@
+export { untilAborted } from '../abort.js';
+export { documentCacheKey, headerMaxAgeSeconds, permitsDocumentCache, policyHeaders, responseHeaders, restrictDocumentCache, } from './cache.js';
+export { createRequestSession } from './request.js';
+export type * from './types.js';

package/dist/types/session/request.d.ts

@@ -0,0 +1,8 @@
+import type { RendererIdentity } from '../identity.js';
+import type { RequestPlatform, RequestSession } from './types.js';
+/** Owns one request and the lifetime of its response body, not a server instance. */
+export declare function createRequestSession<Bindings extends object>(input: {
+    request: Request;
+    identity: RendererIdentity;
+    platform: RequestPlatform<Bindings>;
+}): RequestSession<Bindings>;

package/dist/types/session/types.d.ts

@@ -0,0 +1,48 @@
+import type { RendererIdentity } from '../identity.js';
+export type ResponseHeaders = ReadonlyArray<readonly [string, string]>;
+export type DocumentCachePolicy = {
+    readonly mode: 'no-store' | 'private';
+} | {
+    readonly mode: 'public';
+    readonly maxAgeSeconds: number;
+};
+export interface ResponsePolicy {
+    readonly kind: 'document' | 'terminal';
+    readonly status: number;
+    readonly statusText?: string;
+    readonly headers: ResponseHeaders;
+    readonly cache: DocumentCachePolicy;
+}
+export interface RequestPlatform<Bindings extends object = object> {
+    readonly kind: 'node' | 'worker';
+    readonly bindings: Bindings;
+}
+export type RequestState = 'matching' | 'ready' | 'rendering' | 'committed' | 'completed' | 'failed' | 'aborted';
+export interface RequestCompletion {
+    readonly state: 'completed' | 'failed' | 'aborted';
+    readonly fallback: boolean;
+    readonly error?: unknown;
+    readonly cleanupErrors: readonly unknown[];
+    readonly cacheEligible: boolean;
+}
+export type RequestCleanup = () => void | Promise<void>;
+export interface RequestSession<Bindings extends object = object> {
+    readonly request: Request;
+    readonly identity: Readonly<RendererIdentity>;
+    readonly platform: RequestPlatform<Bindings>;
+    readonly signal: AbortSignal;
+    readonly state: RequestState;
+    readonly responsePolicy: ResponsePolicy | undefined;
+    readonly committedPolicy: ResponsePolicy | undefined;
+    readonly completion: Promise<RequestCompletion>;
+    resolveResponse(policy: ResponsePolicy): void;
+    startRendering(): void;
+    registerCleanup(cleanup: RequestCleanup): () => void;
+    markFallback(): void;
+    respond(body: ReadableStream<Uint8Array> | null): Response;
+    /** The returned response must deliver this session's final owned stream. */
+    ownsResponseBody(response: Response): boolean;
+    /** Notify termination. Await completion separately outside owned cleanup. */
+    fail(error: unknown): void;
+    abort(reason?: unknown): void;
+}

package/package.json

@@ -1,11 +1,166 @@
 {
   "name": "@bleedingdev/modern-js-renderer-core",
-  "version": "0.0.0-bootstrap",
-  "description": "Package-name reservation. Release versions publish through GitHub Trusted Publishing.",
+  "version": "3.9.3-ultramodern.1",
+  "description": "UltraModern native renderer request, data and document contracts.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git"
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
+    "directory": "packages/runtime/renderer-core"
   },
-  "deprecated": "Package-name reservation only. Install a release version published through GitHub Trusted Publishing."
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./identity": {
+      "import": {
+        "types": "./dist/types/identity.d.ts",
+        "default": "./dist/esm/identity.mjs"
+      },
+      "require": {
+        "types": "./dist/types/identity.d.ts",
+        "default": "./dist/cjs/identity.js"
+      }
+    },
+    "./adapter": {
+      "import": {
+        "types": "./dist/types/adapter.d.ts",
+        "default": "./dist/esm/adapter.mjs"
+      },
+      "require": {
+        "types": "./dist/types/adapter.d.ts",
+        "default": "./dist/cjs/adapter.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./federation": {
+      "import": {
+        "types": "./dist/types/federation.d.ts",
+        "default": "./dist/esm/federation.mjs"
+      },
+      "require": {
+        "types": "./dist/types/federation.d.ts",
+        "default": "./dist/cjs/federation.js"
+      }
+    },
+    "./data": {
+      "import": {
+        "types": "./dist/types/data/index.d.ts",
+        "default": "./dist/esm/data/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/data/index.d.ts",
+        "default": "./dist/cjs/data/index.js"
+      }
+    },
+    "./session": {
+      "import": {
+        "types": "./dist/types/session/index.d.ts",
+        "default": "./dist/esm/session/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/session/index.d.ts",
+        "default": "./dist/cjs/session/index.js"
+      }
+    },
+    "./document": {
+      "import": {
+        "types": "./dist/types/document.d.ts",
+        "default": "./dist/esm/document.mjs"
+      },
+      "require": {
+        "types": "./dist/types/document.d.ts",
+        "default": "./dist/cjs/document.js"
+      }
+    },
+    "./router": {
+      "import": {
+        "types": "./dist/types/router.d.ts",
+        "default": "./dist/esm/router.mjs"
+      },
+      "require": {
+        "types": "./dist/types/router.d.ts",
+        "default": "./dist/cjs/router.js"
+      }
+    },
+    "./server": {
+      "import": {
+        "types": "./dist/types/server/index.d.ts",
+        "default": "./dist/esm/server/index.mjs"
+      },
+      "require": {
+        "types": "./dist/types/server/index.d.ts",
+        "default": "./dist/cjs/server/index.js"
+      }
+    },
+    "./entry-client": {
+      "import": {
+        "types": "./dist/types/entry-client.d.ts",
+        "default": "./dist/esm/entry-client.mjs"
+      },
+      "require": {
+        "types": "./dist/types/entry-client.d.ts",
+        "default": "./dist/cjs/entry-client.js"
+      }
+    },
+    "./entry-server": {
+      "import": {
+        "types": "./dist/types/entry-server.d.ts",
+        "default": "./dist/esm/entry-server.mjs"
+      },
+      "require": {
+        "types": "./dist/types/entry-server.d.ts",
+        "default": "./dist/cjs/entry-server.js"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=26.10.0"
+  },
+  "dependencies": {
+    "seroval": "1.6.8"
+  },
+  "peerDependencies": {
+    "@rsbuild/core": "2.2.11"
+  },
+  "peerDependenciesMeta": {
+    "@rsbuild/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.3-ultramodern.1",
+    "@rsbuild/core": "2.2.11",
+    "@rslib/core": "1.0.3",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/node": "^26.6.3"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "test": "rstest"
+  },
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/renderer-core"
+  }
 }

package/src/abort.ts

@@ -0,0 +1,40 @@
+/**
+ * Settle with the work, or reject once the signal aborts: work that ignores
+ * cancellation must not keep its caller alive. A late Response body is
+ * cancelled and a late failure observed.
+ */
+export function untilAborted<T>(
+  handled: T | Promise<T>,
+  signal: AbortSignal,
+): Promise<T> {
+  const settled = Promise.resolve(handled);
+  const discard = () =>
+    void settled.then(
+      value => {
+        if (value instanceof Response)
+          void value.body?.cancel().catch(() => {});
+      },
+      () => {},
+    );
+  if (signal.aborted) {
+    discard();
+    return Promise.reject(signal.reason);
+  }
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      discard();
+      reject(signal.reason);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    settled.then(
+      value => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(value);
+      },
+      error => {
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      },
+    );
+  });
+}

package/src/adapter.ts

@@ -0,0 +1,255 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Renderer, RendererIdentity } from './identity';
+
+/**
+ * Renderer adapters are build-side descriptors. A renderer package exports one
+ * from its `./plugin` entry; UltraModern loads only the selected adapter and
+ * drives native entries, compilation, artifacts, deployment and scaffolding
+ * from its data. Nothing here is imported by application runtime code.
+ */
+
+export interface RendererBuildProfile<TRenderer extends Renderer = Renderer> {
+  renderer: TRenderer;
+  status: 'stable' | 'preview';
+  protocolVersion: 1;
+  minimumNode: '26.10.0';
+  hmr: {
+    editedBoundary: 'may-reset';
+    unaffectedComponents: 'preserved';
+    document: 'preserved';
+    roots: 'single';
+    cleanup: 'exactly-once';
+  };
+  compiler: { name: string; version: string };
+  hydration: { name: string; version: string };
+  router: {
+    name: string;
+    version: string;
+    coreName: string;
+    coreVersion: string;
+  };
+  sourceExtensions: readonly string[];
+  jsxImportSource: string;
+  dependencies: Readonly<Record<string, string>>;
+  capabilities: {
+    worker: boolean;
+    /**
+     * `true`: Module Federation with SSR. React federates through the React
+     * MF plugin; native renderers server-render same-renderer federated
+     * components from a native module-federation.config.
+     * `'client'`: native same-renderer federated components rendered on the
+     * client only.
+     */
+    moduleFederation: boolean | 'client';
+    rsc: boolean;
+    ssg: boolean;
+    i18n: boolean;
+    svgComponent: boolean;
+  };
+}
+
+export interface NativeRendererCompilerOptions {
+  /** The selected native infrastructure owns these source-build identities. */
+  rendererIdentities(): Readonly<Record<string, RendererIdentity>>;
+  /** Rsbuild environment that renders server documents inside a web worker. */
+  readonly workerEnvironmentName: string;
+}
+
+export interface NativeCompilerArtifactContext {
+  /** Hash from the completed client compiler, when validating emitted output. */
+  readonly compilationHash?: string;
+  /** Hydration identity retained with a development snapshot. */
+  readonly hydrationBuildId?: string;
+  readonly development?: boolean;
+}
+
+export interface ValidatedNativeCompilerArtifact {
+  readonly nativeManifest: unknown;
+  /** Optional compiler-owned hydration and document cache identity. */
+  readonly hydrationBuildId?: string;
+}
+
+/** The selected compiler owns its artifact ABI; lifecycle consumers keep it opaque. */
+export interface NativeCompilerArtifacts {
+  clientManifestFile(entryName: string): string;
+  validateClientManifest(
+    value: unknown,
+    identity: RendererIdentity,
+    context: NativeCompilerArtifactContext,
+  ): Promise<ValidatedNativeCompilerArtifact>;
+  isMutableDevelopmentAsset(
+    filename: string,
+    entryNames: readonly string[],
+  ): boolean;
+}
+
+/** Public modules the generated native entries and the host import. */
+export interface NativeRendererRuntime {
+  /** The renderer's own reactive runtime package, e.g. `solid-js`. */
+  readonly package: string;
+  /** The renderer package that owns this adapter and its runtime modules. */
+  readonly bootstrap: string;
+  readonly entryClient: string;
+  readonly entryServer: string;
+  readonly router: string;
+  readonly i18n?: string;
+  /**
+   * Exports the renderer's `compilerArtifacts`, which the production server
+   * loads to validate compiler module manifests; also proves the installed
+   * owner.
+   */
+  readonly manifest: string;
+}
+
+export interface NativeRendererFederation {
+  /** Runtime singletons a host and every remote share (`pkg/` for subpaths). */
+  readonly shared: readonly string[];
+  /** Required providers, with the native import each compilation owns. */
+  readonly sharedByEnvironment?: Readonly<
+    Record<'client' | 'server', Readonly<Record<string, string>>>
+  >;
+  /** Browser container format, matching the renderer's client chunks. */
+  readonly library: 'module';
+  /** Whether federated components also render on the server. */
+  readonly ssr: boolean;
+}
+
+export interface RendererWorkerSupport {
+  /** Worker documents come from the renderer's native server handler. */
+  readonly nativeDocuments: boolean;
+  readonly rsc: boolean;
+}
+
+export interface NativeEntryClientStub {
+  /** Ambient declarations the generated client entry needs. */
+  readonly declarations: string;
+  /** Extra `startNativeClient` fields, as source expressions. */
+  readonly fields: Readonly<Record<string, string>>;
+}
+
+export interface RendererAppSourceOptions {
+  appId: string;
+  title: string;
+  entryName: string;
+  sourceExtension: '.tsx' | '.tsrx';
+  jsxImportSource: string;
+  capabilities: { ssr: boolean; federation: boolean };
+}
+
+export interface RendererAppSources {
+  sourceExtension: '.tsx' | '.tsrx';
+  jsxImportSource: string;
+  artifacts: { path: string; content: string }[];
+}
+
+export interface RendererCreatePackages {
+  /** Framework packages the generated application depends on directly. */
+  frameworkDependencies: readonly string[];
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  typecheckCommand?: string;
+  tsconfig?: Record<string, unknown>;
+}
+
+export interface RendererCreateSupport {
+  /** Deployment templates the adapter admits in generated workspaces. */
+  readonly templates?: {
+    readonly federation: boolean;
+    readonly workers: boolean;
+  };
+  dependencies(
+    profile: RendererBuildProfile,
+    context: { readonly typescriptVersion: string },
+  ): RendererCreatePackages;
+  generateAppSources(options: RendererAppSourceOptions): RendererAppSources;
+}
+
+interface RendererAdapterDescriptor<TRenderer extends Renderer> {
+  readonly name: TRenderer;
+  readonly profile: RendererBuildProfile<TRenderer>;
+  readonly routerFrameworks: readonly string[];
+  readonly worker: RendererWorkerSupport;
+  readonly create?: RendererCreateSupport;
+}
+
+export interface NativeRendererAdapter<TRenderer extends Renderer = Renderer>
+  extends RendererAdapterDescriptor<TRenderer> {
+  readonly kind: 'native';
+  readonly runtime: NativeRendererRuntime;
+  readonly federation?: NativeRendererFederation;
+  readonly entryClient?: NativeEntryClientStub;
+  /**
+   * Who links the stylesheets of lazy components in a server document.
+   * `'renderer'`: the server render links each one beside the markup it
+   * renders. `'document'`: the render cannot report which lazy modules it
+   * rendered, so the document links every lazy stylesheet up front.
+   */
+  readonly lazyStyles: 'renderer' | 'document';
+  /** Path of a CommonJS module exporting `(parts) => source` for `?component` SVGs. */
+  svgComponentTemplate?(): string;
+  /** The renderer compiler; UltraModern applies SVG and ownership policy. */
+  compiler(options: NativeRendererCompilerOptions): RsbuildPlugin;
+  readonly artifacts: NativeCompilerArtifacts;
+  assertSupportedSource?(source: string | false | undefined): Promise<void>;
+}
+
+/** A renderer composed from an existing plugin stack (React only). */
+export interface ComposedRendererAdapter<
+  TRenderer extends Renderer = Renderer,
+  TPlugin = unknown,
+  TPolicy = unknown,
+> extends RendererAdapterDescriptor<TRenderer> {
+  readonly kind: 'composed';
+  /** Public modules whose installed owners pin the profile versions. */
+  readonly frameworkModules: readonly {
+    readonly specifier: string;
+    readonly request: string;
+  }[];
+  compose(consumerPlugins: readonly TPlugin[], policy?: TPolicy): TPlugin;
+}
+
+export type RendererAdapter<TRenderer extends Renderer = Renderer> =
+  | NativeRendererAdapter<TRenderer>
+  | ComposedRendererAdapter<TRenderer>;
+
+const adapterError = (name: unknown, detail: string) =>
+  new Error(`Invalid renderer adapter ${String(name)}: ${detail}`);
+
+/** Validate an adapter's internal consistency and freeze its descriptor data. */
+export function defineRendererAdapter<T extends RendererAdapter>(
+  adapter: T,
+): T {
+  const { name, profile } = adapter;
+  if (profile.renderer !== name)
+    throw adapterError(name, `profile names ${profile.renderer}`);
+  if (!adapter.routerFrameworks.length)
+    throw adapterError(name, 'it declares no router framework');
+  if (adapter.worker.rsc !== profile.capabilities.rsc)
+    throw adapterError(name, 'worker RSC support contradicts its profile');
+  if (adapter.kind === 'native') {
+    if (adapter.worker.nativeDocuments !== true)
+      throw adapterError(name, 'native documents come from its server handler');
+    const federation = adapter.federation;
+    const capability = profile.capabilities.moduleFederation;
+    if (
+      (federation === undefined) !== (capability === false) ||
+      (federation !== undefined && federation.ssr !== (capability === true))
+    )
+      throw adapterError(name, 'federation support contradicts its profile');
+  }
+  return Object.freeze(adapter);
+}
+
+/** Third-party runtime packages a generated native application installs. */
+export function nativeRendererDependencies(
+  profile: RendererBuildProfile,
+): Record<string, string> {
+  return {
+    ...Object.fromEntries(
+      Object.entries(profile.dependencies).filter(
+        ([name]) => !name.startsWith('@modern-js/'),
+      ),
+    ),
+    [profile.router.coreName]: profile.router.coreVersion,
+  };
+}