@kasperpeulen/vitest-plugin-nextjs 0.0.0-alpha.0 → 0.1.0-alpha.0

package/dist/node-server.js

@@ -0,0 +1,193 @@
+import { registry } from "./registry.js";
+import { restoreIncrementalCache } from "./cache.js";
+import { MockedResponse, fromNodeOutgoingHttpHeaders, isDynamicServerError, toNodeOutgoingHttpHeaders } from "./compat/ssr/node-server.js";
+import { Readable } from "@kasperpeulen/vitest-plugin-nextjs/node/stream";
+//#region src/node-server.ts
+const nativeSetTimeout = globalThis.setTimeout;
+const leftBeforeSent = () => new DOMException("The page was left before the server had sent it.", "AbortError");
+/** The `http.IncomingMessage` of a request: a stream of its body, with what Next reads of it. */
+function createNodeRequest(request) {
+	const url = new URL(request.url);
+	const { body } = request;
+	const stream = body instanceof Uint8Array ? Readable.from([body]) : body && Readable.fromWeb(body);
+	return Object.assign(stream || Readable.from([]), {
+		method: request.method,
+		url: url.pathname + url.search,
+		headers: {
+			host: url.host,
+			...toNodeOutgoingHttpHeaders(request.headers)
+		},
+		httpVersion: "1.1",
+		socket: { encrypted: url.protocol === "https:" }
+	});
+}
+const writings = /* @__PURE__ */ new WeakMap();
+/** The `Writing` of a response of `handleRequest()` with a body. */
+const writingOf = (response) => writings.get(response);
+/**
+* The `http.ServerResponse` of a request, which is Next's own stand-in for
+* one, and the `Response` the browser gets of it: once its head is there, while
+* Next goes on to write the body.
+*
+* A request that is left before its head has no response. It lasts until
+* Next's handler is done with it, which can be much later, when the data it
+* waited for comes: its stores have to be there until then.
+*/
+function createNodeResponse(request) {
+	let controller;
+	let headSent = false;
+	let wrote = false;
+	let finished = false;
+	let cancelled = false;
+	let sendHead;
+	const head = new Promise((resolve) => sendHead = resolve).then(() => headSent = true);
+	const encoder = new TextEncoder();
+	let ended;
+	const bodyWritten = new Promise((resolve) => ended = resolve);
+	const body = new ReadableStream({
+		start: (c) => void (controller = c),
+		cancel() {
+			cancelled = true;
+			res.destroy();
+			ended();
+		}
+	});
+	const stop = () => {
+		cancelled = true;
+		controller.error(AbortSignal.abort().reason);
+		res.destroy();
+		ended();
+	};
+	const res = new MockedResponse({ resWriter(chunk) {
+		if (res.destroyed) return false;
+		sendHead();
+		wrote = headSent = res.headersSent = true;
+		controller.enqueue(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+		return true;
+	} });
+	const appendHeader = res.appendHeader.bind(res);
+	res.appendHeader = (name, value) => name.toLowerCase() === "location" && res.getHeader(name) === value ? res : appendHeader(name, value);
+	const end = res.end.bind(res);
+	res.end = ((...args) => {
+		end(...args);
+		if (res.destroyed) return res;
+		if (!wrote) finished = true;
+		headSent = res.headersSent = true;
+		sendHead();
+		return res;
+	});
+	res._writableState.autoDestroy = false;
+	res.on("finish", () => {
+		finished = true;
+		Object.defineProperty(res, "writableFinished", {
+			value: true,
+			configurable: true
+		});
+		controller.close();
+		ended();
+		nativeSetTimeout(() => res.destroy());
+	});
+	let failure;
+	res.on("error", (error) => failure ??= error);
+	res.on("close", () => {
+		if (!headSent || finished || cancelled) return;
+		controller.error(failure ?? leftBeforeSent());
+		ended();
+	});
+	res.hasStreamed.catch(() => {});
+	const { signal } = request;
+	const leave = () => res.destroy();
+	signal?.addEventListener("abort", leave, { once: true });
+	res.once("close", () => signal?.removeEventListener("abort", leave));
+	const response = (written) => {
+		const sent = head.then(() => {
+			const empty = finished && !wrote || [
+				101,
+				204,
+				205,
+				304
+			].includes(res.statusCode);
+			const answer = new registry.Response(empty ? null : body, {
+				status: res.statusCode,
+				statusText: res.statusMessage,
+				headers: fromNodeOutgoingHttpHeaders(res.getHeaders())
+			});
+			if (!empty) writings.set(answer, {
+				written: bodyWritten,
+				stop
+			});
+			return answer;
+		});
+		const settled = written.then(() => {
+			if (headSent) return sent;
+			res.destroy();
+			throw failure ?? leftBeforeSent();
+		}, (error) => {
+			if (!headSent) {
+				res.destroy();
+				throw error;
+			}
+			res.destroy(error ?? /* @__PURE__ */ new Error("The request handler failed."));
+			return sent;
+		});
+		return Promise.race([sent, settled]);
+	};
+	return {
+		res,
+		response
+	};
+}
+const staticToDynamic = "Page changed from static to dynamic at runtime ";
+const isPrerenderBailout = (error) => isDynamicServerError(error) || error instanceof Error && error.message.startsWith(staticToDynamic);
+const prerenders = [];
+const routerServerContexts = Symbol.for("@next/router-server-methods");
+globalThis[routerServerContexts] = { "": { logErrorWithOriginalStack(error) {
+	const prerender = prerenders.at(-1);
+	if (!isPrerenderBailout(error)) console.error(error);
+	else if (prerender) prerender.bailouts++;
+} } };
+/**
+* Counts the bail-outs that Next's handler reports for the prerender that
+* starts now: also those it answers with its error page itself, where its
+* render of a page recovers from the error (`app-page-runtime.js:1133-1224`).
+* The function it returns ends the count and answers it, once: a count that
+* stays would get the bail-outs of the prerenders after it.
+*/
+function countBailouts() {
+	const prerender = { bailouts: 0 };
+	prerenders.push(prerender);
+	return () => {
+		const at = prerenders.lastIndexOf(prerender);
+		if (at !== -1) prerenders.splice(at, 1);
+		return prerender.bailouts;
+	};
+}
+function requestMetaOf(request, routed = {}) {
+	return {
+		...routed.params && { params: routed.params },
+		...routed.query && { query: routed.query },
+		initURL: request.url,
+		initProtocol: new URL(request.url).protocol.slice(0, -1)
+	};
+}
+/**
+* One request, by the request handler Next's build makes for its route:
+* `templates/app-page-runtime` for a page and `templates/app-route` for a
+* route handler, as `next start` calls them.
+*/
+async function handleRequest(request, context, handler, routed, { statusCode, headers } = {}) {
+	const { res, response } = createNodeResponse(request);
+	if (statusCode !== void 0) res.statusCode = statusCode;
+	headers?.forEach((value, name) => {
+		if (name !== "set-cookie") res.setHeader(name, value);
+	});
+	return response(handler(createNodeRequest(request), res, {
+		waitUntil: context.waitUntil,
+		requestMeta: {
+			...requestMetaOf(request, routed),
+			incrementalCache: globalThis.__incrementalCache
+		}
+	}).finally(restoreIncrementalCache));
+}
+//#endregion
+export { countBailouts, handleRequest, isPrerenderBailout, writingOf };

package/dist/optimizer-cache-key.d.ts

@@ -0,0 +1,26 @@
+import { NextLayer, NextProject } from "./project.js";
+
+//#region src/optimizer-cache-key.d.ts
+type OptimizerInputs = Pick<NextProject, "aliases" | "appAliases" | "dependencyCompileOptions" | "newExports" | "version">;
+/**
+ * What the project gives the optimizer's plugins of a layer: Next's alias
+ * table and the app's, which the resolver picks from by the importer, and the
+ * options of Next's transform for a dependency. The tables in their order,
+ * not sorted: the resolver takes the first entry that matches, and a prefix
+ * like `next` can match where a later one would. The order is the code's,
+ * the same for every run. And the stubs of the stand-ins, of the version of
+ * Next.
+ */
+declare function projectKey(project: OptimizerInputs, layer: NextLayer): string;
+/**
+ * The code of a directory of the plugin: the contents of every file of it.
+ * The contents, not the version, which a build of this repository keeps, and
+ * not the times of the files, which every build changes. All of the code,
+ * not just the modules that compile a dependency: a bundle of `dist` mixes
+ * modules, and what those import is just as much the compile.
+ */
+declare function codeKey(dir: string): string;
+/** For the `define` of the optimizer of a layer, which Vite keys its cache on. */
+declare function optimizerCacheKey(project: OptimizerInputs, layer: NextLayer): Record<string, string>;
+//#endregion
+export { codeKey, optimizerCacheKey, projectKey };

package/dist/optimizer-cache-key.js

@@ -0,0 +1,73 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/optimizer-cache-key.ts
+const hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+/**
+* What the project gives the optimizer's plugins of a layer: Next's alias
+* table and the app's, which the resolver picks from by the importer, and the
+* options of Next's transform for a dependency. The tables in their order,
+* not sorted: the resolver takes the first entry that matches, and a prefix
+* like `next` can match where a later one would. The order is the code's,
+* the same for every run. And the stubs of the stand-ins, of the version of
+* Next.
+*/
+function projectKey(project, layer) {
+	return hash(JSON.stringify([
+		Object.entries(project.aliases[layer]),
+		Object.entries(project.appAliases[layer]),
+		project.dependencyCompileOptions[layer],
+		project.newExports,
+		project.version
+	]));
+}
+const isCode = (file) => /\.[cm]?[jt]sx?$/.test(file) && !/\.test\.[cm]?[jt]sx?$/.test(file) && !/\.d\.[cm]?ts$/.test(file);
+/**
+* The code of a directory of the plugin: the contents of every file of it.
+* The contents, not the version, which a build of this repository keeps, and
+* not the times of the files, which every build changes. All of the code,
+* not just the modules that compile a dependency: a bundle of `dist` mixes
+* modules, and what those import is just as much the compile.
+*/
+function codeKey(dir) {
+	const content = createHash("sha256");
+	const files = fs.readdirSync(dir, {
+		recursive: true,
+		encoding: "utf8"
+	}).map((file) => file.split(path.sep).join("/")).filter(isCode).sort();
+	for (const file of files) {
+		const full = path.join(dir, file);
+		if (!fs.statSync(full).isFile()) continue;
+		content.update(`${file}\0`).update(fs.readFileSync(full)).update("\0");
+	}
+	return content.digest("hex").slice(0, 16);
+}
+function ownCodeDirs() {
+	const file = fileURLToPath(import.meta.url);
+	for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+		const manifest = path.join(dir, "package.json");
+		if (!fs.existsSync(manifest)) continue;
+		const { name } = JSON.parse(fs.readFileSync(manifest, "utf8"));
+		if (name !== "@kasperpeulen/vitest-plugin-nextjs") return [];
+		const core = path.dirname(createRequire(import.meta.url).resolve("@kasperpeulen/vitest-plugin-rsc/package.json"));
+		return [dir, core].flatMap((pkg) => ["src", "dist"].map((code) => path.join(pkg, code))).filter((code) => fs.statSync(code, { throwIfNoEntry: false })?.isDirectory());
+	}
+	return [];
+}
+let ownCodeKey;
+/** For the `define` of the optimizer of a layer, which Vite keys its cache on. */
+function optimizerCacheKey(project, layer) {
+	if (ownCodeKey === void 0) try {
+		ownCodeKey = hash(ownCodeDirs().map((dir) => `${path.basename(dir)}:${codeKey(dir)}`).join(","));
+	} catch {
+		ownCodeKey = "";
+	}
+	return {
+		__vitest_plugin_rsc_project__: JSON.stringify(projectKey(project, layer)),
+		__vitest_plugin_rsc_code__: JSON.stringify(ownCodeKey)
+	};
+}
+//#endregion
+export { codeKey, optimizerCacheKey, projectKey };

