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

package/dist/fast-crypto.d.ts

@@ -0,0 +1,20 @@
+//#region src/fast-crypto.d.ts
+/** The file of the stand-ins, which the modules below import. */
+declare function fastCryptoFile(): string;
+/**
+ * The name of the stand-in module for an import of a server layer, if it has
+ * one: a package that hashes passwords, or `node:crypto`, whose module is the
+ * layer's own with the stand-ins in it, `nodeCrypto`.
+ */
+declare function fastCryptoModuleOf(source: string): string | undefined;
+/**
+ * The code of a stand-in module by its name: for `node-crypto`, the layer's
+ * `node:crypto`, `nodeCrypto`, with its `pbkdf2`, `scrypt` and `argon2` the
+ * stand-ins. That is the file of the package's module in a browser, and
+ * Node's own in a worker of Node.js (node-builtins.ts).
+ */
+declare function fastCryptoModule(name: string, nodeCrypto: string): string | undefined;
+/** The module of the setup file: Web Crypto's PBKDF2 a stand-in, or nothing. */
+declare function fastCryptoSetup(enabled: boolean): string;
+//#endregion
+export { fastCryptoFile, fastCryptoModule, fastCryptoModuleOf, fastCryptoSetup };

package/dist/fast-crypto.js

@@ -0,0 +1,151 @@
+import { isBuiltin } from "node:module";
+import { normalizePath } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/fast-crypto.ts
+const ownFile = fileURLToPath(import.meta.url);
+const standInsFile = normalizePath(path.join(path.dirname(ownFile), path.extname(ownFile) === ".ts" ? "../dist/fast-crypto/index.js" : "./fast-crypto/index.js"));
+/** The file of the stand-ins, which the modules below import. */
+function fastCryptoFile() {
+	if (!fs.existsSync(standInsFile)) throw new Error(`vitest-plugin-rsc: no ${standInsFile}, the package is not built: run \`pnpm build\``);
+	return standInsFile;
+}
+const packages = {
+	bcryptjs: {
+		factory: `bcrypt("bcryptjs")`,
+		names: [
+			"genSaltSync",
+			"genSalt",
+			"hashSync",
+			"hash",
+			"compareSync",
+			"compare",
+			"getRounds",
+			"getSalt",
+			"truncates",
+			"encodeBase64",
+			"decodeBase64",
+			"setRandomFallback"
+		],
+		specifiers: ["bcryptjs"]
+	},
+	bcrypt: {
+		factory: `bcrypt("bcrypt")`,
+		names: [
+			"genSaltSync",
+			"genSalt",
+			"hashSync",
+			"hash",
+			"compareSync",
+			"compare",
+			"getRounds"
+		],
+		specifiers: ["bcrypt"]
+	},
+	"node-rs-bcrypt": {
+		factory: "nodeRsBcrypt()",
+		names: [
+			"DEFAULT_COST",
+			"genSaltSync",
+			"genSalt",
+			"hashSync",
+			"hash",
+			"verifySync",
+			"verify",
+			"compareSync",
+			"compare"
+		],
+		specifiers: ["@node-rs/bcrypt"]
+	},
+	argon2: {
+		factory: "argon2()",
+		names: [
+			"argon2d",
+			"argon2i",
+			"argon2id",
+			"hash",
+			"verify",
+			"needsRehash"
+		],
+		specifiers: ["argon2"]
+	},
+	"node-rs-argon2": {
+		factory: "nodeRsArgon2()",
+		names: [
+			"Algorithm",
+			"Version",
+			"hash",
+			"hashSync",
+			"hashRaw",
+			"hashRawSync",
+			"verify",
+			"verifySync"
+		],
+		specifiers: ["@node-rs/argon2"]
+	},
+	"noble-scrypt": {
+		factory: "nobleScrypt()",
+		names: ["scrypt", "scryptAsync"],
+		specifiers: ["@noble/hashes/scrypt", "@noble/hashes/scrypt.js"]
+	},
+	"noble-pbkdf2": {
+		factory: "noblePbkdf2()",
+		names: ["pbkdf2", "pbkdf2Async"],
+		specifiers: ["@noble/hashes/pbkdf2", "@noble/hashes/pbkdf2.js"]
+	},
+	"noble-argon2": {
+		factory: "nobleArgon2()",
+		names: [
+			"argon2d",
+			"argon2i",
+			"argon2id",
+			"argon2dAsync",
+			"argon2iAsync",
+			"argon2idAsync"
+		],
+		specifiers: ["@noble/hashes/argon2", "@noble/hashes/argon2.js"]
+	}
+};
+const moduleOfSpecifier = new Map(Object.entries(packages).flatMap(([name, { specifiers }]) => specifiers.map((specifier) => [specifier, name])));
+/**
+* The name of the stand-in module for an import of a server layer, if it has
+* one: a package that hashes passwords, or `node:crypto`, whose module is the
+* layer's own with the stand-ins in it, `nodeCrypto`.
+*/
+function fastCryptoModuleOf(source) {
+	if (source === "crypto" || source === "node:crypto") return "node-crypto";
+	return moduleOfSpecifier.get(source);
+}
+/**
+* The code of a stand-in module by its name: for `node-crypto`, the layer's
+* `node:crypto`, `nodeCrypto`, with its `pbkdf2`, `scrypt` and `argon2` the
+* stand-ins. That is the file of the package's module in a browser, and
+* Node's own in a worker of Node.js (node-builtins.ts).
+*/
+function fastCryptoModule(name, nodeCrypto) {
+	const from = JSON.stringify(fastCryptoFile());
+	if (name === "node-crypto") {
+		const own = JSON.stringify(nodeCrypto);
+		const names = [
+			"pbkdf2",
+			"pbkdf2Sync",
+			"scrypt",
+			"scryptSync",
+			"argon2",
+			"argon2Sync"
+		];
+		const reexports = isBuiltin(nodeCrypto) ? `export const { ${Object.keys(process.getBuiltinModule("node:crypto")).filter((key) => /^[A-Za-z_$][\w$]*$/.test(key) && !names.includes(key)).join(", ")} } = own;\n` : `export * from ${own};\n`;
+		return `import own from ${own};\nimport { Buffer } from "node:buffer";\nimport { nodeCrypto } from ${from};\n` + reexports + `const fast = nodeCrypto(Buffer);\nexport const { ${names.join(", ")} } = fast;\nexport default { ...own, ...fast };\n`;
+	}
+	const standIn = packages[name];
+	if (!standIn) return;
+	return `import { ${standIn.factory.replace(/\(.*$/, "")} } from ${from};\nconst standIns = ${standIn.factory};\nexport const { ${standIn.names.join(", ")} } = standIns;\nexport default standIns;\n`;
+}
+/** The module of the setup file: Web Crypto's PBKDF2 a stand-in, or nothing. */
+function fastCryptoSetup(enabled) {
+	if (!enabled) return "export {};\n";
+	return `import { installWebCrypto } from ${JSON.stringify(fastCryptoFile())};\ninstallWebCrypto();\n`;
+}
+//#endregion
+export { fastCryptoFile, fastCryptoModule, fastCryptoModuleOf, fastCryptoSetup };

