vinext 1.0.1 → 1.2.0

package/dist/plugins/worker-use-server.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from "vite";
+//#region src/plugins/worker-use-server.d.ts
+type RscPluginModule = typeof import("@vitejs/plugin-rsc");
+/**
+ * Replace `"use server"` modules in browser Web Worker bundles with Server
+ * Function reference proxies.
+ *
+ * Vite bundles every worker in a fresh plugin container built from
+ * `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+ * sees worker modules in production builds and the module bodies would be
+ * emitted verbatim. Next.js compiles workers as part of the browser graph,
+ * where `"use server"` exports become `createServerReference(...)` proxies.
+ * This mirrors the client-environment branch of `rsc:use-server` with the
+ * same reference keys, without claiming references.
+ *
+ * The worker realm has no router to dispatch Server Function calls. Next.js's
+ * `callServer` dispatches inside `startTransition`, so the dispatch error is
+ * reported globally and the call's promise never settles; the worker
+ * references reproduce that instead of reaching the server.
+ */
+export declare function createWorkerUseServerPlugins(options: {
+  rscPluginModule: Promise<RscPluginModule>;
+  rscPluginPath: string;
+}): Promise<Plugin[]>;
+//#endregion

package/dist/plugins/worker-use-server.js

@@ -0,0 +1,129 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { escapeRegExp } from "../utils/regex.js";
+import { magicStringTransformResult } from "./transform-result.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { parseAstAsync, transformWithOxc } from "vite";
+//#region src/plugins/worker-use-server.ts
+const WORKER_REFERENCE_RUNTIME_ID = "\0vinext:worker-server-reference";
+const WORKER_REFERENCE_RUNTIME_ID_RE = /^\0vinext:worker-server-reference$/;
+function workerReferenceRuntime(browserRuntime) {
+	return `import { createServerReference } from ${JSON.stringify(browserRuntime)};
+
+function callServer() {
+  return new Promise(() => {
+    reportError(new Error("Server Functions cannot be called from a browser Web Worker."));
+  });
+}
+
+export function createWorkerServerReference(id, name) {
+  return createServerReference(id, callServer, undefined, undefined, name);
+}
+`;
+}
+/** A module-local binding that cannot collide with any name in `code`. */
+function uniqueBinding(code, base) {
+	let binding = base;
+	while (code.includes(binding)) binding += "_";
+	return binding;
+}
+function isPlainFilePath(id) {
+	return !/[\0?#]/.test(id) && fs.existsSync(id);
+}
+function withPositionedError(ctx, run) {
+	return Promise.resolve().then(run).catch((error) => {
+		if (error instanceof Error && "pos" in error && typeof error.pos === "number") ctx.error(error.message, error.pos);
+		throw error;
+	});
+}
+/**
+* Replace `"use server"` modules in browser Web Worker bundles with Server
+* Function reference proxies.
+*
+* Vite bundles every worker in a fresh plugin container built from
+* `worker.plugins`, so @vitejs/plugin-rsc's `rsc:use-server` transform never
+* sees worker modules in production builds and the module bodies would be
+* emitted verbatim. Next.js compiles workers as part of the browser graph,
+* where `"use server"` exports become `createServerReference(...)` proxies.
+* This mirrors the client-environment branch of `rsc:use-server` with the
+* same reference keys, without claiming references.
+*
+* The worker realm has no router to dispatch Server Function calls. Next.js's
+* `callServer` dispatches inside `startTransition`, so the dispatch error is
+* reported globally and the call's promise never settles; the worker
+* references reproduce that instead of reaching the server.
+*/
+async function createWorkerUseServerPlugins(options) {
+	const rscRequire = createRequire(options.rscPluginPath);
+	const importRscModule = (specifier) => import(pathToFileURL(rscRequire.resolve(specifier)).href);
+	const browserRuntime = pathToFileURL(rscRequire.resolve("@vitejs/plugin-rsc/react/browser")).href;
+	const [transforms, rscCore] = await Promise.all([importRscModule("@vitejs/plugin-rsc/transforms"), importRscModule("@vitejs/plugin-rsc/core/plugin")]);
+	let manager;
+	const useServerPlugin = {
+		name: "vinext:worker-use-server",
+		async configResolved(config) {
+			// @vitejs/plugin-rsc's plugin API (and its reference manager) lives.
+			const mainConfig = config.mainConfig;
+			manager = (await options.rscPluginModule).getPluginApi(mainConfig ?? config)?.manager;
+		},
+		resolveId: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: (source) => source
+		},
+		load: {
+			filter: { id: WORKER_REFERENCE_RUNTIME_ID_RE },
+			handler: () => workerReferenceRuntime(browserRuntime)
+		},
+		transform: {
+			filter: { code: "use server" },
+			async handler(code, id) {
+				let ast = await parseAstAsync(code);
+				if (!transforms.hasDirective(ast.body, "use server")) return null;
+				if (!manager) throw new Error("vinext: cannot compile a \"use server\" module in a Web Worker without @vitejs/plugin-rsc.");
+				const expanded = await withPositionedError(this, () => transforms.transformExpandExportAll({
+					code,
+					ast,
+					importer: id,
+					resolve: async (source, importer) => (await this.resolve(source, importer))?.id,
+					load: async (target) => {
+						if (!isPlainFilePath(target)) throw new Error(`vinext: a "use server" module imported by a Web Worker cannot \`export *\` from ${JSON.stringify(target)}; re-export its names explicitly.`);
+						this.addWatchFile(target);
+						const source = await fs.promises.readFile(target, "utf-8");
+						return parseAstAsync((await transformWithOxc(source, target, { sourcemap: false })).code);
+					}
+				}));
+				if (expanded) {
+					code = expanded.code;
+					ast = await parseAstAsync(code);
+				}
+				const { referenceKey } = manager.serverReferences.resolve(id, "rsc");
+				const runtime = uniqueBinding(code, "$$vinextWorkerReference");
+				const result = await withPositionedError(this, () => transforms.transformDirectiveProxyExport(ast, {
+					code,
+					directive: "use server",
+					rejectNonAsyncFunction: true,
+					runtime: (name) => `${runtime}(${JSON.stringify(`${referenceKey}#${name}`)}, ${JSON.stringify(name)})`
+				}));
+				if (!result?.output.hasChanged()) return null;
+				result.output.prepend(`import { createWorkerServerReference as ${runtime} } from ${JSON.stringify(WORKER_REFERENCE_RUNTIME_ID)};\n`);
+				return magicStringTransformResult(result.output);
+			}
+		}
+	};
+	const patchHook = rscCore.default().find((plugin) => plugin.name === "rsc:patch-react-server-dom-webpack")?.transform;
+	if (!patchHook || typeof patchHook !== "object") throw new Error("vinext: @vitejs/plugin-rsc no longer exposes its Flight client patch plugin.");
+	const flightClientDir = path.dirname(rscRequire.resolve("@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"));
+	return [{
+		name: "vinext:worker-patch-react-server-dom",
+		transform: {
+			filter: {
+				id: new RegExp(`^${escapeRegExp(`${toSlash(flightClientDir)}/`)}`),
+				code: "__webpack_require__"
+			},
+			handler: patchHook.handler
+		}
+	}, useServerPlugin];
+}
+//#endregion
+export { createWorkerUseServerPlugins };

