/**
 * Is the runtime in dev mode? MUST match the Rust host's `is_dev_mode()`
 * (crates/runtime/src/frontend.rs): `PYLON_DEV_MODE` is on ONLY for the exact
 * strings "1" or "true" (case-insensitive). A bare `if (process.env.PYLON_DEV_MODE)`
 * is WRONG — the string "false"/"0" is truthy in JS, so an explicit
 * `PYLON_DEV_MODE=false` on a PROD machine would wrongly enable dev behavior
 * (e.g. the live-reload `<script>` was being injected into prod pages, whose
 * EventSource then 404-retried `/_pylon/dev/live` forever).
 */
export declare function isDevMode(): boolean;
/**
 * The message payload the host sends. Matches RenderRouteMessage in
 * crates/functions/src/protocol.rs.
 */
export interface RenderRouteMessage {
    type: "render_route";
    call_id: string;
    /**
     * Project-relative module path (e.g. "app/hello/page"). The
     * adapter joins cwd + this + the right extension (.tsx → .ts).
     */
    component: string;
    /**
     * Project-relative module paths for the layout chain, walked
     * root → leaf. Each layout's default export wraps the next as
     * `children`. Absent / empty when no layouts apply.
     *
     * Example:
     *   layouts: ["app/layout", "app/blog/layout"]
     *   component: "app/blog/[slug]/page"
     *
     * Resolves to:
     *   <RootLayout>
     *     <BlogLayout>
     *       <Page {...props} />
     *     </BlogLayout>
     *   </RootLayout>
     */
    layouts?: string[];
    /** The matched route pattern (e.g. `/blog/:slug`). */
    route_path: string;
    /**
     * The incoming request PATH, query already stripped by the router (it
     * passes `path_only_owned`). Reaches userland as BOTH `pathname` (use
     * this) and `url` (deprecated); the query is `search_params`.
     */
    url: string;
    /** Dynamic-segment matches keyed by name (e.g. `{slug: "hello-world"}`). */
    params: Record<string, string>;
    /** Parsed query string. */
    search_params: Record<string, string>;
    /** Lowercased header names → values. */
    headers: Record<string, string>;
    /** Parsed cookies. */
    cookies: Record<string, string>;
    /** Pylon auth context. */
    auth: {
        user_id: string | null;
        is_admin: boolean;
        tenant_id: string | null;
        roles: string[];
        is_guest?: boolean;
    };
    /**
     * Whether the request carried a session cookie (presence, not identity) —
     * surfaced as the identity-free `props.session.exists` (Phase 0 auth
     * bucketing). Default false / absent for back-compat.
     */
    session_present?: boolean;
    /**
     * Initial HTTP status the response controller starts at (default 200).
     * The host sets this to 404 when dispatching a `not-found.tsx` render
     * for an unmatched URL, so the boundary streams at 404 without the
     * component having to call `response.setStatus`. A page can still
     * override it via `response.setStatus`.
     */
    initial_status?: number;
    /**
     * Design render (dev only). No hydration tail, no dev HUD, no live-reload
     * snippet; the stylesheet is inlined with no size cap and the head gets a
     * `<base href>` so the HTML works inside a `srcdoc` iframe. See
     * `designHeadBlob`.
     */
    design?: boolean;
}
type Send = (msg: Record<string, unknown>) => void;
/**
 * Control-flow signal a page or layout throws to short-circuit the
 * render: `response.redirect(url)` / `response.notFound()`. The adapter
 * catches it and turns it into a 3xx + Location or a 404 instead of a
 * normal 200 body. Extends Error so React's stream rejects cleanly when
 * it's thrown during the shell render. (Throw it OUTSIDE an error
 * boundary — an enclosing boundary would swallow the signal.)
 */
