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

package/dist/types/data/types.d.ts

@@ -0,0 +1,104 @@
+import type { RendererIdentity } from '../identity.js';
+export declare const DATA_PROTOCOL_VERSION: 1;
+export declare const DATA_CONTENT_TYPE = "application/vnd.ultramodern.data+json";
+export declare const DATA_STREAM_CONTENT_TYPE = "application/vnd.ultramodern.data-stream+json";
+export declare const LOADER_ID_PARAM = "__loader";
+export declare const DIRECT_PARAM = "__ssrDirect";
+export type DataOperation = 'loader' | 'action';
+export type DataHeaders = [string, string][];
+export interface DataResponseMetadata {
+    status: number;
+    statusText: string;
+    headers: DataHeaders;
+    cachePolicy: 'no-store' | 'private' | 'public';
+}
+export interface PublicDataError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+export type DataOutcome = {
+    kind: 'success';
+    value: unknown;
+    response: DataResponseMetadata;
+} | {
+    kind: 'redirect';
+    location: string;
+    response: DataResponseMetadata;
+} | {
+    kind: 'not-found';
+    value: unknown;
+    thrown: boolean;
+    response: DataResponseMetadata;
+} | {
+    kind: 'error';
+    error: PublicDataError;
+    data?: unknown;
+    thrown: boolean;
+    response: DataResponseMetadata;
+} | {
+    kind: 'deferred';
+    critical: Record<string, unknown>;
+    deferred: Record<string, Promise<unknown>>;
+    response: DataResponseMetadata;
+};
+export interface DataHandlerInput<Context = unknown> {
+    request: Request;
+    routeId: string;
+    params: Readonly<Record<string, string>>;
+    context: Context;
+}
+export type DataHandler<Context = unknown> = (input: DataHandlerInput<Context>) => unknown | Promise<unknown>;
+/** The native router supplies an authorized match, never a shared matcher. */
+export interface SelectedDataRoute<Context = unknown> {
+    routeId: string;
+    params: Readonly<Record<string, string>>;
+    handler: DataHandler<Context>;
+}
+export interface DataWireEnvelope {
+    version: typeof DATA_PROTOCOL_VERSION;
+    identity: RendererIdentity;
+    routeId: string;
+    operation: DataOperation;
+    outcome: PublicDataOutcome;
+    deferredKeys?: string[];
+}
+/** Header values and request-owned context never enter a public payload. */
+export type PublicDataOutcome = {
+    kind: 'success';
+    value: unknown;
+    status: number;
+} | {
+    kind: 'redirect';
+    location: string;
+    status: number;
+} | {
+    kind: 'not-found';
+    value: unknown;
+    thrown: boolean;
+    status: number;
+} | {
+    kind: 'error';
+    error: PublicDataError;
+    data?: unknown;
+    thrown: boolean;
+    status: number;
+};
+/** A deferred body is successful only when its terminal framing completes. */
+export type DecodedDataOutcome = PublicDataOutcome & {
+    completion?: Promise<void>;
+};
+export type DataStreamFrame = {
+    type: 'initial';
+    envelope: DataWireEnvelope;
+} | {
+    type: 'resolve';
+    key: string;
+    value: unknown;
+} | {
+    type: 'reject';
+    key: string;
+    error: PublicDataError;
+} | {
+    type: 'complete';
+};

package/dist/types/document.d.ts