package/dist/routing/file-matcher.d.ts

@@ -1,4 +1,5 @@
 //#region src/routing/file-matcher.d.ts
+export declare const DEFAULT_PAGE_EXTENSIONS: readonly ["tsx", "ts", "jsx", "js"];
 export declare function normalizePageExtensions(pageExtensions?: readonly string[] | null): string[];
 export type ValidFileMatcher = {
   extensions: string[];

package/dist/routing/file-matcher.js

@@ -152,4 +152,4 @@ async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	})) yield toSlash(file);
 }
 //#endregion
-export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };
+export { DEFAULT_PAGE_EXTENSIONS, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/server/api-handler.d.ts

@@ -13,5 +13,6 @@ export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMess
   trustedRevalidateOrigin?: string;
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
+  skipTrailingSlashRedirect?: boolean;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -11,6 +11,7 @@ import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
 import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { signalFromNodeResponse } from "./node-response-signal.js";
 import { Buffer } from "node:buffer";
 import { decode } from "node:querystring";
 //#region src/server/api-handler.ts
@@ -89,7 +90,7 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, url, params, nextConfig) {
+function createEdgeApiRequest(req, res, url, params, nextConfig) {
 	const headers = new Headers();
 	for (const [name, value] of Object.entries(req.headers)) {
 		if (name.startsWith(":")) continue;
@@ -103,10 +104,12 @@ function createEdgeApiRequest(req, url, params, nextConfig) {
 	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
 	const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 	requestUrl.search = urlQueryToSearchParams(query).toString();
-	const body = readEdgeRequestBody(req);
+	const signal = signalFromNodeResponse(res);
+	const body = signal.aborted ? void 0 : readEdgeRequestBody(req);
 	const init = {
 		headers,
-		method: req.method
+		method: req.method,
+		signal
 	};
 	if (body) {
 		init.body = body;
@@ -138,12 +141,17 @@ function waitForWritableDrain(res) {
 		res.once("close", onClose);
 	});
 }
-async function writeEdgeApiResponseBody(res, body) {
+async function writeEdgeApiResponseBody(res, body, signal) {
 	if (!body) {
 		res.end();
 		return;
 	}
 	const reader = body.getReader();
+	const cancel = () => {
+		reader.cancel(signal.reason).catch(() => {});
+	};
+	if (signal.aborted) cancel();
+	else signal.addEventListener("abort", cancel, { once: true });
 	try {
 		while (true) {
 			const result = await reader.read();
@@ -151,11 +159,13 @@ async function writeEdgeApiResponseBody(res, body) {
 			if (result.value.byteLength === 0) continue;
 			if (!res.write(Buffer.from(result.value))) await waitForWritableDrain(res);
 		}
-		res.end();
+		if (!signal.aborted) res.end();
 	} catch (error) {
+		if (signal.aborted) return;
 		res.destroy(error instanceof Error ? error : new Error(String(error)));
 		throw error;
 	} finally {
+		signal.removeEventListener("abort", cancel);
 		reader.releaseLock();
 	}
 }
@@ -224,10 +234,11 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, url, params, nextConfig), nextConfig ? { nextConfig: {
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
-				trailingSlash: nextConfig.trailingSlash
+				trailingSlash: nextConfig.trailingSlash,
+				skipTrailingSlashRedirect: nextConfig.skipTrailingSlashRedirect
 			} } : void 0);
 			const handlerResponse = await tracePagesApiHandler(route.pattern, () => apiModule.default(nextRequest));
 			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");
@@ -239,7 +250,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				if (name !== "set-cookie") res.setHeader(name, value);
 			});
 			if (setCookieHeaders.length) res.setHeader("set-cookie", setCookieHeaders);
-			await writeEdgeApiResponseBody(res, response.body);
+			await writeEdgeApiResponseBody(res, response.body, nextRequest.signal);
 			return true;
 		}
 		const handler = apiModule.default;

