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

package/dist/esm-node/session/request.mjs

@@ -0,0 +1,232 @@
+import "node:module";
+import { identityCacheKey } from "../identity.mjs";
+import { permitsDocumentCache, policyHeaders } from "./cache.mjs";
+function freezeResponsePolicy(policy) {
+    if (!Number.isInteger(policy.status) || policy.status < 200 || policy.status > 599) throw new TypeError('A renderer response status must be an integer from 200 to 599.');
+    if ('document' !== policy.kind && 'terminal' !== policy.kind) throw new TypeError('A renderer response must identify its document or terminal outcome.');
+    const statusText = policy.statusText;
+    if (void 0 !== statusText && 'string' != typeof statusText) throw new TypeError('A renderer response status text must be a string.');
+    new Response(null, {
+        status: policy.status,
+        ...void 0 === statusText ? {} : {
+            statusText
+        }
+    });
+    if (![
+        'no-store',
+        'private',
+        'public'
+    ].includes(policy.cache.mode)) throw new TypeError('A renderer response has an unknown cache policy.');
+    if ('public' === policy.cache.mode && (!Number.isInteger(policy.cache.maxAgeSeconds) || policy.cache.maxAgeSeconds < 0)) throw new TypeError('A public document cache lifetime must be a nonnegative integer.');
+    const headers = policy.headers.map(([name, value])=>{
+        new Headers([
+            [
+                name,
+                value
+            ]
+        ]);
+        return Object.freeze([
+            name,
+            value
+        ]);
+    });
+    return Object.freeze({
+        kind: policy.kind,
+        status: policy.status,
+        ...void 0 === statusText ? {} : {
+            statusText
+        },
+        headers: Object.freeze(headers),
+        cache: Object.freeze({
+            ...policy.cache
+        })
+    });
+}
+function createRequestSession(input) {
+    identityCacheKey(input.identity);
+    if ('node' !== input.platform.kind && 'worker' !== input.platform.kind) throw new TypeError('A renderer request requires an explicit Node or worker binding.');
+    const identity = Object.freeze({
+        ...input.identity
+    });
+    const platform = Object.freeze({
+        ...input.platform
+    });
+    const abortController = new AbortController();
+    const disposers = new Set();
+    let state = 'matching';
+    let policy;
+    let committedPolicy;
+    let fallback = false;
+    let responseCreated = false;
+    let hasDocumentBody = false;
+    let deliveredResponse;
+    let deliveredHeaders;
+    let reader;
+    let bodyController;
+    let cancelPromise;
+    let finishPromise;
+    let resolveCompletion;
+    const completion = new Promise((resolve)=>{
+        resolveCompletion = resolve;
+    });
+    const cancelSource = (reason)=>{
+        cancelPromise ??= reader ? reader.cancel(reason).finally(()=>reader?.releaseLock()) : Promise.resolve();
+        return cancelPromise;
+    };
+    const finish = (terminalState, error)=>{
+        if (finishPromise) return finishPromise;
+        state = terminalState;
+        input.request.signal.removeEventListener('abort', onRequestAbort);
+        const ownedDisposers = [
+            ...disposers
+        ].reverse();
+        disposers.clear();
+        finishPromise = Promise.resolve().then(async ()=>{
+            const cleanupErrors = [];
+            let recorded = false;
+            if ('completed' !== terminalState) cancelSource(error).catch((cancelError)=>{
+                if (!recorded) cleanupErrors.push(cancelError);
+            });
+            for (const dispose of ownedDisposers)try {
+                await dispose();
+            } catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            await Promise.resolve();
+            recorded = true;
+            if ('completed' === terminalState && cleanupErrors.length > 0) state = 'failed';
+            const result = Object.freeze({
+                state: state,
+                fallback,
+                ...void 0 !== error ? {
+                    error
+                } : {},
+                cleanupErrors: Object.freeze(cleanupErrors),
+                cacheEligible: 'completed' === state && hasDocumentBody && !fallback && void 0 !== committedPolicy && permitsDocumentCache({
+                    ...committedPolicy,
+                    headers: deliveredHeaders ? [
+                        ...deliveredHeaders.entries()
+                    ] : committedPolicy.headers
+                })
+            });
+            resolveCompletion(result);
+            return result;
+        });
+        if ('completed' !== terminalState) {
+            abortController.abort(error);
+            bodyController?.error(error);
+        }
+        return finishPromise;
+    };
+    const abort = (reason = new DOMException('The renderer request was aborted.', 'AbortError'))=>{
+        finish('aborted', reason);
+    };
+    function onRequestAbort() {
+        abort(input.request.signal.reason);
+    }
+    const session = {
+        request: input.request,
+        identity,
+        platform,
+        signal: abortController.signal,
+        get state () {
+            return state;
+        },
+        get responsePolicy () {
+            return policy;
+        },
+        get committedPolicy () {
+            return committedPolicy;
+        },
+        completion,
+        resolveResponse (nextPolicy) {
+            if (committedPolicy || finishPromise) throw new Error('Renderer response status and headers are already committed or terminated.');
+            policy = freezeResponsePolicy(nextPolicy);
+            if ('matching' === state) state = 'ready';
+        },
+        startRendering () {
+            if ('ready' !== state) throw new Error('Resolve the blocking HTTP outcome before starting the renderer.');
+            state = 'rendering';
+        },
+        registerCleanup (dispose) {
+            if (finishPromise) throw new Error('Cannot register cleanup after a renderer request terminates.');
+            disposers.add(dispose);
+            return ()=>{
+                disposers.delete(dispose);
+            };
+        },
+        markFallback () {
+            if (finishPromise) throw new Error('Cannot change fallback disposition after a renderer request terminates.');
+            fallback = true;
+        },
+        respond (body) {
+            if (responseCreated || committedPolicy || finishPromise) throw new Error('A renderer request has exactly one response body consumer.');
+            if (!policy || 'ready' !== state && 'rendering' !== state) throw new Error('Resolve the blocking HTTP outcome before committing a response.');
+            if (null !== body && [
+                204,
+                205,
+                304
+            ].includes(policy.status)) throw new TypeError(`HTTP ${policy.status} cannot contain a renderer response body.`);
+            reader = body?.getReader();
+            hasDocumentBody = null !== body;
+            responseCreated = true;
+            committedPolicy = policy;
+            state = 'committed';
+            const headers = policyHeaders(committedPolicy.headers);
+            let wrappedBody = null;
+            if (reader) {
+                const sourceReader = reader;
+                wrappedBody = new ReadableStream({
+                    start (controller) {
+                        bodyController = controller;
+                    },
+                    async pull (controller) {
+                        try {
+                            const next = await sourceReader.read();
+                            if (finishPromise) return;
+                            if (!next.done) return void controller.enqueue(next.value);
+                            sourceReader.releaseLock();
+                            const result = await finish('completed');
+                            if (result.cleanupErrors.length > 0) controller.error(new AggregateError(result.cleanupErrors, 'Renderer request cleanup failed.'));
+                            else controller.close();
+                        } catch (error) {
+                            if (!finishPromise) {
+                                await finish('failed', error);
+                                controller.error(error);
+                            }
+                        }
+                    },
+                    cancel (reason) {
+                        abort(reason);
+                        return completion.then(()=>{});
+                    }
+                }, {
+                    highWaterMark: 0
+                });
+            } else finish('completed');
+            const response = new Response(wrappedBody, {
+                status: committedPolicy.status,
+                ...void 0 === committedPolicy.statusText ? {} : {
+                    statusText: committedPolicy.statusText
+                },
+                headers
+            });
+            deliveredResponse = response;
+            deliveredHeaders = response.headers;
+            return response;
+        },
+        ownsResponseBody (response) {
+            return void 0 !== deliveredResponse && (response === deliveredResponse || null !== deliveredResponse.body && response.body === deliveredResponse.body);
+        },
+        fail (error) {
+            finish('failed', error);
+        },
+        abort
+    };
+    if (input.request.signal.aborted) onRequestAbort();
+    else input.request.signal.addEventListener('abort', onRequestAbort, {
+        once: true
+    });
+    return session;
+}
+export { createRequestSession };