export declare class PylonRouteControl extends Error {
    kind: "redirect" | "notFound";
    url?: string;
    redirectStatus?: number;
    constructor(kind: "redirect" | "notFound");
}
/**
 * Normalize a thrown value into a route-control signal: either the framework's
 * own `PylonRouteControl` (`response.redirect()` / `response.notFound()`) or a
 * branded `NotFoundError` thrown by `@pylonsync/react`'s `notFound()` from a
 * page/layout render. Returns `null` for an ordinary error so the caller falls
 * through to its real error-handling path.
 */
export declare function asRouteControl(err: unknown): PylonRouteControl | null;
export interface SsrCookieOptions {
    path?: string;
    domain?: string;
    maxAge?: number;
    expires?: Date | string;
    /** Defaults to true (secure default). Pass false for a client-readable cookie. */
    httpOnly?: boolean;
    /** Defaults to true in prod / false in dev. Forced true when sameSite="none". */
    secure?: boolean;
    /** Defaults to "lax". */
    sameSite?: "strict" | "lax" | "none";
}
export interface ResponseState {
    status: number;
    headers: Record<string, string>;
    cookies: string[];
}
/**
 * The per-render `response` controller handed to every page + layout in
 * props. Pylon already has a backend for data/mutations, so SSR's job is
 * just the response envelope: status, redirects, 404, and the occasional
 * Set-Cookie.
 *
 * IMPORTANT — call these during the SYNCHRONOUS shell render (the
 * component body, before any `await` / Suspense boundary). The HTTP head
 * is committed when the shell is ready; status/headers/cookies set from a
 * suspended subtree that streams in later are lost, and a redirect()/
 * notFound() thrown below a Suspense boundary is caught by React's error
 * handling rather than turned into a 3xx/404 (same constraint as Next's
 * streaming SSR). Per render, not shared across requests.
 */
export interface SsrResponse {
    /** Set the HTTP status (100–599). Default 200. */
    setStatus(code: number): void;
    /** Set a response header (name must be a token; value CR/LF/NUL-free). */
    setHeader(name: string, value: string): void;
    /** Append a Set-Cookie. Defaults: HttpOnly + SameSite=Lax. */
    setCookie(name: string, value: string, opts?: SsrCookieOptions): void;
    /** Throw to send a 3xx (default 307) + Location, no body. Shell-render only. */
    redirect(url: string, status?: number): never;
    /**
     * Throw to send a 404. Renders the nearest `not-found.tsx` (walking up
     * from the page's directory, wrapped in the route's layout chain), or a
     * minimal framework body if none is defined. Shell-render only — a throw
     * below a Suspense boundary is swallowed by React.
     */
    notFound(): never;
}
export declare function makeResponseController(state: ResponseState, defaultRedirectStatus?: number): SsrResponse;
/**
 * Merge page-set headers + cookies into the response_start header map.
 * Cookies are newline-joined under `set-cookie`; the host splits them
 * into one `Set-Cookie` header each (newline is forbidden inside a
 * cookie, so it can't be turned into header injection).
 */
/**
 * Wrap a per-request object so ANY observation — property `get`, `in` (`has`),
 * `Object.keys`/spread/`for…in` (`ownKeys`), or a descriptor probe — calls
 * `onTouch`. Used to mark a render request-specific (vetoing shared caching) the
 * instant it reads auth/headers/cookies. A bare `get` trap misses `in` and
 * `Object.keys`, which would observe the data without tripping the veto.
 * Exported for direct unit testing of that property.
 */
export declare function makeReadTrackingProxy(obj: Record<string, unknown> | undefined, onTouch: () => void): Record<string, unknown>;
/**
 * Deep clone via JSON round-trip — drops functions / proxies / symbols, keeping
 * only JSON-serializable data. Used to SNAPSHOT the bucket-tail props before any
 * page code can mutate them, so a page can't smuggle identity through a nested
 * field of params/searchParams into a shared cache entry. The deep copy is fully
 * independent of the source: a later mutation of the original object can't reach
 * the snapshot.
 */