package/dist/server/app-browser-action-result.d.ts

@@ -25,7 +25,7 @@ export declare function isServerActionResult<TRoot>(value: unknown): value is Ap
 export declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 export declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 export declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
-export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): Promise<unknown>;
 export declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
 export declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
 export type ServerActionResultResponseFactsInput = {

package/dist/server/app-browser-action-result.js

@@ -41,8 +41,15 @@ function createServerActionHttpFallbackError(status) {
 	const error = /* @__PURE__ */ new Error(status === 404 ? "NEXT_NOT_FOUND" : `NEXT_HTTP_ERROR_FALLBACK;${status}`);
 	return Object.assign(error, { digest });
 }
-function normalizeServerActionThrownValue(data, responseStatus) {
-	return createServerActionHttpFallbackError(responseStatus) ?? data;
+async function normalizeServerActionThrownValue(data, responseStatus) {
+	const fallbackError = createServerActionHttpFallbackError(responseStatus);
+	if (fallbackError) return fallbackError;
+	try {
+		await data;
+	} catch (error) {
+		return error;
+	}
+	return data;
 }
 function shouldSyncServerActionHttpFallbackHead(result) {
 	if (!isServerActionResult(result) || result.root !== void 0) return false;

package/dist/server/app-browser-entry.js

@@ -1,12 +1,12 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { addBasePathToPathname, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { matchRoutePattern } from "../routing/route-pattern.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
 import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { getBfcacheIdMapContext, getNavigationContext, setNavigationContext } from "../shims/navigation-context-state.js";
 import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
@@ -362,22 +362,22 @@ function createActionInitiationSnapshot() {
 }
 function createNavigationCommitEffect(options) {
 	const { activeRoutePaths, bfcacheIds, href, historyUpdateMode, navId, params, previousNextUrl, targetHistoryIndex } = options;
-	return () => {
+	return ({ keepCurrentUrl, releaseSnapshot }) => {
 		if (!browserNavigationController.isCurrentNavigation(navId)) {
-			commitClientNavigationState(void 0, { releaseSnapshot: true });
+			commitClientNavigationState(void 0, { releaseSnapshot });
 			return;
 		}
 		historyController.commitNavigationHistory({
 			activeRoutePaths,
 			bfcacheIds,
 			href,
-			historyUpdateMode,
+			historyUpdateMode: keepCurrentUrl ? void 0 : historyUpdateMode,
 			previousNextUrl,
 			stageClientParams: () => stageClientParams(params),
 			targetHistoryIndex
 		});
 		clearAppNavigationFailureTarget(href);
-		commitClientNavigationState(navId);
+		commitClientNavigationState(navId, { releaseSnapshot });
 	};
 }
 async function renderNavigationPayload(options) {
@@ -1505,7 +1505,11 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		},
 		preparePrefetchResponse: (response) => decodeAppElementsPromise(createFromFetch(Promise.resolve(response))),
 		claimCurrentHistoryTreeSnapshot: (historyUpdateMode, previousHistoryState) => historyController.claimCurrentHistoryTreeSnapshot(historyUpdateMode, previousHistoryState),
-		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState)
+		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState),
+		discardPendingNavigation: () => {
+			if (browserNavigationController.discardPendingNavigation(historyController.readCurrentTreeSnapshot())) navigationAbortCoordinator.abortActive();
+		},
+		flushCommittingNavigationUrl: () => browserNavigationController.flushCommittingNavigationUrl()
 	});
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),