@@ -0,0 +1,76 @@
+import { type RendererIdentity } from './identity.js';
+export interface DocumentAsset {
+    readonly kind: 'stylesheet' | 'modulepreload' | 'script';
+    readonly href: string;
+    readonly integrity?: string;
+    readonly crossOrigin?: 'anonymous' | 'use-credentials';
+    readonly scriptType?: 'module' | 'classic';
+}
+/** Preserve the native adapter's order. Equal asset claims collapse; conflicts fail. */
+export declare function collectDocumentAssets(assets: readonly DocumentAsset[]): readonly DocumentAsset[];
+/** Serialize asset metadata only. The native renderer decides its document position. */
+export declare function serializeDocumentAsset(asset: DocumentAsset, nonce?: string, options?: {
+    readonly async?: boolean;
+    readonly defer?: boolean;
+}): string;
+/**
+ * Frame JSON text as an inert `<script type="application/json">` element.
+ * This is the one place inline document data is escaped for HTML.
+ */
+export declare function serializeInlineData(input: {
+    readonly id: string;
+    /** JSON text, such as `serializePublicData` output or `JSON.stringify`. */
+    readonly payload: string;
+    readonly nonce?: string;
+}): string;
+/** Element id of the renderer bootstrap every native client reads first. */
+export declare const RENDERER_BOOTSTRAP_ID = "__ULTRAMODERN_RENDERER__";
+/** What the server tells the client about the document before it starts. */
+export interface DocumentBootstrap {
+    readonly identity: Readonly<RendererIdentity>;
+    /** The renderer's hydration/render id for this response. */
+    readonly documentId: string;
+    readonly hydrating: boolean;
+}
+/** Public JSON a client module reads from the document before it starts. */
+export interface DocumentInlineData {
+    readonly id: string;
+    /** JSON text; `serializeInlineData` escapes it for HTML. */
+    readonly payload: string;
+}
+export interface DocumentNonce {
+    readonly script?: string;
+    readonly style?: string;
+}
+export interface DocumentOptions {
+    readonly rootId?: string;
+    readonly lang?: string;
+    readonly nonce?: DocumentNonce;
+    readonly assets?: readonly DocumentAsset[];
+    /** Placed right after the renderer bootstrap, before entry scripts. */
+    readonly inlineData?: readonly DocumentInlineData[];
+}
+/** HTML fragments a native adapter places in its own document shell. */
+export interface DocumentParts {
+    /** Escaped attribute values. */
+    readonly rootId: string;
+    readonly lang: string;
+    /** Stylesheets and module preloads. */
+    readonly headAssets: string;
+    /** The renderer bootstrap followed by the inline data elements. */
+    readonly bootstrap: string;
+    /** Entry scripts, scheduled so hydration starts before the stream ends. */
+    readonly entryScripts: string;
+}
+/**
+ * Prepare the renderer-neutral parts of a native HTML document: assets, the
+ * renderer bootstrap and inline data. `extra` adds renderer-specific bootstrap
+ * fields, which the client reads with `readDocumentBootstrap`.
+ */
+export declare function prepareDocument(bootstrap: DocumentBootstrap & Readonly<Record<string, unknown>>, options?: DocumentOptions): DocumentParts;
+/**
+ * Read the server's bootstrap before creating a native router or owner. The
+ * identity must equal the client's build identity. Renderer-specific fields
+ * must be named in `extraFields` and are returned for the adapter to check.
+ */
+export declare function readDocumentBootstrap(document: Pick<Document, 'querySelectorAll'>, expectedIdentity: RendererIdentity, extraFields?: readonly string[]): DocumentBootstrap & Readonly<Record<string, unknown>>;

package/dist/types/entry-client.d.ts

@@ -0,0 +1,53 @@
+import { type DocumentBootstrap } from './document.js';
+import type { NativeFederationBinding } from './federation.js';
+import type { RendererIdentity } from './identity.js';
+import { type NativeEntryI18n, type NativeI18nInstance, type NativeI18nView } from './localization.js';
+import { type NativeApplicationModule, type NativeRoutedApplication, type NativeRouterOptions } from './router.js';
+export type * from './localization.js';
+export type { NativeApplicationModule, NativeRoutedApplication, NativeRouterOptions, } from './router.js';
+/** What a generated client entry passes to its renderer. */
+export interface NativeClientEntryOptions<Instance extends NativeI18nInstance = NativeI18nInstance, LocalisedUrls = unknown> {
+    readonly identity: RendererIdentity;
+    readonly federation?: NativeFederationBinding;
+    /** The generated application module, imported after startup begins. */
+    readonly load: () => Promise<NativeApplicationModule>;
+    readonly i18n?: NativeEntryI18n<Instance, LocalisedUrls>;
+    /** The entry module's bundler HMR object, `import.meta.webpackHot`. */
+    readonly hot?: unknown;
+    /** The mount element id; must match the server entry's `rootId`. */
+    readonly rootId?: string;
+}
+/** The application view a renderer mounts or hydrates. */
+export type NativeClientView<Router, Instance, LocalisedUrls> = {
+    readonly i18n?: NativeI18nView<Instance, LocalisedUrls>;
+} & ({
+    readonly kind: 'component';
+    readonly component: unknown;
+} | {
+    readonly kind: 'router';
+    readonly router: Router;
+});
+export interface NativeClientStart<Bootstrap extends DocumentBootstrap, Router, Instance, LocalisedUrls> {
+    readonly root: HTMLElement;
+    readonly identity: Readonly<RendererIdentity>;
+    readonly bootstrap: Bootstrap | undefined;
+    /** Aborts when the entry is disposed during startup. */
+    readonly signal: AbortSignal;
+    /** Import the application and prepare its router for this document. */
+    load(): Promise<NativeClientView<Router, Instance, LocalisedUrls>>;
+}
+/** The renderer's own document, router and root lifecycle. */
+export interface NativeClientAdapter<Bootstrap extends DocumentBootstrap, Router extends object, Instance extends NativeI18nInstance, LocalisedUrls> {
+    readBootstrap(document: Document, identity: Readonly<RendererIdentity>): Bootstrap;
+    createRouter(application: NativeRoutedApplication, options: NativeRouterOptions): Router;
+    /** Load a fresh router, or adopt the server's matches when hydrating. */
+    prepareRouter(router: Router, hydrating: boolean, signal: AbortSignal): Promise<void>;
+    /** Mount or hydrate the root; resolves its disposal. */
+    start(input: NativeClientStart<Bootstrap, Router, Instance, LocalisedUrls>): Promise<() => void>;
+}
+/**
+ * Start a generated browser entry: find the mount element, read the server
+ * bootstrap, own HMR disposal and startup cancellation, and surface startup
+ * failures. The renderer adapter owns its router and root.
+ */
+export declare function startNativeClientEntry<Bootstrap extends DocumentBootstrap, Router extends object, Instance extends NativeI18nInstance, LocalisedUrls>(options: NativeClientEntryOptions<Instance, LocalisedUrls>, adapter: NativeClientAdapter<Bootstrap, Router, Instance, LocalisedUrls>): void;

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