export declare function jsonClone<T>(v: T): T;
/**
 * Revocable form of {@link makeReadTrackingProxy}. The render path wraps each
 * per-request input (auth / headers / cookies / session) in one of these and
 * REVOKES it once the render is done — so a page that stashed the props object
 * (or `props.auth`) in module-level state and read it on a LATER render gets a
 * hard throw instead of silently reading a prior request's identity WITHOUT
 * tripping this render's read-tracking. Revocation is per-render (each render
 * revokes only its own proxies), so it is sound even when the Bun runner
 * multiplexes concurrent renders. Fail-closed: the stale read throws, the render
 * fails, and nothing is cached.
 */
export declare function makeRevocableReadTrackingProxy(obj: Record<string, unknown> | undefined, onTouch: () => void): {
    proxy: Record<string, unknown>;
    revoke: () => void;
};
export declare function finalizeHeaders(state: ResponseState, extra?: Record<string, string>, internal?: Record<string, string>, effectiveStatus?: number): Record<string, string>;
/**
 * Phase 1 SSR handler. Resolves the component, renders it via
 * react-dom/server.renderToReadableStream, pumps chunks back to the
 * host as base64-encoded NDJSON.
 *
 * Errors fall back to a type:"error" frame so the host can return a
 * 500 with the error body. Mid-stream errors (after the first chunk
 * has flushed) are uncatchable here — React's `onError` would have
 * to feed into a separate signal, deferred to Phase 1.5.
 */
/**
 * Page SEO metadata. A page exports `export const metadata = {...}`
 * (static) or `export async function generateMetadata(props)` (dynamic,
 * e.g. param-derived titles). Kept flat — no deep nesting beyond og/twitter.
 *
 * React 19 hoists the resulting <title>/<meta>/<link> into <head>. A page
 * `title` overrides a layout's static `<title>` (both render; the browser
 * uses the last, which is the page's). React does NOT dedupe arbitrary
 * `<meta>`, so set `description`/OG in EITHER the layout OR page metadata,
 * not both, to avoid duplicate tags.
 */
/** A single OpenGraph image (for `openGraph.images` — multiple images). */
export interface OgImage {
    url: string;
    secureUrl?: string;
    type?: string;
    width?: number;
    height?: number;
    alt?: string;
}
export interface SsrMetadata {
    title?: string;
    description?: string;
    keywords?: string | string[];
    canonical?: string;
    robots?: string;
    /** `<meta name="author">` — one tag per author. */
    authors?: string | string[];
    /** `<meta name="theme-color">` — browser UI tint for the page. */
    themeColor?: string;
    openGraph?: {
        title?: string;
        description?: string;
        /** `og:image`. A root-relative path (`/og.png`) is resolved against
         *  the request origin before it's emitted — crawlers require an
         *  absolute URL and Twitter drops the card without one. */
        image?: string;
        /** `og:image:secure_url` — set automatically to the https image URL. */
        imageSecureUrl?: string;
        /** `og:image:type` (e.g. "image/png"). */
        imageType?: string;
        /** `og:image:width` / `og:image:height` in pixels. */
        imageWidth?: number;
        imageHeight?: number;
        imageAlt?: string;
        /** Additional images beyond the primary `image` (each emits its own
         *  `og:image` + dimensions). Relative URLs are absolutized. */
        images?: OgImage[];
        url?: string;
        type?: string;
        /** `og:locale` (e.g. "en_US"). */
        locale?: string;
        /** `og:site_name` — the brand the page belongs to (e.g. "Pylon").
         *  Discord and other unfurlers show this above the title. */
        siteName?: string;
        /** `article:*` tags for `og:type=article` pages. */
        article?: {
            author?: string | string[];
            publishedTime?: string;
            modifiedTime?: string;
            section?: string;
            tags?: string | string[];
        };
    };
    twitter?: {
        card?: string;
        title?: string;
        description?: string;
        image?: string;
        /** `twitter:site` / `twitter:creator` — @handles. */
        site?: string;
        creator?: string;
        /** `twitter:image:alt` — alt text for the card image. */
        imageAlt?: string;
    };
    /** `<link rel="icon">` / `<link rel="apple-touch-icon">`. Auto-wired
     *  from the app/icon.* + app/apple-icon.* + app/favicon.ico file
     *  conventions, or set explicitly. */
    icons?: {
        icon?: {
            url: string;
            type?: string;
            sizes?: string;
        };
        apple?: {
            url: string;
            type?: string;
            sizes?: string;
        };
    };
    /** Alternate URLs. `languages` emits `<link rel="alternate" hreflang>`
     *  per locale; `canonical` is an alias for the top-level `canonical`. */
    alternates?: {
        canonical?: string;
        languages?: Record<string, string>;
    };
    /** Structured data, emitted as `<script type="application/ld+json">`.
     *  One object or an array (each item gets its own script). Serialized with
     *  `<` escaped so values can't break out of the script element. */
    jsonLd?: Record<string, unknown> | Record<string, unknown>[];
}
/**
 * Build a React fragment of <title>/<meta>/<link> from a page's metadata.
 * React 19 auto-hoists these into <head> wherever they render, and the
 * host's </head> splice preserves them. React escapes all text/attrs, so
 * there's no manual XSS handling. Returns null when there's nothing to emit.
 */