package/dist/server/app-browser-history-controller.d.ts

@@ -79,6 +79,8 @@ export declare class AppBrowserHistoryController {
   beginCacheInvalidationGuard(): () => void;
   invalidateRestorableClientState(): void;
   rememberHistoryStateSnapshot(state: AppRouterState): void;
+  /** The router state of the most recently committed render, if any. */
+  readCurrentTreeSnapshot(): AppRouterState | null;
   isCurrentExternalHistoryTree(historyState: unknown): boolean;
   /** Records the raw/hash history entry that now claims the live tree. */
   claimCurrentHistoryTreeSnapshot(historyUpdateMode: HistoryUpdateMode, previousHistoryState: unknown): void;

package/dist/server/app-browser-history-controller.js

@@ -96,6 +96,9 @@ var AppBrowserHistoryController = class {
 		this.#treeSnapshotIdPendingFreshState = historyTreeSnapshotId !== null && this.#treeSnapshots.has(historyTreeSnapshotId) ? historyTreeSnapshotId : null;
 	}
 	rememberHistoryStateSnapshot(state) {
+		const previousState = this.readCurrentTreeSnapshot();
+		const previousOperation = previousState?.activeOperation;
+		if (previousState && previousOperation?.navigationCommitKind === "detached" && state.activeOperation?.navigationCommitKind === "authoritative" && state.activeOperation.navigationId === previousOperation.navigationId) this.#restorableClientState.replaceHistoryStateSnapshots(previousState, state);
 		this.#restorableClientState.rememberHistoryStateSnapshot({
 			historyIndex: this.#currentHistoryTraversalIndex,
 			state
@@ -109,6 +112,11 @@ var AppBrowserHistoryController = class {
 		if (previousTreeSnapshotId !== null && previousTreeSnapshotId !== treeSnapshotId && !this.#treeSnapshotClaimCounts.has(previousTreeSnapshotId)) this.#treeSnapshots.delete(previousTreeSnapshotId);
 		if (historyTreeSnapshotId !== treeSnapshotId) this.#replaceHistoryState(createHistoryStateWithTreeSnapshotId(this.#readHistoryState(), treeSnapshotId));
 	}
+	/** The router state of the most recently committed render, if any. */
+	readCurrentTreeSnapshot() {
+		if (this.#currentTreeSnapshotId === null) return null;
+		return this.#treeSnapshots.get(this.#currentTreeSnapshotId) ?? null;
+	}
 	isCurrentExternalHistoryTree(historyState) {
 		const treeSnapshotId = readHistoryStateTreeSnapshotId(historyState);
 		return treeSnapshotId !== null && treeSnapshotId === this.#currentTreeSnapshotId;

package/dist/server/app-browser-interception-context.js

@@ -1,5 +1,6 @@
-import { splitPathnameForRouteMatch } from "../routing/utils.js";
+import { normalizePathnameForRouteMatch, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
+import { normalizePath } from "./normalize-path.js";
 import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 //#region src/server/app-browser-interception-context.ts
 /**
@@ -37,9 +38,32 @@ function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
 	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
 		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
 		if (matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) return currentPathname;
-		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return currentMatchedPathname;
+		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return encodeMatchedPathname(currentMatchedPathname);
 	}
 	return null;
 }
+/**
+* The matched route pathname is the matched URL decoded once per segment, with
+* path delimiters (and literal `%2F`-style text) re-escaped. The server matches
+* the context on its raw segments, so undo that: keep the escaped delimiters and
+* encode every other `%`, then let the URL parser encode the rest (`café`
+* becomes `caf%C3%A9`). An escaped ASCII character comes back unescaped (`%61`
+* as `a`), like Next.js's `Next-Url`, which it builds from the router tree's
+* canonical params; both spellings match the same params. `%252F` is
+* ambiguous, since both a literal `%2F` and a literal `%252F` produce it. That
+* case, and a result that does not reproduce the same matched pathname because
+* the URL parser changed it (stripping a control character, say), navigate
+* without interception instead of naming a different source.
+*/
+function encodeMatchedPathname(pathname) {
+	if (/%25(?:2f|23|3f|5c)/i.test(pathname)) return null;
+	let encoded;
+	try {
+		encoded = new URL(pathname.replace(/%(?!(?:25)?(?:2f|23|3f|5c))/gi, "%25"), "http://n").pathname;
+	} catch {
+		return null;
+	}
+	return normalizePath(normalizePathnameForRouteMatch(encoded)) === pathname ? encoded : null;
+}
 //#endregion
 export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

package/dist/server/app-browser-navigation-controller.d.ts

@@ -17,7 +17,10 @@ export type PendingBrowserRouterState = {
 };
 export type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
-type BrowserNavigationCommitEffect = () => void;
+type BrowserNavigationCommitEffect = (options: {
+  keepCurrentUrl: boolean;
+  releaseSnapshot: boolean;
+}) => void;
 type BrowserNavigationCommitEffectFactory = (options: {
   activeRoutePaths: readonly string[];
   bfcacheIds: Readonly<Record<string, string>>;
@@ -78,6 +81,8 @@ type BrowserNavigationController = {
   attachBrowserRouterState(setter: Dispatch<AppRouterState | Promise<AppRouterState>>, stateRef: BrowserRouterStateRef): () => void;
   beginPendingBrowserRouterState(): PendingBrowserRouterState;
   finalizeNavigation(navId: number, pending: PendingBrowserRouterState | null | undefined): void;
+  discardPendingNavigation(visibleState: AppRouterState | null): boolean;
+  flushCommittingNavigationUrl(): void;
   restoreHistorySnapshotVisibleState(options: {
     restoreCopiedExternalHistoryEntry?: boolean;
     beforeCommit?: () => void;
@@ -100,6 +105,7 @@ type BrowserNavigationController = {
    * navigation would otherwise be lost.
    */
   drainPrePaintEffects(renderId: number): void;
+  beginNavigationRenderCommit(renderId: number): void;
   commitNavigationRender(renderId: number): void;
   clearCommittedNavigationFailureTargets(renderId: number): void;
   NavigationCommitSignal(this: void, { renderId, children }: {