package/dist/own-package.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/own-package.js

@@ -0,0 +1,6 @@
+import { fileURLToPath } from "node:url";
+import { addOwnPackage } from "@kasperpeulen/vitest-plugin-rsc/internal/own-packages";
+//#region src/own-package.ts
+addOwnPackage("@kasperpeulen/vitest-plugin-nextjs", fileURLToPath(new URL("./", import.meta.url)));
+//#endregion
+export {};

package/dist/page-store.d.ts

@@ -0,0 +1,33 @@
+//#region src/page-store.d.ts
+type Cookie = {
+  value: string;
+  httpOnly: boolean;
+};
+/**
+ * What the browser's requests to the app carry, besides what a browser adds
+ * itself. One for the document, from what the test opened until the test
+ * ends: `cleanup()` makes a new one.
+ */
+declare class PageStore {
+  #private;
+  /** The `headers` of what the test opened, until it opens something else. */
+  headers: Headers;
+  /** The app's cookies, by name, with the values the server wrote. */
+  readonly cookies: Map<string, Cookie>;
+  /** Sets the cookies of a `cookie` header, as a `Set-Cookie` of each would. */
+  seed(cookie: string): void;
+  /** Sets and deletes cookies by the `Set-Cookie` headers of a response of the app. */
+  receive(setCookies: Iterable<string>): void;
+  /**
+   * Sets or deletes a cookie as a script of the page does, with
+   * `document.cookie`. As in a browser, a script cannot write an `HttpOnly`
+   * cookie, nor change or delete one.
+   */
+  write(setCookie: string): void;
+  /** The `cookie` header of a request: empty without cookies. */
+  cookieHeader(): string;
+  /** What `document.cookie` has: the cookies that are not `HttpOnly`. */
+  documentCookie(): string;
+}
+//#endregion
+export { PageStore };