export declare function renderMetadata(React: any, m: SsrMetadata | undefined): any;
/** Import a project-relative module, trying each common extension. */
export declare function importModule(cwd: string, relPath: string): Promise<any>;
/**
 * `findBoundary` with its filesystem and root injected, so the walk is
 * testable against a fixture without `chdir` — which races every other test
 * in the process.
 */
export declare function findBoundaryIn(fs: any, path: any, cwd: string, componentPath: string, fileName: string): string | null;
/** Pure origin resolution (exported for tests).
 *
 *  SECURITY: the request `Host` (and `X-Forwarded-Proto`) is attacker-
 *  controlled. It's only trusted to build the absolute origin baked into
 *  `og:image` / canonical URLs when it's in the allowlist — the configured
 *  public/canonical host, an explicit `PYLON_TRUSTED_HOSTS` entry, or
 *  loopback. An untrusted (or absent) Host falls back to the configured
 *  public origin. Without this, `Host: evil.com` on a cacheable
 *  (force-static / `revalidate`) render bakes `https://evil.com/_pylon/og…`
 *  into the HTML, which is then teed into the shared ISR/CDN cache and
 *  served to every subsequent visitor (cache poisoning). */
export declare function resolveOrigin(opts: {
    host?: string;
    forwardedProto?: string;
    publicUrl?: string;
    canonicalHost?: string;
    trustedHostsCsv?: string;
}): string;
/** SECURITY: validate a `response.redirect()` target to prevent OPEN REDIRECTS.
 *  Mirrors the OAuth-layer `validate_trusted_redirect` (crates/auth). A relative
 *  same-site path is always allowed; an absolute URL only when it's http(s) to a
 *  trusted host — the app's public/canonical origin, a `PYLON_TRUSTED_HOSTS`
 *  entry, or loopback. Everything else is rejected: protocol-relative
 *  `//evil.com`, backslash tricks (`/\evil.com` — browsers normalize `\`→`/`),
 *  other-origin absolutes, and `javascript:`/`data:` schemes. So the natural
 *  `response.redirect(searchParams.get("next"))` can't be turned into an
 *  off-site redirect by attacker-supplied input. Exported for tests. */
export declare function isSafeRedirect(url: string, opts: {
    publicUrl?: string;
    canonicalHost?: string;
    trustedHostsCsv?: string;
}): boolean;
/** Merge auto-discovered favicons (icon.* / apple-icon.* / favicon.ico)
 *  into a page's metadata. Explicit `metadata.icons.*` wins. */