@@ -0,0 +1,63 @@
+import { type DataOutcome } from './data/index.js';
+import type { DocumentAsset, DocumentInlineData } from './document.js';
+import type { NativeFederationBinding } from './federation.js';
+import { type RendererIdentity } from './identity.js';
+import { type NativeEntryI18n, type NativeI18nInstance, type NativeI18nView } from './localization.js';
+import { type NativeApplicationModule, type NativeRoutedApplication, type NativeRouteMatch, type NativeRouteMatcher, type NativeRouterOptions } from './router.js';
+import type { NativeRequestContext, NativeServerManifest } from './server/index.js';
+import type { RequestSession } from './session/index.js';
+export type * from './localization.js';
+export type { NativeApplicationModule, NativeRoutedApplication, NativeRouterOptions, } from './router.js';
+/** What a generated server entry passes to its renderer. */
+export interface NativeServerEntryOptions<Instance extends NativeI18nInstance = NativeI18nInstance, LocalisedUrls = unknown> {
+    readonly identity: RendererIdentity;
+    readonly federation?: NativeFederationBinding;
+    /** The generated application module, imported per request. */
+    readonly app: () => Promise<NativeApplicationModule>;
+    readonly i18n?: NativeEntryI18n<Instance, LocalisedUrls>;
+    /** The document mount element id; the client entry must use the same. */
+    readonly rootId?: string;
+}
+/** The renderer-neutral part of one response document. */
+export interface NativeServerDocument {
+    readonly documentId: string;
+    readonly rootId: string;
+    readonly nonce?: string;
+    readonly assets?: readonly DocumentAsset[];
+    readonly lang?: string;
+    readonly inlineData?: readonly DocumentInlineData[];
+}
+export interface NativeServerRoutesInput<Router, Document, Instance, LocalisedUrls> {
+    /** The request bound to the session signal; data loaders observe it. */
+    readonly request: Request;
+    readonly context: NativeRequestContext;
+    readonly router: Router;
+    /** Blocking data outcomes, recorded while the router loads. */
+    readonly outcomes: readonly DataOutcome[];
+    readonly document: Document;
+    /** Request-private values the router must never serialize. */
+    readonly forbiddenValues: readonly object[];
+    readonly i18n?: NativeI18nView<Instance, LocalisedUrls>;
+}
+/** The renderer's own request scope, manifest, router and document. */
+export interface NativeServerAdapter<Router extends NativeRouteMatcher<unknown, NativeRouteMatch>, Document extends NativeServerDocument, Instance extends NativeI18nInstance, LocalisedUrls> {
+    /** Validate the compiler manifest and complete the document. */
+    document(base: NativeServerDocument, nativeManifest: unknown, identity: Readonly<RendererIdentity>): Document;
+    /** Run one request inside the renderer's native request scope. */
+    run<Result>(session: RequestSession, callback: () => Promise<Result>): Promise<Result>;
+    /** Commit a terminal data or redirect response. */
+    respond(session: RequestSession, response: Response): Response;
+    createRouter(application: NativeRoutedApplication, options: NativeRouterOptions): Router;
+    renderCSR(context: NativeRequestContext, document: Document): Response | Promise<Response>;
+    renderComponent(context: NativeRequestContext, component: unknown, document: Document, i18n?: NativeI18nView<Instance, LocalisedUrls>): Promise<Response>;
+    /** Load the router, resolve its HTTP outcome and render the document. */
+    renderRoutes(input: NativeServerRoutesInput<Router, Document, Instance, LocalisedUrls>): Promise<Response>;
+}
+export type NativeServerEntry = Required<NativeServerManifest>;
+/**
+ * Create the native transport handlers of a generated server entry: identity
+ * and session ownership, CSR and SSR documents, localized redirects, route
+ * matching and the data endpoint. The renderer adapter owns its request
+ * scope, router and document.
+ */
+export declare function createNativeServerEntry<Router extends NativeRouteMatcher<unknown, NativeRouteMatch>, Document extends NativeServerDocument, Instance extends NativeI18nInstance, LocalisedUrls>(options: NativeServerEntryOptions<Instance, LocalisedUrls>, adapter: NativeServerAdapter<Router, Document, Instance, LocalisedUrls>): NativeServerEntry;