package/dist/flight.d.ts

@@ -0,0 +1,19 @@
+//#region src/flight.d.ts
+declare const rscFlightCodec: {
+  readonly server: readonly ["renderToReadableStream", "decodeReply", "decodeReplyFromAsyncIterable", "decodeAction", "decodeFormState", "createTemporaryReferenceSet", "registerServerReference", "registerClientReference", "createClientModuleProxy"];
+  readonly static: readonly ["prerender"];
+  readonly client: readonly ["createFromReadableStream", "encodeReply", "createTemporaryReferenceSet"];
+};
+type FlightEntry = keyof typeof rscFlightCodec;
+/** The adapters of one entry: a function for each of its exports. */
+type FlightAdapters<Entry extends FlightEntry> = Record<(typeof rscFlightCodec)[Entry][number], (...args: any[]) => unknown>;
+/**
+ * The module that the rsc layer gets for an entry of Next's codec. It has
+ * every export of the entry, as the installed `next` has it, and forwards it
+ * to the adapter that rsc.ts puts in `registry`. The lookup is deferred to
+ * the call, so a pre-bundled chunk can load before rsc.ts has. An export
+ * without an adapter throws when it is called.
+ */
+declare function flightBridge(entry: FlightEntry, exports: string[], nextVersion: string, registry: string): string;
+//#endregion
+export { FlightAdapters, FlightEntry, flightBridge, rscFlightCodec };