export declare function applyAutoIcons(component: string, metadata: SsrMetadata | undefined): SsrMetadata | undefined;
export declare function applyAutoSocialImages(component: string, headers: Record<string, string> | undefined, metadata: SsrMetadata | undefined, requestUrl?: string, 
/** True for a not-found / error boundary — see findColocatedOgImageRoute. */
isBoundary?: boolean): SsrMetadata | undefined;
/**
 * Drain a `renderToReadableStream` reader, injecting `headBlob` immediately
 * before the first `</head>` (or, if the document has none, the blob is
 * never emitted — fragment renders have no head). `</head>` can straddle a
 * chunk boundary, so a small carry buffer (len("</head>") − 1 bytes) is
 * withheld at each chunk's tail until the next read confirms the match.
 * Each emitted slice is handed to `sendChunk` as utf-8 text.
 *
 * Shared by the page render and the boundary render so head injection has
 * exactly one implementation.
 *
 * Decoding uses ONE `TextDecoder` with `{stream: true}` for the whole
 * reader, never a per-chunk decode. React splits the byte stream at
 * arbitrary offsets, so a multi-byte character can land across two chunks;
 * decoding each chunk independently turns the orphaned bytes into one
 * U+FFFD apiece — `…` (e2 80 a6) arrives as three replacement characters.
 * The failure is silent and position-dependent: markup added anywhere
 * earlier shifts the boundary, so a page can render correctly for months
 * and corrupt on an unrelated CSS change. A streaming decoder holds the
 * partial sequence back until the bytes that complete it arrive.
 */
export declare function streamWithHeadInjection(reader: ReadableStreamDefaultReader<Uint8Array>, headBlob: string, sendChunk: (text: string) => void, bodyBlob?: string): Promise<void>;
/**
 * Dev-only tail chunk: the `__PYLON_DEV__` info blob (cache verdict, render
 * mode/timing, route) + the HUD bootstrap. Embedded after the page tail so the
 * marker + probe are in place before the deferred client entry boots the sync
 * engine. `<` is escaped so the JSON can't break out of the script.
 */
/**
 * Escape a JSON string so it can't break out of a `<script>` element: `<`
 * closes a `</script>` (or `<!--`, `<script`); U+2028/U+2029 are JS statement
 * terminators (valid in JSON, not in a JS string literal). Applied to every
 * server-serialized blob embedded in a script tag \u2014 the `application/json`
 * data blobs AND the executable fallback warning.
 */
export declare function escapeScriptJson(json: string): string;
export declare function buildDevHudChunk(devInfo: Record<string, unknown>): string;
/**
 * The free-tier attribution badge, injected before `</body>` when the control
 * plane sets `PYLON_CLOUD_BADGE` (it does so only for hobby-plan projects, and
 * the key is protected so an app cannot unset it for itself).
 *
 * Deliberately plain: one anchor, inline styles, no script, no webfont, no
 * network request. It renders inside somebody else's app, so it must not fight
 * their layout or cost their visitors a round trip. Everything it could
 * inherit from the host page — font, line-height, box-sizing, text-transform —
 * is stated rather than left to chance.
 *
 * Returns "" when the flag is unset: every paid project, and every self-hosted
 * install.
 */
export declare function buildCloudBadgeChunk(env?: Record<string, string | undefined>): string;
export declare function cssHeadTag(css: string, prefix: string, routeOverride?: boolean, maxBytes?: number): Promise<string>;
/**
 * `<base href>` for a design render. The HTML is shown in a `srcdoc` iframe,
 * where relative URLs have no origin to resolve against; the base points them
 * at the dev server. Uses the request's Host, else `127.0.0.1:<PYLON_PORT>`.
 */