package/dist/page-store.js

@@ -0,0 +1,80 @@
+//#region src/page-store.ts
+/** A name and a value: of a `cookie` header, or of a `Set-Cookie` before its first `;`. */
+function pairOf(text) {
+	const at = text.indexOf("=");
+	return at === -1 ? ["", text.trim()] : [text.slice(0, at).trim(), text.slice(at + 1).trim()];
+}
+/** The name of an attribute of a `Set-Cookie`, in lower case, and its value. */
+function attributeOf(text) {
+	const at = text.indexOf("=");
+	return at === -1 ? [text.trim().toLowerCase(), ""] : [text.slice(0, at).trim().toLowerCase(), text.slice(at + 1).trim()];
+}
+function expiresAt(value) {
+	if (!/\d{1,2}:\d{1,2}:\d{1,2}/.test(value)) return void 0;
+	if (!/jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/i.test(value)) return void 0;
+	const time = Date.parse(value);
+	return Number.isNaN(time) ? void 0 : time;
+}
+function deletes(attributes) {
+	let maxAge;
+	let expires;
+	for (const [name, value] of attributes.map(attributeOf)) {
+		if (name === "max-age" && /^-?\d+$/.test(value)) maxAge = Number(value);
+		if (name === "expires") expires = expiresAt(value) ?? expires;
+	}
+	if (maxAge !== void 0) return maxAge <= 0;
+	return expires !== void 0 && expires <= Date.now();
+}
+/** The cookies as a `cookie` header, or as `document.cookie` has them. */
+function serialize(cookies) {
+	return Array.from(cookies, ([name, { value }]) => name ? `${name}=${value}` : value).join("; ");
+}
+/**
+* What the browser's requests to the app carry, besides what a browser adds
+* itself. One for the document, from what the test opened until the test
+* ends: `cleanup()` makes a new one.
+*/
+var PageStore = class {
+	/** The `headers` of what the test opened, until it opens something else. */
+	headers = new Headers();
+	/** The app's cookies, by name, with the values the server wrote. */
+	cookies = /* @__PURE__ */ new Map();
+	/** Sets the cookies of a `cookie` header, as a `Set-Cookie` of each would. */
+	seed(cookie) {
+		this.receive(cookie.split(";"));
+	}
+	/** Sets and deletes cookies by the `Set-Cookie` headers of a response of the app. */
+	receive(setCookies) {
+		for (const setCookie of setCookies) this.#set(setCookie, false);
+	}
+	/**
+	* Sets or deletes a cookie as a script of the page does, with
+	* `document.cookie`. As in a browser, a script cannot write an `HttpOnly`
+	* cookie, nor change or delete one.
+	*/
+	write(setCookie) {
+		this.#set(setCookie, true);
+	}
+	/** The `cookie` header of a request: empty without cookies. */
+	cookieHeader() {
+		return serialize(this.cookies);
+	}
+	/** What `document.cookie` has: the cookies that are not `HttpOnly`. */
+	documentCookie() {
+		return serialize(Array.from(this.cookies).filter(([, { httpOnly }]) => !httpOnly));
+	}
+	#set(setCookie, byScript) {
+		const [pair = "", ...attributes] = setCookie.split(";");
+		const [name, value] = pairOf(pair);
+		if (!name && !value) return;
+		const httpOnly = attributes.some((attribute) => attributeOf(attribute)[0] === "httponly");
+		if (byScript && (httpOnly || this.cookies.get(name)?.httpOnly)) return;
+		if (deletes(attributes)) this.cookies.delete(name);
+		else this.cookies.set(name, {
+			value,
+			httpOnly
+		});
+	}
+};
+//#endregion
+export { PageStore };