package/dist/flight.js

@@ -0,0 +1,42 @@
+//#region src/flight.ts
+const rscFlightCodec = {
+	server: [
+		"renderToReadableStream",
+		"decodeReply",
+		"decodeReplyFromAsyncIterable",
+		"decodeAction",
+		"decodeFormState",
+		"createTemporaryReferenceSet",
+		"registerServerReference",
+		"registerClientReference",
+		"createClientModuleProxy"
+	],
+	static: ["prerender"],
+	client: [
+		"createFromReadableStream",
+		"encodeReply",
+		"createTemporaryReferenceSet"
+	]
+};
+const owners = {
+	server: "flightServer",
+	static: "flightStatic",
+	client: "flightClient"
+};
+/**
+* The module that the rsc layer gets for an entry of Next's codec. It has
+* every export of the entry, as the installed `next` has it, and forwards it
+* to the adapter that rsc.ts puts in `registry`. The lookup is deferred to
+* the call, so a pre-bundled chunk can load before rsc.ts has. An export
+* without an adapter throws when it is called.
+*/
+function flightBridge(entry, exports, nextVersion, registry) {
+	const adapted = rscFlightCodec[entry];
+	return exports.map((name) => {
+		if (adapted.includes(name)) return `export const ${name} = (...args) => ${registry}.${owners[entry]}.${name}(...args);`;
+		const message = `vitest-plugin-rsc: \`${name}\` of Next's Flight codec is not supported in the rsc layer (next@${nextVersion}).`;
+		return `export const ${name} = () => { throw new Error(${JSON.stringify(message)}); };`;
+	}).join("\n");
+}
+//#endregion
+export { flightBridge, rscFlightCodec };

package/dist/form-submission.d.ts

@@ -0,0 +1,15 @@
+//#region src/form-submission.d.ts
+/**
+ * The encoding of a submission whose navigation `source` is: the
+ * `formenctype` of the button that submits the form, or the `enctype` of the
+ * form, which `form.submit()` submits itself.
+ */
+declare function enctypeOf(source: Element | null): string;
+/**
+ * The body of a form with the entries of `formData`, in the encoding
+ * `enctype`. A `Blob` with the type as a browser sends it, without a charset:
+ * Next's server tells a form from a Server Action by the exact type.
+ */
+declare function formBody(formData: FormData, enctype: string): FormData | Blob;
+//#endregion
+export { enctypeOf, formBody };

package/dist/form-submission.js

@@ -0,0 +1,27 @@
+//#region src/form-submission.ts
+/**
+* The encoding of a submission whose navigation `source` is: the
+* `formenctype` of the button that submits the form, or the `enctype` of the
+* form, which `form.submit()` submits itself.
+*/
+function enctypeOf(source) {
+	if (source instanceof HTMLFormElement) return source.enctype;
+	if (source instanceof HTMLButtonElement || source instanceof HTMLInputElement) {
+		if (source.hasAttribute("formenctype")) return source.formEnctype;
+		if (source.form) return source.form.enctype;
+	}
+	return "application/x-www-form-urlencoded";
+}
+/**
+* The body of a form with the entries of `formData`, in the encoding
+* `enctype`. A `Blob` with the type as a browser sends it, without a charset:
+* Next's server tells a form from a Server Action by the exact type.
+*/
+function formBody(formData, enctype) {
+	if (enctype === "multipart/form-data") return formData;
+	const entries = Array.from(formData, ([name, value]) => [name, typeof value === "string" ? value : value.name]);
+	if (enctype === "text/plain") return new Blob([entries.map(([name, value]) => `${name}=${value}\r\n`).join("")], { type: "text/plain" });
+	return new Blob([String(new URLSearchParams(entries))], { type: "application/x-www-form-urlencoded" });
+}
+//#endregion
+export { enctypeOf, formBody };