package/dist/esm-node/session/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/types/abort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 declare function untilAborted<T>(handled: T | Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/types/adapter.d.ts

@@ -0,0 +1,195 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Renderer, RendererIdentity } from './identity.js';
+/**
+ * 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>;
+/** Validate an adapter's internal consistency and freeze its descriptor data. */
+export declare function defineRendererAdapter<T extends RendererAdapter>(adapter: T): T;
+/** Third-party runtime packages a generated native application installs. */
+export declare function nativeRendererDependencies(profile: RendererBuildProfile): Record<string, string>;
+export {};

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

@@ -0,0 +1,2 @@
+/** Bound actual bytes while reading, rather than buffering an arbitrary body. */
+export declare function readBoundedDataText(response: Response, signal?: AbortSignal, maxBytes?: number): Promise<string>;

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

@@ -0,0 +1,17 @@
+import { type RendererIdentity } from '../identity.js';
+import { type DataOperation, type DecodedDataOutcome } from './types.js';
+export declare function readDataResponse(response: Response, expected: {
+    identity: RendererIdentity;
+    routeId: string;
+    operation: DataOperation;
+}, signal?: AbortSignal): Promise<DecodedDataOutcome>;
+export declare function createDataClient(routeId: string, identity: RendererIdentity, options?: {
+    fetch?: typeof globalThis.fetch;
+}): {
+    loader(input: {
+        request: Request;
+    }): Promise<DecodedDataOutcome>;
+    action(input: {
+        request: Request;
+    }): Promise<DecodedDataOutcome>;
+};

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