export declare function designBaseHref(headers: Record<string, string | undefined>, env?: Record<string, string | undefined>): string;
/**
 * Build the hydration tail appended after React's stream EOFs: the
 * `__PYLON_DATA__` JSON blob (props + ssrData) + the per-route entry
 * `<script>` that hydrates it, + (dev) the live-reload snippet. Shared by the
 * page render AND the now-hydrated boundary render (#279) so a boundary
 * hydrates through the EXACT same path as a page.
 *
 * `kind` marks an error/not-found boundary so the client knows whether to
 * synthesize a `reset()`. For an error boundary, `errorForClient` is the SAFE
 * projection ({message, digest}) — the raw `Error` (and its stack) is NEVER
 * serialized (the dev overlay owns dev stacks; preserves the #270 posture).
 */
export declare function buildHydrationTail(args: {
    component: string;
    layouts: string[];
    props: any;
    ssrData: Record<string, any>;
    manifestRoute: {
        file: string;
        imports: string[];
        css: string[];
    } | null;
    publicPrefix: string;
    manifestErr: string | null;
    kind?: "error" | "not-found";
    errorForClient?: {
        message: string;
        digest?: string;
    };
    bucketAuth?: {
        signedIn: boolean;
    };
    /** Client-side NAVIGATION payload: emit the `__PYLON_DATA__` blob and
     *  nothing else. The client already has the runtime and resolves the route
     *  entry from the build manifest, so the entry `<script>`, the preload tags
     *  and the dev-reload snippet are all dead weight on a navigation. Shares
     *  this function — and therefore its props strip — rather than rebuilding
     *  the payload somewhere the security-relevant parts could drift. */
    dataOnly?: boolean;
}): string;
/**
 * Is this render answering a client-side navigation rather than a document
 * load? The client runtime sets `X-Pylon-Nav: 1`; the Rust host reads the same
 * header to key the ISR cache, so the two always agree on which shape a URL
 * is being asked for.
 */
export declare function isNavRequest(headers: Record<string, unknown> | undefined): boolean;
/**
 * Render a detached element (the metadata fragment) to an HTML string.
 *
 * A navigation response carries the page's `<title>`/`<meta>`/`<link>` so the
 * client can swap them, but not the page body — which the client re-renders
 * from `__PYLON_DATA__` anyway. Rendering the fragment on its own is what
 * lets the body be dropped without losing the head.
 */
export declare function renderElementToString(renderToReadableStream: any, element: any): Promise<string>;
/**
 * A short, non-reversible correlation id for an error — surfaced to the
 * client error boundary as `error.digest` (matching server logs) WITHOUT
 * carrying any stack content. FNV-1a over message+stack, 8 hex chars.
 */
export declare function errorDigest(err: any): string;
/**
 * Wrap a DbReader so each `serverData.x(...)` call returns a PROMISE CACHED
 * by (method, args) — required for React 19 `use()`, which re-invokes the
 * call on the post-suspense re-render and must get the same (now-resolved)
 * promise instead of a fresh pending one (else it suspends forever). Each
 * resolved value is also recorded into `valueCache` keyed identically, so it
 * can be serialized into `__PYLON_DATA__.ssrData` and replayed on the client
 * — keeping hydration free of mismatches.
 */
export declare function makeServerData(reader: any, valueCache: Record<string, any>, callFn?: (name: string, args?: Record<string, unknown>) => Promise<unknown>, onFnCall?: () => void): any;
/**
 * #278: does this route STREAM (vs buffer the whole document)? Streaming is
 * opt-in: a `loading.tsx` (route-level Suspense) or `export const streaming =
 * true` (inner-boundary). Pure for testing.
 */
export declare function computeWantsStream(hasLoading: boolean, mod: any): boolean;
/**
 * #277: how long an opt-in page stays cacheable, in seconds — or null if it
 * never opted in. `export const revalidate = N` (N>0) → N; `dynamic:
 * "force-static"` → a year (only a deploy invalidates); else null. Pure.
 */