package/dist/from-page.d.ts

@@ -0,0 +1,5 @@
+//#region src/from-page.d.ts
+/** `input` and `init` of a request of the page, as the server's `Request` takes them. */
+declare function fromPage(input: RequestInfo | URL, init?: RequestInit): [RequestInfo | URL, RequestInit | undefined];
+//#endregion
+export { fromPage };

package/dist/from-page.js

@@ -0,0 +1,44 @@
+//#region src/from-page.ts
+/** `input` and `init` of a request of the page, as the server's `Request` takes them. */
+function fromPage(input, init) {
+	if (window.Request === globalThis.Request) return [input, init];
+	if (input instanceof window.Request) {
+		const { url, method, headers, body, signal, redirect, credentials } = input.body ? input.clone() : input;
+		init = {
+			method,
+			headers,
+			body,
+			signal,
+			redirect,
+			credentials,
+			...init
+		};
+		input = url;
+	}
+	input = new URL(String(input), window.location.href);
+	if (!init) return [input, init];
+	const headers = new Headers(init.headers ? [...new window.Headers(init.headers)] : void 0);
+	let { body, signal } = init;
+	if (body instanceof window.FormData || body instanceof window.Blob) {
+		const read = new window.Response(body);
+		const type = read.headers.get("content-type");
+		if (type && !headers.has("content-type")) headers.set("content-type", type);
+		body = read.body;
+	}
+	if (signal && !(signal instanceof AbortSignal)) {
+		const controller = new AbortController();
+		const page = signal;
+		if (page.aborted) controller.abort(page.reason);
+		else page.addEventListener("abort", () => controller.abort(page.reason), { once: true });
+		signal = controller.signal;
+	}
+	return [input, {
+		...init,
+		headers,
+		body,
+		signal,
+		...body ? { duplex: "half" } : {}
+	}];
+}
+//#endregion
+export { fromPage };

package/dist/globals.d.ts

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

package/dist/globals.js