@@ -0,0 +1,14 @@
+export declare const DATA_CODEC: 'seroval-json@1.6.8';
+export declare const MAX_DATA_BYTES: number;
+export declare class DataProtocolError extends Error {
+    constructor(message: string);
+}
+/** Only explicit loader/action results are public. Request context is not data. */
+export declare function assertPublicData(value: unknown, options?: {
+    privateReferences?: WeakSet<object>;
+}): void;
+/** JSON text stays inert when it is placed in a script element. */
+export declare function escapeInlineDataJSON(text: string): string;
+/** JSON text. `serializeInlineData` escapes it when it goes into a document. */
+export declare function serializePublicData(value: unknown): string;
+export declare function parsePublicData(text: string): unknown;

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

@@ -0,0 +1,8 @@
+export * from './client.js';
+export * from './codec.js';
+export type { RequestDataPolicy } from './private.js';
+export { createRequestDataPolicy } from './private.js';
+export * from './routes.js';
+export * from './server.js';
+export * from './static.js';
+export * from './types.js';

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

@@ -0,0 +1,6 @@
+export interface RequestDataPolicy {
+    assertRoot(value: unknown): void;
+    assertValue(value: unknown): void;
+}
+/** Capture aliases before callbacks, and retain them as request context changes. */
+export declare function createRequestDataPolicy(roots: readonly unknown[]): RequestDataPolicy;

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

@@ -0,0 +1,28 @@
+/** Module references remain build-time strings; adapters import their own views. */
+export interface RouteModuleReferences {
+    data?: string;
+    clientData?: string;
+    loading?: string;
+    error?: string;
+    search?: string;
+    head?: string;
+    notFound?: string;
+}
+/** Filesystem structure only. Matching and scheduling belong to native routers. */
+export interface FileSystemRouteIR {
+    id: string;
+    file?: string;
+    path?: string;
+    index?: boolean;
+    isRoot?: boolean;
+    modules?: RouteModuleReferences;
+    children: FileSystemRouteIR[];
+}
+/**
+ * Project the structural CLI route shape without retaining source objects,
+ * executable handlers, component values, or arbitrary configuration.
+ * Input order and conventional path syntax survive the projection unchanged.
+ */
+export declare function projectFileSystemRoutes(routes: unknown): FileSystemRouteIR[];
+/** Convert conventional parameter spelling for TanStack without matching it. */
+export declare function toTanstackPath(pathname: string): string;

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

