@qzsy/vinext 0.1.7

package/dist/shims/unrecognized-action-error.js

@@ -0,0 +1,39 @@
+//#region src/shims/unrecognized-action-error.ts
+/**
+* Unrecognized server-action errors.
+*
+* When a server action call fails because the server did not recognize the
+* action id, the client bundle and the server are typically from different
+* deployments and a hard reload is required.
+*
+* This module is intentionally dependency-free: both the `next/navigation`
+* shim (which re-exports these for user code) and vinext's client
+* server-action dispatcher import `UnrecognizedActionError` from here, so the
+* `instanceof` check inside `unstable_isUnrecognizedActionError` resolves
+* against a single shared class.
+*
+* Ported 1:1 from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/unrecognized-action-error.ts
+*/
+/**
+* Error class for unrecognized server-action calls. Thrown by vinext's client
+* server-action dispatcher when the server reports the requested action id as
+* unknown (the `x-nextjs-action-not-found` response header).
+*/
+var UnrecognizedActionError = class extends Error {
+	constructor(...args) {
+		super(...args);
+		this.name = "UnrecognizedActionError";
+	}
+};
+/**
+* Returns true if the error came from a server action whose id was not
+* recognized by the server. Useful inside `catch` blocks that surround
+* `await myAction(...)` calls; reloading the page generally fixes the
+* underlying client/server deployment mismatch.
+*/
+function unstable_isUnrecognizedActionError(error) {
+	return !!(error && typeof error === "object" && error instanceof UnrecognizedActionError);
+}
+//#endregion
+export { UnrecognizedActionError, unstable_isUnrecognizedActionError };

package/dist/shims/url-safety.d.ts

@@ -0,0 +1,34 @@
+//#region src/shims/url-safety.d.ts
+/**
+ * Shared URL safety utilities for Link, Form, and navigation shims.
+ *
+ * Centralizes dangerous URI scheme detection so all components and
+ * navigation functions use the same validation logic.
+ */
+declare const DANGEROUS_URL_BLOCK_MESSAGE = "Next.js has blocked a javascript: URL as a security precaution.";
+declare function isDangerousScheme(url: string): boolean;
+/**
+ * Emit a `console.error` matching Next.js's blocked-navigation message.
+ *
+ * Next.js's `router.push` / `router.replace` / `router.prefetch` (and the
+ * Pages Router equivalents) throw an `Error` when the URL has a dangerous
+ * scheme. In the browser, React's event-handler runtime catches that throw
+ * and reports it through `console.error`, which is what the Next.js E2E
+ * `test/e2e/app-dir/javascript-urls` suite asserts on.
+ *
+ * Vinext's navigation guards run synchronously inside async event handlers
+ * (e.g. Link's `void handleClick(event)`), so a raw throw is dropped on the
+ * floor instead of bubbling up to React. Emitting the same `console.error`
+ * explicitly keeps observable behaviour aligned with Next.js — the test
+ * matcher uses `.includes("has blocked a javascript: URL as a security
+ * precaution.")` so any message containing that phrase satisfies it.
+ *
+ * Source reference (Next.js):
+ *   packages/next/src/client/components/segment-cache/navigation.ts:537
+ *   packages/next/src/client/components/app-router-instance.ts:345,402,442,460
+ *   packages/next/src/shared/lib/router/router.ts:1025,1057
+ */
+declare function reportBlockedDangerousNavigation(): void;
+declare function assertSafeNavigationUrl(url: string): void;
+//#endregion
+export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };

package/dist/shims/url-safety.js