package/dist/page-timers.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "vite";
+
+//#region src/page-timers.d.ts
+/**
+ * Those uses, to the module runner's. Also for the dependency optimizer of
+ * the browser layer, by its `transform.define`: the bundler replaces them in
+ * every module of the pre-bundle, natively and in parallel, and the result
+ * stays on disk, where the plugin below would compile each pre-bundled file
+ * again in every run. None of them is a file of the host, and the packages
+ * of the host are not in it (`vitest-plugin-rsc:next-host-packages`).
+ */
+declare const pageTimersDefine: {
+  [k: string]: string;
+};
+/**
+ * For the modules of the browser layer, by the name of its environment, but
+ * those of a file that `isHostFile()`, and the pre-bundled dependencies,
+ * which have `pageTimersDefine`.
+ */
+declare function pageTimersPlugin(environment: string, isHostFile: (file: string) => boolean): Plugin;
+//#endregion
+export { pageTimersDefine, pageTimersPlugin };

package/dist/page-timers.js

@@ -0,0 +1,47 @@
+import { fileOfModule } from "./client-files.js";
+import { runnerGlobalNames, timersKey } from "@kasperpeulen/vitest-plugin-rsc/internal/timers";
+import { normalizePath, transformWithOxc } from "vite";
+import { ssrImportMetaKey } from "vite/module-runner";
+//#region src/page-timers.ts
+/**
+* Those uses, to the module runner's. Also for the dependency optimizer of
+* the browser layer, by its `transform.define`: the bundler replaces them in
+* every module of the pre-bundle, natively and in parallel, and the result
+* stays on disk, where the plugin below would compile each pre-bundled file
+* again in every run. None of them is a file of the host, and the packages
+* of the host are not in it (`vitest-plugin-rsc:next-host-packages`).
+*/
+const pageTimersDefine = Object.fromEntries(runnerGlobalNames.map((name) => [name, `${ssrImportMetaKey}.${timersKey}.${name}`]));
+const mentionsTimer = new RegExp(`\\b(?:${runnerGlobalNames.join("|")})\\b`);
+/**
+* For the modules of the browser layer, by the name of its environment, but
+* those of a file that `isHostFile()`, and the pre-bundled dependencies,
+* which have `pageTimersDefine`.
+*/
+function pageTimersPlugin(environment, isHostFile) {
+	return {
+		name: "vitest-plugin-rsc:next-page-timers",
+		enforce: "post",
+		applyToEnvironment: ({ name }) => name === environment,
+		transform: {
+			filter: { code: mentionsTimer },
+			async handler(code, id) {
+				const { environment } = this;
+				if (environment.mode === "dev" && environment.depsOptimizer?.isOptimizedDepFile(id)) return;
+				const file = fileOfModule(id);
+				if (file !== void 0 && isHostFile(file)) return;
+				try {
+					return await transformWithOxc(code, normalizePath(id), {
+						lang: "js",
+						define: pageTimersDefine
+					});
+				} catch (error) {
+					const reason = String(error instanceof Error ? error.message : error);
+					this.warn(`vitest-plugin-rsc: the timers of ${id} keep running after its page is left, it does not parse as JavaScript. ${reason.replace(/\s+/g, " ")}`);
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { pageTimersDefine, pageTimersPlugin };

package/dist/page.d.ts

@@ -0,0 +1,112 @@
+import { Opened } from "./registry.js";
+import { PageStore } from "./page-store.js";
+import { NodeOnPage } from "./node-on-page.js";
+import { HistoryEntry } from "./document.js";
+import { ShellErrorAnswer } from "./ssr.js";
+
+//#region src/page.d.ts
+/**
+ * A navigation without a page of the app, which has the router, under
+ * Vitest: a component that a test file with `"use client"` rendered has none.
+ */
+declare function noRouter(url: URL): Error;
+/**
+ * A page of the app, from the first line of its load until it is left, with
+ * the node of `renderServer()` on it, and where it reports its errors. Its
+ * load makes it part by part, and each part that would outlive the page says
+ * how it is released. Leaving stops the load at once, and releases the
+ * parts, the last first.
+ */
+declare class Page {
+  #private;
+  readonly errors: unknown[];
+  readonly nodeOnPage?: NodeOnPage | undefined;
+  /** Whether the page renders in the app kept from the page before: see `kept`. */
+  readonly inKeptApp: boolean;
+  /** Aborts as the page is left: what the load does takes it. */
+  readonly signal: AbortSignal;
+  constructor(errors: unknown[], nodeOnPage?: NodeOnPage | undefined, /** Whether the page renders in the app kept from the page before: see `kept`. */
+
+  inKeptApp?: boolean);
+  /** Whether the page is open: from when its client starts until it is left. */
+  get open(): boolean;
+  /**
+   * Runs `release` as the page is left: before what the load made before
+   * it. As `defer()` of a `DisposableStack`.
+   */
+  defer(release: () => void): void;
+  /**
+   * Opens the page: its client starts. Leaving waits for `started` to
+   * settle, at most `startTimeout`, before it releases what the page holds.
+   * `stopped` runs once the start is over for the page: once `started` has
+   * settled, or once leaving stops waiting for it.
+   */
+  starts(started: Promise<unknown>, stopped: () => void): void;
+  /**
+   * Leaves the page: `by` is what leaves it, for its node. Stops its load at
+   * once. Resolves once what the page holds is released, or rejects with the
+   * first error of a release, after every release has run. A page still
+   * starting after `startTimeout` is released once it has stopped, and
+   * `reportError()` gets that error: leaving resolves without it. Once:
+   * leaving it again gets the same promise.
+   */
+  leave(by: string): Promise<void>;
+}
+/**
+ * Leaves the page of the kept app that is open, as `leavePage()` does with
+ * `by`, and then the kept app: a test file ends with them. The app goes also
+ * after a page that could not be left, and the first error rejects.
+ */
+declare function leaveKeptAppWithPage(by: string): Promise<void>;
+/** The page that is open: see `Page.open`. */
+declare function currentPage(): Page | undefined;
+type Opening = {
+  container?: Element;
+  opened: Opened;
+  headers: Headers;
+  cookie: string | null; /** For a node: what `rerender()` waits for. */
+  nodeOnPage?: NodeOnPage; /** What stops the load: see `RequestOptions.signal` in index.ts. */
+  signal?: AbortSignal; /** Where the page, and the pages the app loads from it, report their errors. */
+  errors: unknown[];
+  /**
+   * Renders the page in the app of the page before, if it is kept, and else
+   * keeps the app it starts for the pages after it: see `kept`. A page of
+   * `keepApp` without HTML of the server.
+   */
+  inKeptApp?: boolean;
+};
+type PageDocument = {
+  response: Response;
+  html: string;
+  after?: HistoryEntry;
+  payload?: Uint8Array<ArrayBuffer>;
+};
+declare function loadPage(url: URL, request: RequestInit | PageDocument, from: PageStore, opening?: Opening): Promise<Response>;
+/** The Flight payload in the scripts of a document of Next. */
+declare function payloadInDocument(html: string): Uint8Array;
+/**
+ * How the server would have answered the document of the page of a Flight
+ * payload, had it rendered its HTML, by the errors in the payload (see
+ * `shellErrorAnswer()` in ssr.ts): the first `redirect()`, wherever it is in
+ * the tree, as Next's router follows it (its RedirectBoundary), else the
+ * status of the first other error. Undefined for a payload without an error.
+ * A path of the app's has the app's `basePath` before it, which `redirect()`
+ * takes without it, as Next's server puts it in the `Location` of the 307 of
+ * a document.
+ */
+declare function renderFailureOf(payload: Uint8Array, answerOf: (digest: string) => ShellErrorAnswer): ShellErrorAnswer | undefined;
+/**
+ * A navigation of the app without its router, as a browser makes it: a
+ * `<form>`, an `<a>` that React does not handle, `location.assign()`. The
+ * page that is open stays until the answer is there, and for good when the
+ * answer is a download (downloads.ts). Else the answer is the next page,
+ * which needs a page of the app to navigate in. `downloadRequest` is the
+ * navigation's, and `from` the store of the browser context it is in. With
+ * `push` the next page gets an entry of the history of its own, as after a
+ * link or a form in a browser. Else it takes the entry of the page, as
+ * after a reload or `location.replace()`.
+ */
+declare function navigate(url: URL, init: RequestInit, downloadRequest: string | null, from: PageStore, push: boolean): Promise<void>;
+declare function leavePage(by: string): Promise<void>;
+//#endregion
+export { Page, currentPage, leaveKeptAppWithPage, leavePage, loadPage, navigate, noRouter, payloadInDocument, renderFailureOf };