@@ -0,0 +1,59 @@
+import { type RendererIdentity } from '../identity.js';
+import { responseHeaders as collectDataHeaders } from '../session/cache.js';
+import type { ResponsePolicy } from '../session/types.js';
+import { type DataHandler, type DataHandlerInput, type DataOperation, type DataOutcome, type DataResponseMetadata, type PublicDataError, type SelectedDataRoute } from './types.js';
+export { collectDataHeaders };
+declare const DEFERRED: unique symbol;
+/**
+ * Combine header fields from two sources for one document: list fields
+ * (cookies, `Vary`, `Link`, `Server-Timing`, CSP) keep both sources' values,
+ * while a singleton field from `primary` replaces the `secondary` one.
+ */
+export declare function mergeHeaderFields(primary: readonly (readonly [string, string])[], secondary: readonly (readonly [string, string])[]): [string, string][];
+/**
+ * Opaque result of {@link deferData}. Exported so loaders returning it keep a
+ * nameable type under declaration emit (composite/declaration projects).
+ */
+export interface DeferredDataResult {
+    [DEFERRED]: true;
+    critical: Record<string, unknown>;
+    deferred: Record<string, Promise<unknown>>;
+    init?: ResponseInit;
+}
+export declare function deferData(critical: Record<string, unknown>, deferred: Record<string, Promise<unknown>>, init?: ResponseInit): DeferredDataResult;
+/** The native router supplies status after resolving its own route outcomes. */
+export declare function mergeDataResponseMetadata(outcomes: readonly DataOutcome[], nativeResponse: {
+    status: number;
+    statusText?: string;
+}): DataResponseMetadata;
+/** Loader representation headers cannot describe the native HTML document. */
+export declare function dataMetadataToDocumentPolicy(metadata: DataResponseMetadata): ResponsePolicy;
+/** Preserve a native terminal response while adding all matched loader cookies. */
+export declare function mergeDataResponseIntoResponse(response: Response, metadata: DataResponseMetadata): Response;
+export declare function publicDataError(error: unknown, production?: boolean): PublicDataError;
+/** Resolve every status/redirect/header outcome before the document commits headers. */
+export declare function normalizeDataResult(value: unknown, options?: {
+    thrown?: boolean;
+    production?: boolean;
+    signal?: AbortSignal;
+}): Promise<DataOutcome>;
+export declare function invokeRouteData<Context>(handler: DataHandler<Context>, input: DataHandlerInput<Context>, options?: {
+    production?: boolean;
+    privateValues?: readonly unknown[];
+}): Promise<DataOutcome>;
+export declare function createDataResponse(outcome: DataOutcome, identity: RendererIdentity, options: {
+    routeId: string;
+    operation: DataOperation;
+    signal?: AbortSignal;
+    production?: boolean;
+    onCancel?: (reason: unknown) => void | Promise<void>;
+}): Response;
+export declare function handleDataRequest<Context>(options: {
+    request: Request;
+    identity: RendererIdentity;
+    context: Context;
+    selectRoute: (request: Request, requestedRouteId: string, operation: DataOperation) => SelectedDataRoute<Context> | undefined | Promise<SelectedDataRoute<Context> | undefined>;
+    production?: boolean;
+    /** Additional dispatcher-owned request identities, never public payload. */
+    privateValues?: readonly unknown[];
+}): Promise<Response | undefined>;

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

@@ -0,0 +1,31 @@
+import { DATA_CONTENT_TYPE, DATA_STREAM_CONTENT_TYPE } from './types.js';
+/** Head marker written into documents produced by static prerendering. */
+export declare const PRERENDERED_DOCUMENT_META = "ultramodern-prerendered";
+/** Directory beside a prerendered document that holds its loader payloads. */
+export declare const STATIC_DATA_DIRECTORY = "__ultramodern-data";
+/** A loader response captured at build time, replayed by the data client. */
+export interface StaticDataPayload {
+    status: number;
+    contentType: typeof DATA_CONTENT_TYPE | typeof DATA_STREAM_CONTENT_TYPE;
+    body: string;
+}
+/** URL path of one route's loader payload for a search-free document path. */
+export declare function staticDataPayloadPath(pathname: string, routeId: string): string;
+/**
+ * The client reads a payload file whole before replaying it. One response
+ * wrapped as a JSON string can grow up to six times through escaping; a
+ * deferred stream's frames are bounded only one by one, so prerendering
+ * checks the whole file against the same limit.
+ */
+export declare const STATIC_DATA_PAYLOAD_MAX_BYTES: number;
+/**
+ * Read a captured loader response with a running byte bound. Encoding only
+ * grows the body, so a body over the limit fails as soon as it crosses it,
+ * before an unbounded deferred stream is buffered.
+ */
+export declare function readStaticDataPayloadBody(response: Response): Promise<string>;
+/** The payload file's text, or an error when the client could not read it. */
+export declare function encodeStaticDataPayload(payload: StaticDataPayload): string;
+export declare function isStaticDataPayload(value: unknown): value is StaticDataPayload;
+/** Whether the current browser document was emitted by static prerendering. */
+export declare function isPrerenderedDocument(): boolean;

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

@@ -0,0 +1,3 @@
+import type { SerovalJSON } from 'seroval';
+/** Validate inert, pure-data Seroval JSON before the decoder can coerce it. */
+export declare function validateSerializedData(value: unknown): asserts value is SerovalJSON;