@@ -0,0 +1,70 @@
+//#region src/shims/url-safety.ts
+/**
+* Shared URL safety utilities for Link, Form, and navigation shims.
+*
+* Centralizes dangerous URI scheme detection so all components and
+* navigation functions use the same validation logic.
+*/
+/**
+* Detect dangerous URI schemes that should never be navigated to.
+*
+* Adapted from Next.js's javascript URL detector:
+* packages/next/src/client/lib/javascript-url.ts
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/client/lib/javascript-url.ts
+*
+* URL parsing ignores leading C0 control characters / spaces, and treats
+* embedded tab/newline characters in the scheme as insignificant. We mirror
+* that behavior here so obfuscated values like `java\nscript:` and
+* `\x00javascript:` are still blocked.
+*
+* Vinext intentionally extends this handling to `data:` and `vbscript:` too,
+* since both are also dangerous navigation targets.
+*/
+const LEADING_IGNORED = "[\\u0000-\\u001F \\u200B\\uFEFF]*";
+const SCHEME_IGNORED = "[\\r\\n\\t]*";
+function buildDangerousSchemeRegex(scheme) {
+	const chars = scheme.split("").join(SCHEME_IGNORED);
+	return new RegExp(`^${LEADING_IGNORED}${chars}${SCHEME_IGNORED}:`, "i");
+}
+const DANGEROUS_SCHEME_RES = [
+	buildDangerousSchemeRegex("javascript"),
+	buildDangerousSchemeRegex("data"),
+	buildDangerousSchemeRegex("vbscript")
+];
+const DANGEROUS_URL_BLOCK_MESSAGE = "Next.js has blocked a javascript: URL as a security precaution.";
+function isDangerousScheme(url) {
+	const str = "" + url;
+	return DANGEROUS_SCHEME_RES.some((re) => re.test(str));
+}
+/**
+* Emit a `console.error` matching Next.js's blocked-navigation message.
+*
+* Next.js's `router.push` / `router.replace` / `router.prefetch` (and the
+* Pages Router equivalents) throw an `Error` when the URL has a dangerous
+* scheme. In the browser, React's event-handler runtime catches that throw
+* and reports it through `console.error`, which is what the Next.js E2E
+* `test/e2e/app-dir/javascript-urls` suite asserts on.
+*
+* Vinext's navigation guards run synchronously inside async event handlers
+* (e.g. Link's `void handleClick(event)`), so a raw throw is dropped on the
+* floor instead of bubbling up to React. Emitting the same `console.error`
+* explicitly keeps observable behaviour aligned with Next.js — the test
+* matcher uses `.includes("has blocked a javascript: URL as a security
+* precaution.")` so any message containing that phrase satisfies it.
+*
+* Source reference (Next.js):
+*   packages/next/src/client/components/segment-cache/navigation.ts:537
+*   packages/next/src/client/components/app-router-instance.ts:345,402,442,460
+*   packages/next/src/shared/lib/router/router.ts:1025,1057
+*/
+function reportBlockedDangerousNavigation() {
+	console.error(DANGEROUS_URL_BLOCK_MESSAGE);
+}
+function assertSafeNavigationUrl(url) {
+	if (isDangerousScheme(url)) {
+		reportBlockedDangerousNavigation();
+		throw new Error(DANGEROUS_URL_BLOCK_MESSAGE);
+	}
+}
+//#endregion
+export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };

package/dist/shims/url-utils.d.ts

@@ -0,0 +1,51 @@
+//#region src/shims/url-utils.d.ts
+declare function isAbsoluteUrl(url: string): boolean;
+declare function isAbsoluteOrProtocolRelativeUrl(url: string): boolean;
+declare function getWindowOrigin(): string | null;
+/**
+ * If `url` is an absolute same-origin URL, return the local path
+ * (pathname + search + hash). Returns null for truly external URLs
+ * or on the server (where origin is unknown).
+ */
+declare function toSameOriginPath(url: string): string | null;
+/**
+ * If `url` is an absolute same-origin URL, return the app-relative path
+ * (basePath stripped from the pathname, if configured). Returns null for
+ * truly external URLs or on the server.
+ */
+declare function toSameOriginAppPath(url: string, basePath: string): string | null;
+/**
+ * Normalise the trailing slash of a local URL according to the
+ * `trailingSlash` config option in `next.config.js`. Used by the `<Link>`
+ * shim so that rendered `href` attributes match the canonical URL form
+ * (which is what the server-side redirect would otherwise enforce).
+ *
+ * Behaviour matches Next.js's client-side `normalizePathTrailingSlash`:
+ * packages/next/src/client/normalize-trailing-slash.ts
+ *
+ * - Absolute URLs (`http://`, `https://`, `//`) and non-local strings are
+ *   returned unchanged.
+ * - Paths whose final segment looks like a filename (`...\.ext`) have any
+ *   trailing slash stripped even when `trailingSlash: true`, mirroring the
+ *   `.well-known`-aware redirect rule shipped in `routes-manifest.json`.
+ * - Query strings and hash fragments are preserved verbatim.
+ * - Idempotent: already-canonical paths round-trip unchanged.
+ */
+declare function normalizePathTrailingSlash(path: string, trailingSlash: boolean): string;
+/**
+ * Prepend basePath to a local path for browser URLs / fetches.
+ */
+declare function withBasePath(path: string, basePath: string): string;
+/**
+ * Resolve a potentially relative href against the current URL.
+ * Handles: "#hash", "?query", "?query#hash", and relative paths.
+ */
+declare function resolveRelativeHref(href: string, currentUrl?: string, basePath?: string): string;
+/**
+ * Convert a local navigation target into the browser URL that should be used
+ * for history entries, fetches, and onNavigate callbacks.
+ */
+declare function toBrowserNavigationHref(href: string, currentUrl?: string, basePath?: string): string;
+declare function isHashOnlyBrowserUrlChange(href: string, currentHref: string, basePath?: string): boolean;
+//#endregion
+export { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath };

package/dist/shims/url-utils.js

@@ -0,0 +1,156 @@
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+//#region src/shims/url-utils.ts
+/**
+* Shared URL utilities for same-origin detection.
+*
+* Used by link.tsx, navigation.ts, and router.ts to normalize
+* same-origin absolute URLs to local paths for client-side navigation.
+*/
+const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+function isAbsoluteUrl(url) {
+	const firstChar = url.charCodeAt(0);
+	return (firstChar >= 65 && firstChar <= 90 || firstChar >= 97 && firstChar <= 122) && ABSOLUTE_URL_REGEX.test(url);
+}
+function isAbsoluteOrProtocolRelativeUrl(url) {
+	return isAbsoluteUrl(url) || url.startsWith("//");
+}
+function getWindowOrigin() {
+	if (typeof window === "undefined") return null;
+	const { origin, href } = window.location;
+	if (origin) return origin;
+	try {
+		return new URL(href).origin;
+	} catch {
+		return null;
+	}
+}
+/**
+* If `url` is an absolute same-origin URL, return the local path
+* (pathname + search + hash). Returns null for truly external URLs
+* or on the server (where origin is unknown).
+*/
+function toSameOriginPath(url) {
+	const origin = getWindowOrigin();
+	if (!origin) return null;
+	try {
+		const parsed = url.startsWith("//") ? new URL(url, origin) : new URL(url);
+		if (parsed.origin === origin) return parsed.pathname + parsed.search + parsed.hash;
+	} catch {}
+	return null;
+}
+/**
+* If `url` is an absolute same-origin URL, return the app-relative path
+* (basePath stripped from the pathname, if configured). Returns null for
+* truly external URLs or on the server.
+*/
+function toSameOriginAppPath(url, basePath) {
+	const localPath = toSameOriginPath(url);
+	if (localPath == null || !basePath) return localPath;
+	try {
+		const parsed = new URL(localPath, "http://vinext.local");
+		if (!hasBasePath(parsed.pathname, basePath)) return null;
+		return stripBasePath(parsed.pathname, basePath) + parsed.search + parsed.hash;
+	} catch {
+		return localPath;
+	}
+}
+/**
+* Split a path string into pathname, query, and hash without depending on
+* the URL constructor (which would resolve relative paths against an origin).
+*
+* Ported from Next.js: packages/next/src/shared/lib/router/utils/parse-path.ts
+*/
+function parsePath(path) {
+	const hashIndex = path.indexOf("#");
+	const queryIndex = path.indexOf("?");
+	const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+	if (hasQuery || hashIndex > -1) return {
+		pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+		query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : void 0) : "",
+		hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+	};
+	return {
+		pathname: path,
+		query: "",
+		hash: ""
+	};
+}
+/**
+* Drop trailing slashes from a route while preserving the bare root.
+*
+* Ported from Next.js: packages/next/src/shared/lib/router/utils/remove-trailing-slash.ts
+*/
+function removeRouteTrailingSlash(route) {
+	return route.replace(/\/$/, "") || "/";
+}
+/**
+* Normalise the trailing slash of a local URL according to the
+* `trailingSlash` config option in `next.config.js`. Used by the `<Link>`
+* shim so that rendered `href` attributes match the canonical URL form
+* (which is what the server-side redirect would otherwise enforce).
+*
+* Behaviour matches Next.js's client-side `normalizePathTrailingSlash`:
+* packages/next/src/client/normalize-trailing-slash.ts
+*
+* - Absolute URLs (`http://`, `https://`, `//`) and non-local strings are
+*   returned unchanged.
+* - Paths whose final segment looks like a filename (`...\.ext`) have any
+*   trailing slash stripped even when `trailingSlash: true`, mirroring the
+*   `.well-known`-aware redirect rule shipped in `routes-manifest.json`.
+* - Query strings and hash fragments are preserved verbatim.
+* - Idempotent: already-canonical paths round-trip unchanged.
+*/
+function normalizePathTrailingSlash(path, trailingSlash) {
+	if (!path.startsWith("/") || path.startsWith("//")) return path;
+	const { pathname, query, hash } = parsePath(path);
+	if (trailingSlash) {
+		if (/\.[^/]+\/?$/.test(pathname)) return `${removeRouteTrailingSlash(pathname)}${query}${hash}`;
+		if (pathname.endsWith("/")) return `${pathname}${query}${hash}`;
+		return `${pathname}/${query}${hash}`;
+	}
+	return `${removeRouteTrailingSlash(pathname)}${query}${hash}`;
+}
+/**
+* Prepend basePath to a local path for browser URLs / fetches.
+*/
+function withBasePath(path, basePath) {
+	if (!basePath || !path.startsWith("/") || isAbsoluteOrProtocolRelativeUrl(path)) return path;
+	return basePath + path;
+}
+/**
+* Resolve a potentially relative href against the current URL.
+* Handles: "#hash", "?query", "?query#hash", and relative paths.
+*/
+function resolveRelativeHref(href, currentUrl, basePath = "") {
+	const base = currentUrl ?? (typeof window !== "undefined" ? window.location.href : void 0);
+	if (!base) return href;
+	if (href.startsWith("/") || isAbsoluteOrProtocolRelativeUrl(href)) return href;
+	try {
+		const resolved = new URL(href, base);
+		return (basePath && resolved.pathname === basePath ? "" : basePath ? stripBasePath(resolved.pathname, basePath) : resolved.pathname) + resolved.search + resolved.hash;
+	} catch {
+		return href;
+	}
+}
+/**
+* Convert a local navigation target into the browser URL that should be used
+* for history entries, fetches, and onNavigate callbacks.
+*/
+function toBrowserNavigationHref(href, currentUrl, basePath = "") {
+	const resolved = resolveRelativeHref(href, currentUrl, basePath);
+	if (!basePath) return withBasePath(resolved, basePath);
+	if (resolved === "") return basePath;
+	if (resolved.startsWith("?") || resolved.startsWith("#")) return basePath + resolved;
+	return withBasePath(resolved, basePath);
+}
+function isHashOnlyBrowserUrlChange(href, currentHref, basePath = "") {
+	try {
+		const current = new URL(currentHref);
+		const next = new URL(href, currentHref);
+		return stripBasePath(current.pathname, basePath) === stripBasePath(next.pathname, basePath) && current.search === next.search && next.hash !== "";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath };

package/dist/shims/use-merged-ref.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from "react";
+
+//#region src/shims/use-merged-ref.d.ts
+declare function useMergedRef<TElement>(refA: Ref<TElement>, refB: Ref<TElement>): Ref<TElement>;
+//#endregion
+export { useMergedRef };

package/dist/shims/use-merged-ref.js

@@ -0,0 +1,38 @@
+"use client";
+import { useCallback, useRef } from "react";
+//#region src/shims/use-merged-ref.ts
+function useMergedRef(refA, refB) {
+	const cleanupA = useRef(null);
+	const cleanupB = useRef(null);
+	return useCallback((current) => {
+		if (current === null) {
+			const cleanupFnA = cleanupA.current;
+			if (cleanupFnA) {
+				cleanupA.current = null;
+				cleanupFnA();
+			}
+			const cleanupFnB = cleanupB.current;
+			if (cleanupFnB) {
+				cleanupB.current = null;
+				cleanupFnB();
+			}
+		} else {
+			if (refA) cleanupA.current = applyRef(refA, current);
+			if (refB) cleanupB.current = applyRef(refB, current);
+		}
+	}, [refA, refB]);
+}
+function applyRef(refA, current) {
+	if (typeof refA === "function") {
+		const cleanup = refA(current);
+		if (typeof cleanup === "function") return cleanup;
+		else return () => refA(null);
+	} else {
+		refA.current = current;
+		return () => {
+			refA.current = null;
+		};
+	}
+}
+//#endregion
+export { useMergedRef };

package/dist/shims/web-vitals.d.ts

@@ -0,0 +1,8 @@
+import { MetricType } from "web-vitals";
+
+//#region src/shims/web-vitals.d.ts
+type WebVitalsMetric = MetricType;
+type ReportWebVitalsCallback = (metric: WebVitalsMetric) => void;
+declare function useReportWebVitals(callback: ReportWebVitalsCallback): void;
+//#endregion
+export { type ReportWebVitalsCallback, type WebVitalsMetric, useReportWebVitals };

package/dist/shims/web-vitals.js

@@ -0,0 +1,22 @@
+import { useEffect, useRef } from "react";
+import { onCLS, onFCP, onFID, onINP, onLCP, onTTFB } from "web-vitals";
+//#region src/shims/web-vitals.ts
+function useReportWebVitals(callback) {
+	const callbackRef = useRef(callback);
+	useEffect(() => {
+		callbackRef.current = callback;
+	}, [callback]);
+	useEffect(() => {
+		const reportWebVitals = (metric) => {
+			callbackRef.current(metric);
+		};
+		onCLS(reportWebVitals);
+		onFID(reportWebVitals);
+		onLCP(reportWebVitals);
+		onINP(reportWebVitals);
+		onFCP(reportWebVitals);
+		onTTFB(reportWebVitals);
+	}, []);
+}
+//#endregion
+export { useReportWebVitals };

package/dist/typegen.d.ts

@@ -0,0 +1,9 @@
+//#region src/typegen.d.ts
+type GenerateRouteTypesOptions = {
+  root: string;
+  appDir?: string | null;
+  pageExtensions?: readonly string[];
+};
+declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<string>;
+//#endregion
+export { generateRouteTypes };

package/dist/typegen.js

@@ -0,0 +1,228 @@
+import { findDir } from "./utils/project.js";
+import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
+import { patternToNextFormat } from "./routing/route-validation.js";
+import { compareStrings } from "./utils/compare.js";
+import "./routing/app-route-graph.js";
+import { appRouteGraph } from "./routing/app-router.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/typegen.ts
+const NEXT_ENV_FILE_CONTENT = `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
+`;
+async function generateRouteTypes(options) {
+	const root = path.resolve(options.root);
+	const appDir = options.appDir ? path.resolve(options.appDir) : findDir(root, "app", path.join("src", "app"));
+	const outPath = path.join(root, ".next", "types", "routes.d.ts");
+	const content = appDir ? renderRouteTypes(await collectRouteTypeModel(appDir, options.pageExtensions)) : renderRouteTypes(emptyRouteTypeModel());
+	await fs.mkdir(path.dirname(outPath), { recursive: true });
+	await fs.writeFile(outPath, content, "utf-8");
+	await ensureNextEnvFile(root);
+	return outPath;
+}
+async function ensureNextEnvFile(root) {
+	const envPath = path.join(root, "next-env.d.ts");
+	try {
+		await fs.writeFile(envPath, NEXT_ENV_FILE_CONTENT, {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+}
+function emptyRouteTypeModel() {
+	return {
+		pageRoutes: [],
+		layoutRoutes: [],
+		routeHandlerRoutes: [],
+		params: /* @__PURE__ */ new Map(),
+		layoutSlots: /* @__PURE__ */ new Map()
+	};
+}
+async function collectRouteTypeModel(appDir, pageExtensions) {
+	const graph = await appRouteGraph(appDir, pageExtensions);
+	const model = emptyRouteTypeModel();
+	const segmentGraph = graph.routeManifest.segmentGraph;
+	const layoutRouteKeys = createLayoutRouteKeyMap(segmentGraph.layouts.values());
+	const pageRouteSet = /* @__PURE__ */ new Set();
+	const layoutRouteSet = /* @__PURE__ */ new Set();
+	const routeHandlerRouteSet = /* @__PURE__ */ new Set();
+	for (const route of segmentGraph.pages.values()) {
+		const routeEntry = segmentGraph.routes.get(route.routeId);
+		addRoute(model.pageRoutes, pageRouteSet, model.params, patternToNextFormat(route.pattern), paramsForPatternParts(routeEntry?.patternParts ?? []));
+	}
+	for (const route of segmentGraph.routeHandlers.values()) {
+		const routeEntry = segmentGraph.routes.get(route.routeId);
+		addRoute(model.routeHandlerRoutes, routeHandlerRouteSet, model.params, patternToNextFormat(route.pattern), paramsForPatternParts(routeEntry?.patternParts ?? []));
+	}
+	for (const layout of segmentGraph.layouts.values()) {
+		const route = layoutRouteKeys.get(layout.treePath) ?? treePathToRouteLiteral(layout.treePath);
+		addRoute(model.layoutRoutes, layoutRouteSet, model.params, route, paramsForPatternParts(layout.patternParts));
+	}
+	const layoutSlotSets = /* @__PURE__ */ new Map();
+	for (const slot of segmentGraph.slots.values()) {
+		const layoutRoute = layoutRouteKeyForSlot(slot, segmentGraph.layouts, layoutRouteKeys);
+		if (!layoutRoute) continue;
+		let slotNames = layoutSlotSets.get(layoutRoute);
+		if (!slotNames) {
+			slotNames = /* @__PURE__ */ new Set();
+			layoutSlotSets.set(layoutRoute, slotNames);
+			model.layoutSlots.set(layoutRoute, []);
+		}
+		if (!slotNames.has(slot.name)) {
+			slotNames.add(slot.name);
+			model.layoutSlots.get(layoutRoute)?.push(slot.name);
+		}
+	}
+	model.pageRoutes.sort(compareStrings);
+	model.layoutRoutes.sort(compareStrings);
+	model.routeHandlerRoutes.sort(compareStrings);
+	for (const slotNames of model.layoutSlots.values()) slotNames.sort(compareStrings);
+	return model;
+}
+function renderRouteTypes(model) {
+	const allRoutes = uniqueSorted([
+		...model.pageRoutes,
+		...model.layoutRoutes,
+		...model.routeHandlerRoutes
+	]);
+	return `// This file is generated by vinext. Do not edit.
+import type * as React from "react";
+
+declare global {
+  type PageProps<Route extends VinextRouteTypes.PageRoute = VinextRouteTypes.PageRoute> = {
+    params: Promise<VinextRouteTypes.ParamMap[Route]>;
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+  };
+
+  type LayoutProps<Route extends VinextRouteTypes.LayoutRoute> = {
+    params: Promise<VinextRouteTypes.ParamMap[Route]>;
+    children: React.ReactNode;
+  } & {
+    [K in VinextRouteTypes.LayoutSlotMap[Route]]: React.ReactNode;
+  };
+
+  type RouteContext<Route extends VinextRouteTypes.RouteHandlerRoute = VinextRouteTypes.RouteHandlerRoute> = {
+    params: Promise<VinextRouteTypes.ParamMap[Route]>;
+  };
+}
+
+declare namespace VinextRouteTypes {
+  type PageRoute = ${routeUnion(model.pageRoutes)};
+  type LayoutRoute = ${routeUnion(model.layoutRoutes)};
+  type RouteHandlerRoute = ${routeUnion(model.routeHandlerRoutes)};
+  type AppRoute = ${routeUnion(allRoutes)};
+
+  interface ParamMap {
+${renderParamMap(allRoutes, model.params)}
+  }
+
+  interface LayoutSlotMap {
+${renderLayoutSlotMap(model.layoutRoutes, model.layoutSlots)}
+  }
+}
+
+export {};
+`;
+}
+function renderParamMap(routes, params) {
+	if (routes.length === 0) return "    [route: string]: {};\n";
+	return routes.map((route) => `    ${quote(route)}: ${renderParamShape(params.get(route) ?? /* @__PURE__ */ new Map())};`).join("\n");
+}
+function renderParamShape(params) {
+	if (params.size === 0) return "{}";
+	return `{ ${Array.from(params.entries()).sort(([left], [right]) => compareStrings(left, right)).map(([name, kind]) => {
+		const optional = kind === "string[]?";
+		const valueType = optional ? "string[]" : kind;
+		return `${propertyName(name)}${optional ? "?" : ""}: ${valueType};`;
+	}).join(" ")} }`;
+}
+function renderLayoutSlotMap(layoutRoutes, layoutSlots) {
+	if (layoutRoutes.length === 0) return "    [route: string]: never;\n";
+	return layoutRoutes.map((route) => {
+		const slots = layoutSlots.get(route) ?? [];
+		return `    ${quote(route)}: ${routeUnion(slots)};`;
+	}).join("\n");
+}
+function paramsForPatternParts(patternParts) {
+	const params = /* @__PURE__ */ new Map();
+	for (const part of patternParts) {
+		if (!part.startsWith(":")) continue;
+		if (part.endsWith("+")) params.set(part.slice(1, -1), "string[]");
+		else if (part.endsWith("*")) params.set(part.slice(1, -1), "string[]?");
+		else params.set(part.slice(1), "string");
+	}
+	return params;
+}
+function createLayoutRouteKeyMap(layouts) {
+	const treePathsByRoute = /* @__PURE__ */ new Map();
+	for (const { treePath } of layouts) {
+		const route = treePathToRouteLiteral(treePath);
+		const treePaths = treePathsByRoute.get(route) ?? [];
+		treePaths.push(treePath);
+		treePathsByRoute.set(route, treePaths);
+	}
+	const keys = /* @__PURE__ */ new Map();
+	for (const [route, treePaths] of treePathsByRoute) for (const treePath of treePaths) keys.set(treePath, treePaths.length === 1 ? route : treePathToScopedLayoutRouteLiteral(treePath));
+	return keys;
+}
+function layoutRouteKeyForSlot(slot, layouts, layoutRouteKeys) {
+	if (!slot.ownerLayoutId) return null;
+	const layout = layouts.get(slot.ownerLayoutId);
+	if (!layout) throw new Error(`[vinext] App route graph invariant violated: slot ${slot.id} references missing owner layout ${slot.ownerLayoutId}`);
+	return layoutRouteKeys.get(layout.treePath) ?? treePathToRouteLiteral(layout.treePath);
+}
+/** Convert a layout tree path to its URL route literal, stripping invisible segments. */
+function treePathToRouteLiteral(treePath) {
+	if (treePath === "/") return "/";
+	const segments = treePath.split("/").filter(Boolean).filter((segment) => !isInvisibleSegment(segment)).map((segment) => decodeRouteSegment(segment));
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+/**
+* Convert a layout tree path to a scoped route literal that preserves
+* route-group and `@slot` segments. Used only as a fallback key when multiple
+* layouts collapse to the same URL route literal, so consumers can keep their
+* slot/params typings distinct.
+*/
+function treePathToScopedLayoutRouteLiteral(treePath) {
+	if (treePath === "/") return "/";
+	const segments = treePath.split("/").filter(Boolean).filter((segment) => segment !== ".").map((segment) => decodeRouteSegment(segment));
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function addRoute(routes, seen, params, route, paramShape) {
+	if (!seen.has(route)) {
+		seen.add(route);
+		routes.push(route);
+	}
+	const existingParamShape = params.get(route);
+	if (existingParamShape) {
+		if (!paramShapesEqual(existingParamShape, paramShape)) throw new Error(`[vinext] Conflicting route param shapes generated for ${route}`);
+		return;
+	}
+	params.set(route, paramShape);
+}
+function paramShapesEqual(left, right) {
+	if (left.size !== right.size) return false;
+	for (const [name, kind] of left) if (right.get(name) !== kind) return false;
+	return true;
+}
+function uniqueSorted(values) {
+	return Array.from(new Set(values)).sort(compareStrings);
+}
+function routeUnion(routes) {
+	if (routes.length === 0) return "never";
+	return routes.map(quote).join(" | ");
+}
+function propertyName(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : quote(name);
+}
+function quote(value) {
+	return JSON.stringify(value);
+}
+//#endregion
+export { generateRouteTypes };