/**
 * Nexus SSR Renderer — assembles server-rendered HTML with island markers.
 * Implements PPR (Partial Pre-Rendering): static shell + dynamic holes.
 *
 * Edge-Cache Header Strategy:
 *   Nexus knows the TTL of every cache() call made during rendering.
 *   The renderer collects these TTLs and emits the most conservative
 *   Cache-Control header, ensuring CDNs never serve stale content.
 *
 *   Rules:
 *     1. No cache() calls → Cache-Control: no-store (dynamic, session data)
 *     2. All static (TTL=∞) → Cache-Control: public, max-age=31536000, immutable
 *     3. Mixed TTLs → Cache-Control: s-maxage=<min(ttls)>, stale-while-revalidate=<swr>
 *     4. Has Suspense boundary → Cache-Control: no-store (streaming, can't cache)
 *     5. Has user session → Cache-Control: private, no-store (never CDN-cache)
 */
import type { MatchedRoute } from '@nexus_js/router';
import { type NexusContext } from './context.js';
export interface RenderOptions {
    dev: boolean;
    /** Required for loading `.nx` routes (dev compile + prod build path). */
    appRoot: string;
    /**
     * From `.nexus/build-id.json` after `nexus build`. Injected into the document
     * as `window.__NEXUS_BUILD_ID__` so `callAction` can send `x-nexus-build-id`.
     */
    buildId?: string;
    assets: AssetManifest;
    /**
     * Extra `<script type="importmap">` `imports` entries (merged over Nexus defaults).
     * Pass from `nexus.config.ts` `browser.importMap` for island bare imports (e.g. `qr-code-styling`).
     */
    browserImportMap?: Record<string, string>;
    /**
     * Per-request CSP nonce (base64url, 16 bytes).
     * When provided, all inline `<script>` tags in the rendered document carry
     * `nonce="{nonce}"`, and the `Content-Security-Policy` header is generated
     * by the caller using this value.
     * Generate with `randomBytes(16).toString('base64url')` per request.
     */
    cspNonce?: string;
}
export interface AssetManifest {
    runtime: string;
    styles: string[];
    islands: Map<string, string>;
}
export interface RenderResult {
    html: string;
    headers: Record<string, string>;
    status: number;
    /** Resolved cache TTL for this page (seconds). 0 = no-store. */
    cacheTtl: number;
    /** Number of island markers found in the rendered HTML */
    islandCount: number;
}
/** A single entry in the server-to-browser log bridge */
export interface ServerBridgeLog {
    type: 'render' | 'cache' | 'fetch' | 'action' | 'island-count';
    path?: string;
    duration?: number;
    cacheStrategy?: string;
    cacheHit?: boolean;
    islandCount?: number;
    url?: string;
    label?: string;
}
/** Build-time info injected into the dev bridge for the "performance score" */
export interface BuildInfo {
    /** Estimated JS bytes for this route */
    totalJs?: number;
    /** Estimated JS bytes if using React instead (injected as `reactEquivalent`) */
    reactEquivalent?: number;
}
/** Called by @nexus_js/runtime cache() to register a TTL for this render. */
export declare function registerCacheTTL(ttl: number): void;
/** Called when the renderer detects a user session cookie. */
export declare function markSessionRequest(): void;
/** Called when the renderer detects a Suspense/streaming boundary. */
export declare function markStreamingResponse(): void;
/**
 * Computes the Cache-Control header value from the collected TTL context.
 * This is the "smart cache" — the renderer's output is correct by construction.
 */
export declare function computeCacheControl(ctx: NexusContext): {
    header: string;
    ttl: number;
    strategy: string;
};
/**
 * Renders a matched route to a full HTML response.
 * Wraps the page with its layout chain and injects island hydration scripts.
 */
/**
 * Runs the data loader (`load` / `nxPretext`) from every layout (outer → inner) and the page
 * in parallel, then shallow-merges results onto `ctx.pretext` (child wins on key collisions).
 * This powers both the `{pretext.xxx}` template usage and the client-side `$pretext()`.
 */
export declare function mergeRoutePretext(matched: MatchedRoute, ctx: NexusContext, opts: RenderOptions): Promise<Record<string, unknown>>;
type LayoutsAndPageOk = {
    ok: true;
    content: string;
    islandCount: number;
};
type LayoutsAndPageErr = {
    ok: false;
    result: RenderResult;
};
/**
 * Runs layouts + page render after `ctx.pretext` is set (used by buffered and streaming SSR).
 */
export declare function runLayoutsAndPage(matched: MatchedRoute, ctx: NexusContext, opts: RenderOptions): Promise<LayoutsAndPageOk | LayoutsAndPageErr>;
/**
 * Progressive SSR: flush the HTML shell (head + skeleton) before `nxPretext` finishes,
 * then stream the real layout/page fragment and update `#__NEXUS_PRETEXT__`.
 *
 * Requires fragment layouts: the composed route must not emit a root `&lt;html&gt;` document.
 */
export declare function renderRouteStreaming(matched: MatchedRoute, ctx: NexusContext, opts: RenderOptions): Response;
export declare function renderRoute(matched: MatchedRoute, ctx: NexusContext, opts: RenderOptions): Promise<RenderResult>;
export declare function wrapWithDocument(content: string, opts: RenderOptions, bridgeLogs?: ServerBridgeLog[], islandCount?: number, pretextWire?: string | null, headHtml?: string): string;
/**
 * Serializes island props for client-side hydration.
 *
 * Encoding: base64url (URL-safe, no padding issues in HTML attributes).
 * We JSON-stringify first so any type (Date, nested objects, arrays) survives
 * the round-trip, then base64url-encode so the value is safe inside any HTML
 * attribute without escaping — base64 never contains `<`, `>`, `"`, or `&`.
 *
 * Using Buffer.from().toString('base64url') instead of btoa() because btoa()
 * throws RangeError on characters outside Latin-1 (e.g. emoji, CJK, etc.).
 */
export declare function serializeIslandProps(props: Record<string, unknown>): string;
/**
 * Wraps a component's HTML output with island metadata for client hydration.
 */
export declare function wrapIsland(html: string, opts: {
    id: string;
    componentPath: string;
    strategy: string;
    props?: Record<string, unknown>;
    mediaQuery?: string;
}): string;
export {};
//# sourceMappingURL=renderer.d.ts.map