export declare function computeRevalidateSecs(mod: any): number | null;
/**
 * #277 cache verdict — the security-critical predicate, extracted pure so the
 * leak class (a personalized/streaming render marked cacheable) is a TEST, not
 * a mental walkthrough. INVARIANT: result ⟹ !wantsStream (a streaming render
 * commits its head before auth/cookies/status are final, so it can never be
 * cached). Fail-closed: every condition must hold.
 */
export declare function computeCacheVerdict(args: {
    revalidateSecs: number | null;
    forceDynamic: boolean;
    authTouched: boolean;
    dynamicTouched: boolean;
    sessionTouched: boolean;
    cookieCount: number;
    strictPolicies: boolean;
    wantsStream: boolean;
    status: number;
}): boolean;
/**
 * PPR Phase 0 — the AUTH-BUCKET verdict: may this render be stored as a SHARED
 * cache entry keyed only on session-cookie PRESENCE (one signed-in shell + one
 * signed-out shell, both IDENTITY-FREE)? Pure, exported, leak-class tested.
 *
 * Like `computeCacheVerdict` EXCEPT `sessionTouched` is ALLOWED (reading
 * `props.session.exists` to render a binary signed-in/out nav is the whole
 * point — that bit is what the bucket keys on, and it's identical across all
 * users in the same bucket). Everything else still vetoes:
 *
 *  - `authTouched` — reading real `props.auth` (user_id/tenant_id/roles) makes
 *    the output identity-SPECIFIC, not bucket-uniform. This is the load-bearing
 *    gate: ANY identity-dependent output requires reading auth, so vetoing on
 *    `authTouched` proves a bucketable body depends on nothing but the binary
 *    session bit.
 *  - `dynamicTouched` — reading request headers/cookies makes it request-specific.
 *  - `strictPolicies` — in strict mode serverData reads are auth-FILTERED, so the
 *    body/ssrData would vary by identity even without the page reading auth. In
 *    the default (non-strict) mode serverData reads bypass the policy gate and
 *    return identity-independent rows, so the cached body is safe to share within
 *    the bucket. Strict mode therefore must NOT bucket.
 *  - cookieCount / forceDynamic / wantsStream / non-200 — same reasons as the
 *    anon verdict (a Set-Cookie, a streaming head, or an error/redirect can't be
 *    safely shared).
 *
 * Requires the explicit `bucketOptIn` (`export const cache = "auth-bucketed"`)
 * AND a TTL via `export const revalidate = N` — fail-closed: no opt-in or no TTL
 * → no bucket.
 */
export declare function computeBucketVerdict(args: {
    bucketOptIn: boolean;
    revalidateSecs: number | null;
    forceDynamic: boolean;
    authTouched: boolean;
    dynamicTouched: boolean;
    cookieCount: number;
    strictPolicies: boolean;
    wantsStream: boolean;
    status: number;
}): boolean;
/**
 * Dev HUD: explain the cache verdict for a finished render in human terms — the
 * verdict, its TTL, and (when dynamic) the SINGLE reason it isn't cached. Pure so
 * it's unit-tested and matches `computeCacheVerdict`/`computeBucketVerdict`
 * exactly. The "why isn't my page caching?" answer the framework otherwise throws
 * away.
 */
export declare function describeCacheVerdict(v: {
    bucketOptIn: boolean;
    cacheable: boolean;
    bucketable: boolean;
    revalidateSecs: number | null;
    authTouched: boolean;
    dynamicTouched: boolean;
    sessionTouched: boolean;
    cookieCount: number;
    strictPolicies: boolean;
    wantsStream: boolean;
    forceDynamic: boolean;
    status: number;
}): {
    verdict: "bucketed" | "cacheable" | "dynamic";
    secs: number | null;
    reason: string;
};
/**
 * #278: diff the response head committed at `response_start` against the final
 * state after EOF, to catch a late response.* mutation from a suspended subtree
 * that the already-sent head couldn't carry. Returns the dropped pieces, or
 * null if nothing was lost. Pure.
 */