package/dist/types/federation.d.ts

@@ -0,0 +1,56 @@
+/** 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>;
+    readonly remoteHandler?: {
+        readonly idToRemoteMap?: Record<string, {
+            name: string;
+            expose: string;
+        }>;
+    };
+    readonly moduleCache?: Map<string, {
+        readonly remoteInfo: unknown;
+    }>;
+    readonly snapshotHandler?: {
+        getGlobalRemoteInfo(info: unknown): {
+            remoteSnapshot?: RemoteSnapshot;
+        };
+    };
+}
+interface RemoteSnapshot {
+    readonly publicPath?: unknown;
+    readonly remoteEntry?: unknown;
+    readonly modules?: readonly {
+        readonly modulePath?: unknown;
+        readonly assets?: {
+            readonly js?: {
+                readonly sync?: readonly string[];
+            };
+            readonly css?: {
+                readonly sync?: readonly string[];
+                readonly async?: readonly string[];
+            };
+        };
+    }[];
+}
+/** Generated entries retain their own compiler's host, including on the server. */
+export interface NativeFederationBinding {
+    readonly instance: () => FederationInstance;
+    /**
+     * Server bindings: the client module, relative to the client asset base,
+     * that loads a server-rendered remote through this host before hydration.
+     */
+    readonly hydrationModule?: string;
+}
+export interface FederatedAssets {
+    readonly js: readonly string[];
+    readonly css: readonly string[];
+}
+/** Capture the host before importing application modules or remote containers. */
+export declare function getFederationHost(binding: NativeFederationBinding | undefined): FederationInstance | undefined;
+/** Load through the selected application's runtime, never another app's host. */
+export declare function loadFederatedModule<T>(instance: FederationInstance | undefined, id: string): Promise<T>;
+/** Browser assets from the native snapshot that admitted and loaded this remote. */
+export declare function remoteBrowserAssets(instance: FederationInstance, id: string): FederatedAssets | undefined;
+export {};

package/dist/types/identity.d.ts

@@ -0,0 +1,27 @@
+export type Renderer = string;
+/** Immutable identity for one application entry and its hydration bytes. */
+export interface RendererIdentity {
+    renderer: Renderer;
+    appId: string;
+    entryName: string;
+    protocolVersion: 1;
+    buildId: string;
+}
+export declare function resolveRenderer(value?: unknown): Renderer;
+export declare function identityCacheKey(identity: RendererIdentity): string;
+export declare function assertRendererIdentity(actual: RendererIdentity, expected: RendererIdentity): void;
+/**
+ * Read an identity from untrusted JSON (a document bootstrap or a build
+ * manifest). It must be a plain record with exactly the identity fields and
+ * equal the identity this application was built with.
+ */
+export declare function readRendererIdentity(value: unknown, expected: RendererIdentity): Readonly<RendererIdentity>;
+/** The emitted client compiler manifest for one native renderer entry. */
+export declare function nativeModuleManifestFilename(renderer: Renderer, entryName: string): string;
+/** Response header naming the built entry identity that rendered a document. */
+export declare const RENDERER_IDENTITY_HEADER = "x-ultramodern-renderer-identity";
+/**
+ * Serialize an entry identity as an ASCII-only header value (JSON with
+ * non-ASCII code units escaped), so every host emits the same bytes.
+ */
+export declare function serializeRendererIdentityHeader(identity: RendererIdentity): string;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { assertRendererIdentity, identityCacheKey, type Renderer, type RendererIdentity, resolveRenderer, } from './identity.js';