@@ -0,0 +1,197 @@
+import { registry } from "./registry.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Buffer } from "node:buffer";
+import env from "virtual:vitest-plugin-rsc/next-env";
+import pageHost from "virtual:vitest-plugin-rsc/page-host";
+import { SequentialAsyncLocalStorage, asyncFunctionHooks, enterAmbientScope } from "@kasperpeulen/vitest-plugin-rsc/internal/async-local-storage";
+//#region src/globals.ts
+const { Request: NativeRequest, Response: NativeResponse, Headers } = globalThis;
+function headersOf(init, input) {
+	if (init?.headers) return new Headers(init.headers);
+	return new Headers(input instanceof NativeRequest ? input.headers : void 0);
+}
+var ServerRequest = class ServerRequest extends NativeRequest {
+	#headers;
+	constructor(input, init) {
+		const body = init?.body;
+		if (body && typeof body.on === "function" && typeof body.pipe === "function") init = {
+			...init,
+			body: new ReadableStream({
+				start(controller) {
+					body.on("data", (chunk) => controller.enqueue(typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk)));
+					body.on("end", () => controller.close());
+					body.on("error", (error) => controller.error(error));
+				},
+				cancel: (reason) => body.destroy?.(reason)
+			})
+		};
+		super(input, init?.body ? {
+			duplex: "half",
+			...init
+		} : init);
+		this.#headers = headersOf(init, input);
+		const contentType = super.headers.get("content-type");
+		if (contentType && !this.#headers.has("content-type")) this.#headers.set("content-type", contentType);
+	}
+	get headers() {
+		return this.#headers;
+	}
+	clone() {
+		return new ServerRequest(super.clone(), { headers: this.#headers });
+	}
+	static [Symbol.hasInstance](value) {
+		return Function.prototype[Symbol.hasInstance].call(this === ServerRequest ? NativeRequest : this, value);
+	}
+};
+var ServerResponse = class ServerResponse extends NativeResponse {
+	#headers;
+	constructor(body, init) {
+		super(body, init);
+		this.#headers = headersOf(init);
+		const contentType = super.headers.get("content-type");
+		if (contentType && !this.#headers.has("content-type")) this.#headers.set("content-type", contentType);
+	}
+	get headers() {
+		return this.#headers;
+	}
+	clone() {
+		const clone = super.clone();
+		return new ServerResponse(clone.body, {
+			status: clone.status,
+			statusText: clone.statusText,
+			headers: this.#headers
+		});
+	}
+	static json(data, init) {
+		const json = NativeResponse.json(data, init);
+		const headers = headersOf(init);
+		if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		return new ServerResponse(json.body, {
+			status: json.status,
+			statusText: json.statusText,
+			headers
+		});
+	}
+	static [Symbol.hasInstance](value) {
+		return Function.prototype[Symbol.hasInstance].call(this === ServerResponse ? NativeResponse : this, value);
+	}
+};
+registry.Request = ServerRequest;
+registry.Response = ServerResponse;
+registry.Headers = Headers;
+registry.serverDir = () => pageHost.serverDir;
+registry.enterRequestScope = enterAmbientScope;
+registry.openedByRequest = new SequentialAsyncLocalStorage();
+registry.asyncFunctionHooks = asyncFunctionHooks;
+const nativeQueueMicrotask = globalThis.queueMicrotask;
+registry.queueMicrotask = (callback) => nativeQueueMicrotask(SequentialAsyncLocalStorage.bind(callback));
+const renders = /* @__PURE__ */ new WeakMap();
+registry.performWork = (request, performWork) => {
+	let inStores = renders.get(request);
+	if (!inStores) renders.set(request, inStores = SequentialAsyncLocalStorage.snapshot());
+	inStores(performWork, request);
+};
+registry.fetch = (input, init) => pageHost.serverFetch(input, init);
+registry.network = (input, init) => pageHost.serverFetch(input, init);
+const scope = globalThis;
+scope.process ??= { env: {} };
+scope.process.env ??= {};
+for (const [name, value] of Object.entries(env)) scope.process.env[name] ??= value;
+scope.global ??= scope;
+scope.global.process ??= scope.process;
+scope.Buffer ??= Buffer;
+const takesUint8Array = (() => {
+	try {
+		return Buffer.from([0, 1]).indexOf(new Uint8Array([1])) === 1;
+	} catch {
+		return false;
+	}
+})();
+for (const method of takesUint8Array ? [] : ["indexOf", "lastIndexOf"]) {
+	const original = Buffer.prototype[method];
+	Buffer.prototype[method] = function(value, ...rest) {
+		if (value instanceof Uint8Array && !Buffer.isBuffer(value)) value = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+		return original.call(this, value, ...rest);
+	};
+}
+if (!Buffer.isEncoding("base64url")) {
+	const isBase64url = (encoding) => typeof encoding === "string" && encoding.toLowerCase() === "base64url";
+	const base64 = (text) => text.replaceAll("-", "+").replaceAll("_", "/");
+	const base64url = (text) => text.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+	const statics = Buffer;
+	const { from, byteLength, isEncoding } = statics;
+	statics.from = function(value, encoding, ...rest) {
+		return isBase64url(encoding) && typeof value === "string" ? from.call(this, base64(value), "base64") : from.call(this, value, encoding, ...rest);
+	};
+	statics.byteLength = function(value, encoding) {
+		return isBase64url(encoding) && typeof value === "string" ? byteLength.call(this, base64(value), "base64") : byteLength.call(this, value, encoding);
+	};
+	statics.isEncoding = (encoding) => isBase64url(encoding) || isEncoding.call(Buffer, encoding);
+	const prototype = Buffer.prototype;
+	const toString = prototype.toString;
+	const write = prototype.write;
+	prototype.toString = function(encoding, ...rest) {
+		return isBase64url(encoding) ? base64url(toString.apply(this, ["base64", ...rest])) : toString.apply(this, [encoding, ...rest]);
+	};
+	prototype.write = function(text, ...rest) {
+		const at = rest.findLastIndex((value) => typeof value === "string");
+		if (at === -1 || !isBase64url(rest[at])) return write.apply(this, [text, ...rest]);
+		const args = [...rest];
+		args[at] = "base64";
+		return write.apply(this, [base64(text), ...args]);
+	};
+}
+scope.AsyncLocalStorage ??= AsyncLocalStorage;
+const immediates = /* @__PURE__ */ new Map();
+function immediate(callback, args) {
+	const id = Symbol("immediate");
+	const cancel = pageHost.serverImmediate(() => {
+		immediates.delete(id);
+		callback(...args);
+	});
+	immediates.set(id, cancel);
+	return id;
+}
+function clearImmediateOf(id) {
+	immediates.get(id)?.();
+	return immediates.delete(id);
+}
+{
+	const { process } = scope;
+	process.cwd ??= () => "/";
+	process.on ??= () => process;
+	process.off ??= () => process;
+	process.nextTick ??= (callback, ...args) => queueMicrotask(() => callback(...args));
+	process.hrtime ??= Object.assign(() => [0, 0], { bigint: () => BigInt(Math.round(performance.now() * 1e6)) });
+	const nativeSetTimeout = globalThis.setTimeout;
+	const nativeClearTimeout = globalThis.clearTimeout;
+	registry.setImmediate = (callback, ...args) => pageHost.immediatesOfRuntime || registry.speedFeatures?.immediates ? immediate(callback, args) : nativeSetTimeout(callback, 0, ...args);
+	registry.clearImmediate = (id) => typeof id === "symbol" ? clearImmediateOf(id) : nativeClearTimeout(id);
+	registry.setTimeout = (callback, delay, ...args) => registry.speedFeatures?.immediates && !(Number(delay) > 0) && typeof callback === "function" && globalThis.setTimeout === nativeSetTimeout ? immediate(callback, args) : globalThis.setTimeout(callback, delay, ...args);
+	registry.clearTimeout = (id) => typeof id === "symbol" ? clearImmediateOf(id) : globalThis.clearTimeout(id);
+	const latin1 = (bytes) => {
+		let text = "";
+		for (let at = 0; at < bytes.length; at += 8192) text += String.fromCharCode(...bytes.subarray(at, at + 8192));
+		return text;
+	};
+	const utf8 = new TextDecoder("utf-8");
+	const ucs2 = new TextDecoder("utf-16le");
+	const decoders = {
+		latin1,
+		ascii: latin1,
+		utf8: (bytes) => utf8.decode(bytes),
+		ucs2: (bytes) => ucs2.decode(bytes)
+	};
+	for (const [encoding, decode] of Object.entries(decoders)) {
+		if (`${encoding}Slice` in Uint8Array.prototype) continue;
+		Object.defineProperty(Uint8Array.prototype, `${encoding}Slice`, {
+			configurable: true,
+			writable: true,
+			value(start, end) {
+				return decode(this.subarray(start, end));
+			}
+		});
+	}
+}
+//#endregion
+export {};

package/dist/host-document.d.ts

@@ -0,0 +1,26 @@
+//#region src/host-document.d.ts
+type NavigateEvent = Event & {
+  navigationType: "push" | "replace" | "reload" | "traverse";
+  destination: {
+    url: string;
+    sameDocument: boolean;
+  };
+  hashChange: boolean;
+  formData: FormData | null;
+  downloadRequest: string | null;
+  sourceElement: Element | null;
+};
+/** Says whether a browser context of the app is open: browser-context.ts does. */
+declare function appHasNavigations(open: boolean): void;
+/**
+ * Keeps the host's document while the host renders components outside a
+ * browser context of the app: a link or a form that would load another
+ * document is stopped, and `report` hears of it with the URL it would load.
+ * By default `reportError()` gets an error that says why. A declared
+ * download, like `<a download>`, is the browser's, and while a context is
+ * open, the app has the navigations. Until the function it returns is
+ * called.
+ */
+declare function keepHostDocument(report?: (url: URL) => void): () => void;
+//#endregion
+export { NavigateEvent, appHasNavigations, keepHostDocument };

package/dist/host-document.js

@@ -0,0 +1,34 @@
+import pageHost from "virtual:vitest-plugin-rsc/page-host";
+//#region src/host-document.ts
+let inContext = false;
+/** Says whether a browser context of the app is open: browser-context.ts does. */
+function appHasNavigations(open) {
+	inContext = open;
+}
+/**
+* Keeps the host's document while the host renders components outside a
+* browser context of the app: a link or a form that would load another
+* document is stopped, and `report` hears of it with the URL it would load.
+* By default `reportError()` gets an error that says why. A declared
+* download, like `<a download>`, is the browser's, and while a context is
+* open, the app has the navigations. Until the function it returns is
+* called.
+*/
+function keepHostDocument(report = reportLoad) {
+	const { navigation } = pageHost;
+	const keep = (event) => {
+		if (inContext || event.defaultPrevented) return;
+		const { destination, hashChange, downloadRequest } = event;
+		if (destination.sameDocument || hashChange || !event.cancelable) return;
+		if (downloadRequest !== null || destination.url === window.location.href) return;
+		event.preventDefault();
+		report(new URL(destination.url));
+	};
+	navigation?.addEventListener("navigate", keep);
+	return () => navigation?.removeEventListener("navigate", keep);
+}
+function reportLoad(url) {
+	reportError(/* @__PURE__ */ new Error(`vitest-plugin-rsc: a link or a form navigated to ${url.href}, which would load another document in place of the host's. The host renders it outside a browser context of the app, where there is no router of Next's: the host's document stays.`));
+}
+//#endregion
+export { appHasNavigations, keepHostDocument };

package/dist/host-return-shared.d.ts

@@ -0,0 +1,5 @@
+//#region src/host-return-shared.d.ts
+declare const hostKey = "vitest-plugin-rsc:host";
+declare const topLevelHostKey = "vitest-plugin-rsc:host-top-level";
+//#endregion
+export { hostKey, topLevelHostKey };

package/dist/host-return-shared.js

@@ -0,0 +1,5 @@
+//#region src/host-return-shared.ts
+const hostKey = "vitest-plugin-rsc:host";
+const topLevelHostKey = "vitest-plugin-rsc:host-top-level";
+//#endregion
+export { hostKey, topLevelHostKey };

package/dist/host-return.d.ts

@@ -0,0 +1,5 @@
+//#region src/host-return.d.ts
+/** Keeps `url`, the URL of the host's document, as the one a page that opens now goes back to. */
+declare function rememberHost(url: string): void;
+//#endregion
+export { rememberHost };

package/dist/host-return.js

@@ -0,0 +1,16 @@
+import { buildDirectory } from "./built-files.js";
+import { hostKey, topLevelHostKey } from "./host-return-shared.js";
+//#region src/host-return.ts
+const ownStorages = ["sessionStorage", "localStorage"].map((name) => Object.getOwnPropertyDescriptor(window, name)?.get);
+/** Keeps `url`, the URL of the host's document, as the one a page that opens now goes back to. */
+function rememberHost(url) {
+	if (!buildDirectory) return;
+	const [session, local] = ownStorages.map((get) => get?.call(window));
+	try {
+		session?.setItem(hostKey, url);
+		session?.setItem(topLevelHostKey, window.top === window ? "1" : "0");
+		local?.setItem(hostKey, url);
+	} catch {}
+}
+//#endregion
+export { rememberHost };