export declare function diffCommittedResponse(snapshot: {
    status: number;
    cookies: string[];
    headerKeys: string[];
}, final: {
    status: number;
    cookies: string[];
    headers: Record<string, string>;
}): {
    droppedCookies: string[];
    statusChanged: boolean;
    newHeaderKeys: string[];
} | null;
/** One URL entry in a sitemap (mirrors Next's `MetadataRoute.Sitemap[number]`). */
export interface SitemapEntry {
    url: string;
    lastModified?: string | Date;
    changeFrequency?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
    priority?: number;
    /** hreflang alternates, e.g. `{ languages: { "en-US": "https://…/en" } }`. */
    alternates?: {
        languages?: Record<string, string>;
    };
}
/** Return type of a default export in `app/sitemap.ts`. */
export type Sitemap = SitemapEntry[];
export interface RobotsRule {
    userAgent?: string | string[];
    allow?: string | string[];
    disallow?: string | string[];
    crawlDelay?: number;
}
/** Return type of a default export in `app/robots.ts`. */
export interface Robots {
    rules: RobotsRule | RobotsRule[];
    sitemap?: string | string[];
    host?: string;
}
/** Serialize sitemap entries to a sitemaps.org 0.9 XML document. */
export declare function serializeSitemap(entries: Sitemap | undefined): string;
/** One link in an `llms.txt` section. */
export interface LlmsLink {
    title: string;
    url: string;
    /** Short note after the link — what an agent finds there. */
    notes?: string;
}
/** An H2-delimited section of file links. */
export interface LlmsSection {
    title: string;
    links: LlmsLink[];
}
/**
 * Return type of a default export in `app/llms.ts`, serialized to
 * <https://llmstxt.org> format.
 *
 * The spec's order is fixed and load-bearing, because the file is parsed by
 * "standard programmatic-based tools": an H1 title, a blockquote summary, free
 * prose with NO headings, then H2 sections of markdown links.
 */
export interface LlmsTxt {
    /** H1 — the site or project name. The one required element. */
    title: string;
    /** The blockquote under it: what this is, in one or two sentences. */
    summary?: string;
    /**
     * Prose paragraphs between the summary and the first section. Headings are
     * not allowed here — the parser reads the first H2 as the start of the link
     * lists, so a heading in this block would swallow the rest of the file.
     */
    details?: string | string[];
    sections?: LlmsSection[];
}
/** Serialize an {@link LlmsTxt} to llmstxt.org format. */
export declare function serializeLlms(doc: LlmsTxt | undefined): string;
/** Serialize a robots config to robots.txt text. */
export declare function serializeRobots(robots: Robots | undefined): string;
/**
 * Import app/sitemap or app/robots, run its default export, serialize the
 * result, and stream it back with the right content-type. Errors surface as a
 * 500 with a short plain-text message (so a broken sitemap doesn't wedge the
 * runner). 1-hour cache — sitemaps/robots change rarely; tune via a CDN.
 */
export declare function handleDataRoute(msg: RenderRouteMessage, kind: "sitemap" | "robots" | "llms", send: Send): Promise<void>;
/**
 * Import an `opengraph-image.tsx`, call its default export, render the
 * returned `ImageResponse` (or raw React element) to a PNG via Satori +
 * resvg (see `./ssr-og-runtime`), and stream the bytes back with an image
 * content-type. This is the code path behind the `opengraph-image` file
 * convention (Next.js `next/og` parity). Errors surface as a 500 with a
 * short plain-text body so a broken OG module doesn't wedge the runner.
 */
export declare function handleOgImageRoute(msg: RenderRouteMessage, send: Send): Promise<void>;
export declare function handleRenderRoute(msg: RenderRouteMessage, send: Send): Promise<void>;
export {};