package/dist/types/localization.d.ts

@@ -0,0 +1,58 @@
+import type { DocumentInlineData } from './document.js';
+import type { NativeLocationRewrite } from './router.js';
+/** `{ [namespace]: { [key]: value } }` for one language. */
+export type NativeI18nResources = Record<string, Record<string, unknown>>;
+export type NativeRequestLanguage = {
+    readonly kind: 'language';
+    readonly language: string;
+    /** Request headers the language was detected from, for `Vary`. */
+    readonly vary?: readonly string[];
+} | {
+    readonly kind: 'redirect';
+    readonly language: string;
+    readonly location: string;
+};
+/** A per-request or per-document translation instance, such as i18next's. */
+export interface NativeI18nInstance {
+    readonly language: string;
+}
+/**
+ * Localized routing a native entry composes. `createNativeI18n()` from
+ * `@modern-js/i18n-runtime-extensions/native` implements it with i18next.
+ */
+export interface NativeEntryI18n<Instance extends NativeI18nInstance = NativeI18nInstance, LocalisedUrls = unknown> {
+    readonly languages: readonly string[];
+    readonly localisedUrls?: LocalisedUrls;
+    /** The language of a request URL, or the redirect to its localized URL. */
+    resolveRequest(request: Request): NativeRequestLanguage;
+    redirect(location: string): Response;
+    /** A new, fully isolated instance for one request or one browser document. */
+    create(language: string, resources?: NativeI18nResources): Promise<Instance>;
+    /** The router rewrite: matching stays on canonical paths. */
+    rewrite(getLanguage: () => string): NativeLocationRewrite;
+    /** The document handoff of a language and, with an instance, its bundles. */
+    handoff(language: string, instance?: Instance): DocumentInlineData;
+    /** The server's language and bundles, read before the browser router starts. */
+    clientHandoff(): {
+        language: string;
+        resources?: NativeI18nResources;
+    };
+    /**
+     * History navigation to another language prefix switches the instance.
+     * Returns the cleanup that detaches it when the client entry is disposed.
+     */
+    syncWithRouter(router: object, instance: Instance): () => void;
+    /**
+     * Keep the document language and persisted language in step with the
+     * instance, for routed and component-only entries alike. Returns the
+     * cleanup that detaches it when the client entry is disposed.
+     */
+    persist?(instance: Instance): () => void;
+}
+/** What a renderer needs to provide localization to its application view. */
+export interface NativeI18nView<Instance, LocalisedUrls> {
+    readonly instance: Instance;
+    readonly languages: readonly string[];
+    readonly localisedUrls?: LocalisedUrls;
+}
+export declare function nativeI18nView<Instance extends NativeI18nInstance, Urls>(i18n: NativeEntryI18n<Instance, Urls>, instance: Instance): NativeI18nView<Instance, Urls>;

package/dist/types/router.d.ts

@@ -0,0 +1,201 @@
+import { untilAborted } from './abort.js';
+import type { DataHandler, DataHandlerInput, DataOperation, DataOutcome, DecodedDataOutcome, FileSystemRouteIR, PublicDataOutcome, SelectedDataRoute } from './data/index.js';
+import type { RendererIdentity } from './identity.js';
+import type { RequestSession } from './session/index.js';
+export interface FileSystemDataModule<Context = unknown> {
+    loader?: DataHandler<Context>;
+    action?: DataHandler<Context>;
+}
+export type RouteOutcome = DataOutcome | DecodedDataOutcome;
+export interface FileSystemRouteOptions<Context = unknown, Router = unknown> {
+    /** The request owned by this router; carries RequestSession.signal. */
+    request?: Request;
+    /** Retires every route load, as a disposed browser entry does. */
+    signal?: AbortSignal;
+    /** The exact request owner validates native public snapshots (Solid). */
+    session?: RequestSession;
+    /** Private data-handler input; never part of native route context. */
+    context?: Context;
+    /** Resolve the native router once its route tree is installed (Octane). */
+    getRouter?: () => Router;
+    loadRoute?: (route: FileSystemRouteIR, input: DataHandlerInput<Context>) => Promise<RouteOutcome>;
+    /** The server resolves HTTP policy from blocking outcomes before rendering. */
+    onOutcome?: (routeId: string, outcome: RouteOutcome) => void;
+}
+/** A route boundary receives only the public error projection and its status. */
+export declare class RouteDataError extends Error {
+    readonly status: number;
+    readonly data: unknown;
+    readonly routeId: string;
+    constructor(routeId: string, outcome: Extract<DataOutcome | PublicDataOutcome, {
+        kind: 'error';
+    }>);
+}
+/** The renderer binding's own redirect and not-found constructors. */
+export interface NativeRouteSignals {
+    redirect(options: {
+        href: string;
+        statusCode: number;
+        headers?: HeadersInit;
+    }): unknown;
+    notFound(options: {
+        data: unknown;
+    }): unknown;
+}
+/**
+ * Turn a data outcome into loader data, or throw it into the native redirect,
+ * not-found or error boundary. `project` maps every public value first.
+ */
+export declare function resolveRouteData(native: NativeRouteSignals, routeId: string, outcome: DataOutcome | PublicDataOutcome, project?: (value: unknown) => unknown): unknown;
+/** Validate the filesystem shape: one application root and unique ids. */
+export declare function splitFileSystemRoutes(routes: readonly FileSystemRouteIR[]): {
+    root: FileSystemRouteIR | undefined;
+    children: readonly FileSystemRouteIR[];
+};
+/** Native path (or pathless id) options for one filesystem route. */
+export declare function nativeRoutePath(route: FileSystemRouteIR): {
+    path: string;
+} | {
+    id: string;
+};
+export interface NativeLoaderMatch {
+    params: Record<string, string>;
+    location: {
+        publicHref: string;
+    };
+    abortController: AbortController;
+}
+/**
+ * Invoke a route's data handler for one native loader generation. The request
+ * carries the public URL (basepath included) and aborts with either owner.
+ */
+export declare function loadFileSystemRoute<Context>(route: FileSystemRouteIR, loadRoute: NonNullable<FileSystemRouteOptions<Context>['loadRoute']>, options: FileSystemRouteOptions<Context>, { params, location, abortController }: NativeLoaderMatch): Promise<{
+    outcome: RouteOutcome;
+    request: Request;
+    signal: AbortSignal;
+}>;
+/** Renderer adapters race their authored router hooks with the same rule. */
+export { untilAborted };
+/** Location input accepted by a native router's parseLocation. */
+export interface NativeHistoryLocation {
+    href: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    state: {
+        __TSR_index: number;
+    };
+}
+export interface NativeRouteMatch {
+    routeId: string;
+    params: Readonly<Record<string, string>>;
+}
+export interface NativeRouteMatcher<Location, Match> {
+    parseLocation(location: NativeHistoryLocation): Location;
+    matchRoutes(location: Location): Match[];
+    routesById: Readonly<Record<string, {
+        options: {
+            staticData?: unknown;
+        };
+    } | undefined>>;
+}
+/**
+ * Match a public request URL through the router's own location parsing, so the
+ * basepath (a router rewrite) is removed exactly as navigation removes it.
+ */
+export declare function matchApplicationRoutes<Location, Match>(router: NativeRouteMatcher<Location, Match>, url: URL): Match[];
+/** The filesystem route ids a public request URL matches, outermost first. */
+export declare function matchApplicationRouteIds<Location, Match extends {
+    routeId: string;
+}>(router: NativeRouteMatcher<Location, Match>, url: URL): string[];
+/** A requested data id must belong to the native router's match for this URL. */
+export declare function selectApplicationDataRoute<Context, Location, Match extends NativeRouteMatch>(router: NativeRouteMatcher<Location, Match>, request: Request, requestedRouteId: string, operation: DataOperation, handlers: Readonly<Record<string, FileSystemDataModule<Context>>>): SelectedDataRoute<Context> | undefined;
+/** One route's source module namespaces, as the generated application imports them. */
+export interface NativeRouteSources {
+    readonly component?: {
+        readonly default?: unknown;
+    };
+    readonly pendingComponent?: {
+        readonly default?: unknown;
+    };
+    readonly errorComponent?: {
+        readonly default?: unknown;
+    };
+    readonly notFoundComponent?: {
+        readonly default?: unknown;
+    };
+    readonly head?: {
+        readonly head?: unknown;
+        readonly default?: unknown;
+    };
+    readonly search?: {
+        readonly validateSearch?: unknown;
+        readonly default?: unknown;
+    };
+}
+/** The generated module of a file-system routed entry: route sources and data. */
+export interface NativeRoutedApplication {
+    /** The analyzed public prefix the router strips before matching. */
+    readonly basePath: string;
+    readonly routeIR: readonly FileSystemRouteIR[];
+    readonly routeModules: Readonly<Record<string, NativeRouteSources>>;
+    readonly dataModules: Readonly<Record<string, FileSystemDataModule>>;
+    /** Client graph only: routes whose loader runs on the server. */
+    readonly serverDataRoutes?: readonly string[];
+}
+/** The generated module of an entry that renders one component. */
+export interface NativeComponentApplication {
+    readonly default: unknown;
+}
+export type NativeApplicationModule = NativeRoutedApplication | NativeComponentApplication;
+export declare function isRoutedApplication(application: NativeApplicationModule): application is NativeRoutedApplication;
+/** Structurally identical to router-core's `LocationRewrite`. */
+export interface NativeLocationRewrite {
+    input?: (args: {
+        url: URL;
+    }) => undefined | string | URL;
+    output?: (args: {
+        url: URL;
+    }) => undefined | string | URL;
+}
+export interface NativeRouterOptions {
+    readonly identity: RendererIdentity;
+    readonly loadRoute: NonNullable<FileSystemRouteOptions['loadRoute']>;
+    /** The server request this router renders; a browser router omits it. */
+    readonly request?: Request;
+    /** Retires every route load of this router, e.g. on entry disposal. */
+    readonly signal?: AbortSignal;
+    /** Private data-handler input; never part of native route context. */
+    readonly context?: object;
+    readonly onOutcome?: (routeId: string, outcome: RouteOutcome) => void;
+    readonly session?: RequestSession;
+    /** The document CSP nonce the router stamps on its emitted scripts. */
+    readonly nonce?: string;
+    readonly rewrite?: NativeLocationRewrite;
+}
+/** Router options a renderer passes to its native router constructor. */
+export interface NativeApplicationRouterOptions<Route> {
+    readonly routeTree: Route;
+    readonly basepath: string;
+    readonly context: {
+        readonly ultramodern: Readonly<{
+            rendererIdentity: Readonly<RendererIdentity>;
+        }>;
+    };
+    readonly rewrite?: NativeLocationRewrite;
+    readonly ssr?: {
+        readonly nonce: string;
+    };
+    /** A server router starts at the request location in memory history. */
+    readonly location?: {
+        readonly origin: string;
+        readonly href: string;
+    };
+}
+/** The renderer's own route tree and router constructors. */
+export interface NativeRouterFactory<Route, Router> {
+    routeTree(routes: readonly FileSystemRouteIR[], modules: Readonly<Record<string, Record<string, unknown>>>, options: FileSystemRouteOptions<object, Router>): Route;
+    router(options: NativeApplicationRouterOptions<Route>): Router;
+}
+/** Create the native router of a generated routed application. */
+export declare function createNativeRouter<Route, Router>(application: NativeRoutedApplication, options: NativeRouterOptions, factory: NativeRouterFactory<Route, Router>): Router;

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

@@ -0,0 +1,14 @@
+import { type DocumentAsset } from '../document.js';
+import { type Renderer, type RendererIdentity } from '../identity.js';
+export declare const RENDERER_ASSET_MANIFEST_FILE = "renderer-assets.json";
+export interface NativeClientAssetManifest {
+    readonly schema: 'ultramodern-renderer-assets';
+    readonly version: 1;
+    readonly renderer: Exclude<Renderer, 'react'>;
+    readonly entries: Readonly<Record<string, {
+        readonly rendererIdentity: RendererIdentity;
+        readonly assets: readonly DocumentAsset[];
+    }>>;
+}
+/** Read actual emitted initial assets, never infer URLs from source filenames. */
+export declare function validateNativeClientAssetManifest(value: unknown, expectedIdentity: RendererIdentity): readonly DocumentAsset[];